/* Generated by Nim Compiler v0.11.2 */
/*   (c) 2015 Andreas Rumpf */
/* The generated code is subject to the original license. */
#define NIM_INTBITS 64
#include "nimbase.h"

#include <string.h>

#include <setjmp.h>
typedef struct Ttype191849 Ttype191849;
typedef struct Tidobj168015 Tidobj168015;
typedef struct TNimObject TNimObject;
typedef struct TNimType TNimType;
typedef struct TNimNode TNimNode;
typedef struct Ttypeseq191845 Ttypeseq191845;
typedef struct Tnode191813 Tnode191813;
typedef struct Tsym191843 Tsym191843;
typedef struct Tloc191827 Tloc191827;
typedef struct Ropeobj162009 Ropeobj162009;
typedef struct Tcell46346 Tcell46346;
typedef struct Tcellseq46362 Tcellseq46362;
typedef struct Tgcheap48216 Tgcheap48216;
typedef struct Tcellset46358 Tcellset46358;
typedef struct Tpagedesc46354 Tpagedesc46354;
typedef struct Tmemregion28210 Tmemregion28210;
typedef struct Tsmallchunk27440 Tsmallchunk27440;
typedef struct Tllchunk28204 Tllchunk28204;
typedef struct Tbigchunk27442 Tbigchunk27442;
typedef struct Tintset27417 Tintset27417;
typedef struct Ttrunk27413 Ttrunk27413;
typedef struct Tavlnode28208 Tavlnode28208;
typedef struct Tgcstat48214 Tgcstat48214;
typedef struct Tident168021 Tident168021;
typedef struct NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
typedef struct Tscope191837 Tscope191837;
typedef struct TY191944 TY191944;
typedef struct Tstrtable191817 Tstrtable191817;
typedef struct Tsymseq191815 Tsymseq191815;
typedef struct Tlineinfo164338 Tlineinfo164338;
typedef struct Tlib191831 Tlib191831;
typedef struct Tpasscontext242005 Tpasscontext242005;
typedef struct Tcontext245023 Tcontext245023;
typedef struct Tproccon245011 Tproccon245011;
typedef struct Intset188056 Intset188056;
typedef struct Ttrunk188052 Ttrunk188052;
typedef struct Ttrunkseq188054 Ttrunkseq188054;
typedef struct Tlinkedlist130028 Tlinkedlist130028;
typedef struct Tlistentry130022 Tlistentry130022;
typedef struct Tidtable191861 Tidtable191861;
typedef struct Tidpairseq191859 Tidpairseq191859;
typedef struct Tctx244048 Tctx244048;
typedef struct TY245141 TY245141;
typedef struct Tnodeseq191807 Tnodeseq191807;
typedef struct Toverloaditer250431 Toverloaditer250431;
typedef struct Tidentiter199141 Tidentiter199141;
typedef struct TY86345 TY86345;
typedef struct Tcandidate345209 Tcandidate345209;
typedef struct Trepltypevars266544 Trepltypevars266544;
typedef struct Genericctx427608 Genericctx427608;
typedef struct Tinstantiation191833 Tinstantiation191833;
typedef struct TY191933 TY191933;
typedef struct Tinstantiationpair245013 Tinstantiationpair245013;
typedef struct TY413757 TY413757;
typedef struct TY413758 TY413758;
typedef struct Toptionentry245005 Toptionentry245005;
typedef struct TY421253 TY421253;
typedef struct Templctx423582 Templctx423582;
typedef struct Slice85773 Slice85773;
typedef struct Tliftctx435286 Tliftctx435286;
typedef struct Exception Exception;
typedef struct TSafePoint TSafePoint;
typedef struct TY433269 TY433269;
typedef struct Tfieldinstctx437147 Tfieldinstctx437147;
typedef struct Tfieldsctx437309 Tfieldsctx437309;
typedef struct Ttabiter199119 Ttabiter199119;
typedef struct Trodreader234030 Trodreader234030;
typedef struct Tindex234028 Tindex234028;
typedef struct Tiitable199274 Tiitable199274;
typedef struct Tiipairseq199272 Tiipairseq199272;
typedef struct Memfile232208 Memfile232208;
typedef struct Tbasechunk27438 Tbasechunk27438;
typedef struct Tfreecell27430 Tfreecell27430;
typedef struct Tidpair191857 Tidpair191857;
typedef struct TY244253 TY244253;
typedef struct TY165033 TY165033;
typedef struct PprocHEX3Aobjecttype244232 PprocHEX3Aobjecttype244232;
typedef struct TY244272 TY244272;
typedef struct Tiipair199270 Tiipair199270;
typedef struct TY244233 TY244233;
typedef struct TY244239 TY244239;
typedef struct TY244273 TY244273;
typedef struct Vmargs244042 Vmargs244042;
typedef struct Tblock244030 Tblock244030;
typedef struct TY244213 TY244213;
typedef N_NIMCALL_PTR(void, TY3289) (void* p, NI op);
typedef N_NIMCALL_PTR(void*, TY3294) (void* p);
struct  TNimType  {
NI size;
NU8 kind;
NU8 flags;
TNimType* base;
TNimNode* node;
void* finalizer;
TY3289 marker;
TY3294 deepcopy;
};
struct  TNimObject  {
TNimType* m_type;
};
struct  Tidobj168015  {
  TNimObject Sup;
NI id;
};
struct  Tloc191827  {
NU8 k;
NU8 s;
NU16 flags;
Ttype191849* t;
Ropeobj162009* r;
Ropeobj162009* heaproot;
};
struct  Ttype191849  {
  Tidobj168015 Sup;
NU8 kind;
NU8 callconv;
NU32 flags;
Ttypeseq191845* sons;
Tnode191813* n;
Tsym191843* owner;
Tsym191843* sym;
Tsym191843* destructor;
Tsym191843* deepcopy;
Tsym191843* assignment;
NI64 size;
NI16 align;
NI16 locklevel;
Tloc191827 loc;
};
struct  TNimNode  {
NU8 kind;
NI offset;
TNimType* typ;
NCSTRING name;
NI len;
TNimNode** sons;
};
struct  Tcell46346  {
NI refcount;
TNimType* typ;
};
struct  Tcellseq46362  {
NI len;
NI cap;
Tcell46346** d;
};
struct  Tcellset46358  {
NI counter;
NI max;
Tpagedesc46354* head;
Tpagedesc46354** data;
};
typedef Tsmallchunk27440* TY28222[512];
typedef Ttrunk27413* Ttrunkbuckets27415[256];
struct  Tintset27417  {
Ttrunkbuckets27415 data;
};
struct  Tmemregion28210  {
NI minlargeobj;
NI maxlargeobj;
TY28222 freesmallchunks;
Tllchunk28204* llmem;
NI currmem;
NI maxmem;
NI freemem;
NI lastsize;
Tbigchunk27442* freechunkslist;
Tintset27417 chunkstarts;
Tavlnode28208* root;
Tavlnode28208* deleted;
Tavlnode28208* last;
Tavlnode28208* freeavlnodes;
};
struct  Tgcstat48214  {
NI stackscans;
NI cyclecollections;
NI maxthreshold;
NI maxstacksize;
NI maxstackcells;
NI cycletablesize;
NI64 maxpause;
};
struct  Tgcheap48216  {
void* stackbottom;
NI cyclethreshold;
Tcellseq46362 zct;
Tcellseq46362 decstack;
Tcellset46358 cycleroots;
Tcellseq46362 tempstack;
NI recgclock;
Tmemregion28210 region;
Tgcstat48214 stat;
};
struct  TGenericSeq  {
NI len;
NI reserved;
};
struct  NimStringDesc  {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
struct  Tstrtable191817  {
NI counter;
Tsymseq191815* data;
};
struct  Tlineinfo164338  {
NI16 line;
NI16 col;
NI32 fileindex;
};
struct  Tsym191843  {
  Tidobj168015 Sup;
NU8 kind;
union{
struct {Ttypeseq191845* typeinstcache;
Tscope191837* typscope;
} S1;
struct {TY191944* procinstcache;
Tsym191843* gcunsafetyreason;
} S2;
struct {TY191944* usedgenerics;
Tstrtable191817 tab;
} S3;
struct {Tsym191843* guard;
} S4;
} kindU;
NU16 magic;
Ttype191849* typ;
Tident168021* name;
Tlineinfo164338 info;
Tsym191843* owner;
NU32 flags;
Tnode191813* ast;
NU32 options;
NI position;
NI offset;
Tloc191827 loc;
Tlib191831* annex;
Tnode191813* constraint;
};
struct  Tpasscontext242005  {
  TNimObject Sup;
NIM_BOOL fromcache;
};
struct  Intset188056  {
NI counter;
NI max;
Ttrunk188052* head;
Ttrunkseq188054* data;
};
struct  Tlinkedlist130028  {
Tlistentry130022* head;
Tlistentry130022* tail;
NI counter;
};
struct  Tidtable191861  {
NI counter;
Tidpairseq191859* data;
};
typedef N_NIMCALL_PTR(Tnode191813*, TY245072) (Tcontext245023* c, Tnode191813* n);
typedef N_NIMCALL_PTR(Tnode191813*, TY245077) (Tcontext245023* c, Tnode191813* n, NU16 flags);
typedef N_NIMCALL_PTR(Tnode191813*, TY245085) (Tcontext245023* c, Tnode191813* n, NU16 flags);
typedef N_NIMCALL_PTR(Tnode191813*, TY245093) (Tcontext245023* c, Tnode191813* n);
typedef N_NIMCALL_PTR(Tnode191813*, TY245098) (Tcontext245023* c, Tnode191813* n, NU16 flags);
typedef N_NIMCALL_PTR(Tnode191813*, TY245106) (Tcontext245023* c, Tnode191813* n);
typedef N_NIMCALL_PTR(Tnode191813*, TY245111) (Tcontext245023* c, Tnode191813* n, Tnode191813* norig, NU32 filter);
typedef N_NIMCALL_PTR(Ttype191849*, TY245118) (Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
typedef struct {
N_NIMCALL_PTR(Tnode191813*, ClPrc) (Tcontext245023* c, Tidtable191861 pt, Tnode191813* n, void* ClEnv);
void* ClEnv;
} TY245124;
typedef struct {
N_NIMCALL_PTR(Tsym191843*, ClPrc) (Tcontext245023* c, Tsym191843* fn, Tidtable191861 pt, Tlineinfo164338 info, void* ClEnv);
void* ClEnv;
} TY245130;
typedef N_NIMCALL_PTR(Tsym191843*, TY245146) (Tcontext245023* c, Tsym191843* dc, Ttype191849* t, Tlineinfo164338 info, NU8 op);
struct  Tcontext245023  {
  Tpasscontext242005 Sup;
Tsym191843* module;
Tscope191837* currentscope;
Tscope191837* importtable;
Tscope191837* toplevelscope;
Tproccon245011* p;
Tsymseq191815* friendmodules;
NI instcounter;
Intset188056 ambiguoussymbols;
NI intypeclass;
NI ingenericcontext;
NI inunrolledcontext;
NI incompilescontext;
NI ingenericinst;
Tsymseq191815* converters;
Tsymseq191815* patterns;
Tlinkedlist130028 optionstack;
Tidtable191861 symmapping;
Tlinkedlist130028 libs;
TY245072 semconstexpr;
TY245077 semexpr;
TY245085 semtryexpr;
TY245093 semtryconstexpr;
TY245098 semoperand;
TY245106 semconstboolexpr;
TY245111 semoverloadedcall;
TY245118 semtypenode;
TY245124 seminferredlambda;
TY245130 semgenerateinstance;
Intset188056 includedfiles;
Tstrtable191817 userpragmas;
Tctx244048* evalcontext;
Intset188056 unknownidents;
TY245141* generics;
NI lastgenericidx;
NI hloloopdetector;
NI inparallelstmt;
TY245146 insttypeboundop;
};
struct  Tnode191813  {
Ttype191849* typ;
Tlineinfo164338 info;
NU16 flags;
NU8 kind;
union{
struct {NI64 intval;
} S1;
struct {NF floatval;
} S2;
struct {NimStringDesc* strval;
} S3;
struct {Tsym191843* sym;
} S4;
struct {Tident168021* ident;
} S5;
struct {Tnodeseq191807* sons;
} S6;
} kindU;
NimStringDesc* comment;
};
struct  Tproccon245011  {
Tsym191843* owner;
Tsym191843* resultsym;
NI nestedloopcounter;
NI nestedblockcounter;
NI intrystmt;
Tproccon245011* next;
NIM_BOOL wasforwarded;
Tnode191813* bracketexpr;
};
struct  Tident168021  {
  Tidobj168015 Sup;
NimStringDesc* s;
Tident168021* next;
NI h;
};
typedef NU8 TY433644[20];
typedef Tnode191813* TY417419[2];
typedef Ttype191849* TY417424[2];
struct  Tidentiter199141  {
NI h;
Tident168021* name;
};
struct  Toverloaditer250431  {
Tidentiter199141 it;
Tsym191843* m;
NU8 mode;
NI symchoiceindex;
Tscope191837* scope;
Intset188056 insymchoice;
};
typedef NimStringDesc* TY155965[2];
struct TY86345 {
NimStringDesc* Field0;
NI Field1;
};
struct  Tcandidate345209  {
Tcontext245023* c;
NI exactmatches;
NI genericmatches;
NI subtypematches;
NI intconvmatches;
NI convmatches;
NU8 state;
Ttype191849* callee;
Tsym191843* calleesym;
NI calleescope;
Tnode191813* call;
Tidtable191861 bindings;
NIM_BOOL basetypematch;
NU8 fauxmatch;
NIM_BOOL genericconverter;
NIM_BOOL coercedistincts;
NIM_BOOL typedescmatched;
NI inheritancepenalty;
Tsymseq191815* errors;
};
struct  Trepltypevars266544  {
Tcontext245023* c;
Tidtable191861 typemap;
Tidtable191861 symmap;
Tidtable191861 localcache;
Tlineinfo164338 info;
NIM_BOOL allowmetatypes;
NIM_BOOL skiptypedesc;
};
struct  Genericctx427608  {
Intset188056 tomixin;
NIM_BOOL cursorinbody;
};
struct  Tinstantiation191833  {
Tsym191843* sym;
Ttypeseq191845* concretetypes;
TY191933* usedby;
};
struct  Tinstantiationpair245013  {
Tsym191843* genericsym;
Tinstantiation191833* inst;
};
typedef NU8 Tspecialwords173012[33];
typedef Ttype191849* TY245864[2];
typedef Tnode191813* TY447930[3];
struct  Tscope191837  {
NI depthlevel;
Tstrtable191817 symbols;
Tnodeseq191807* usingsyms;
Tscope191837* parent;
};
struct TY413758 {
Tsym191843* Field0;
NI Field1;
};
typedef Ttype191849* TY350187[1];
struct  Tlistentry130022  {
  TNimObject Sup;
Tlistentry130022* prev;
Tlistentry130022* next;
};
struct  Toptionentry245005  {
  Tlistentry130022 Sup;
NU32 options;
NU8 defaultcc;
Tlib191831* dynlib;
NU64 notes;
Tnode191813* otherpragmas;
};
struct  TY421253  {
NI HEX3Astate;
NimStringDesc* paramname420285;
Tnode191813* genericparams420283;
Tlineinfo164338 info420286;
Tcontext245023* c420281;
};
typedef struct {
N_NIMCALL_PTR(Ttype191849*, ClPrc) (Ttype191849* typeclass, Tident168021* typid, void* ClEnv);
void* ClEnv;
} TY420302;
typedef N_CLOSURE_PTR(Ttype191849*, TMP3135) (Ttype191849* typeclass, Tident168021* typid);
typedef N_CLOSURE_PTR(Ttype191849*, TMP3136) (Ttype191849* typeclass, Tident168021* typid);
typedef N_CLOSURE_PTR(Ttype191849*, TMP3137) (Ttype191849* typeclass, Tident168021* typid);
typedef N_CLOSURE_PTR(Ttype191849*, TMP3138) (Ttype191849* typeclass, Tident168021* typid);
typedef N_CLOSURE_PTR(Ttype191849*, TMP3139) (Ttype191849* typeclass, Tident168021* typid);
typedef N_CLOSURE_PTR(Ttype191849*, TMP3140) (Ttype191849* typeclass, Tident168021* typid);
typedef N_CLOSURE_PTR(Ttype191849*, TMP3141) (Ttype191849* typeclass, Tident168021* typid);
typedef N_CLOSURE_PTR(Ttype191849*, TMP3142) (Ttype191849* typeclass, Tident168021* typid);
typedef N_CLOSURE_PTR(Ttype191849*, TMP3144) (Ttype191849* typeclass, Tident168021* typid);
typedef N_CLOSURE_PTR(Ttype191849*, TMP3145) (Ttype191849* typeclass, Tident168021* typid);
struct  Templctx423582  {
Tcontext245023* c;
Intset188056 tobind;
Intset188056 tomixin;
Intset188056 toinject;
Tsym191843* owner;
NIM_BOOL cursorinbody;
};
typedef Tsym191843* TY433049[2];
typedef Tnode191813* TY246103[2];
struct  Slice85773  {
NI a;
NI b;
};
typedef Tnode191813* TY194071[7];
typedef Tnode191813* TY209680[1];
typedef NU8 TY444856[33];
typedef NimStringDesc* TY443654[2];
typedef N_NIMCALL_PTR(Tnode191813*, Transformation407013) (Tcontext245023* c, Tnode191813* n);
typedef NimStringDesc* TY177061[3];
typedef NimStringDesc* TY165566[1];
struct  Tliftctx435286  {
Tcontext245023* c;
Tlineinfo164338 info;
NU8 kind;
Tsym191843* fn;
Ttype191849* asgnfortype;
NIM_BOOL recurse;
};
struct  Exception  {
  TNimObject Sup;
Exception* parent;
NCSTRING name;
NimStringDesc* message;
NimStringDesc* trace;
};
typedef struct {
N_NIMCALL_PTR(NIM_BOOL, ClPrc) (Exception* e, void* ClEnv);
void* ClEnv;
} TY15609;
struct  TSafePoint  {
TSafePoint* prev;
NI status;
jmp_buf context;
NIM_BOOL hasRaiseAction;
TY15609 raiseAction;
};
typedef N_CLOSURE_PTR(Tsym191843*, TMP3415) (Tcontext245023* c, Tsym191843* fn, Tidtable191861 pt, Tlineinfo164338 info);
struct TY433269 {
Tnode191813* Field0;
Tnode191813* Field1;
};
struct  Tfieldinstctx437147  {
Ttype191849* tupletype;
NI tupleindex;
Tsym191843* field;
NIM_BOOL replacebyfieldname;
};
struct  Tfieldsctx437309  {
Tcontext245023* c;
NU16 m;
};
typedef N_NIMCALL_PTR(Tnode191813*, TY242069) (Tsym191843* m, NI32 fileidx);
struct  Ttabiter199119  {
NI h;
};
typedef N_CLOSURE_PTR(Tnode191813*, TMP3479) (Tcontext245023* c, Tidtable191861 pt, Tnode191813* n, void* ClEnv);
typedef N_CLOSURE_PTR(Tsym191843*, TMP3480) (Tcontext245023* c, Tsym191843* fn, Tidtable191861 pt, Tlineinfo164338 info, void* ClEnv);
struct  Tiitable199274  {
NI counter;
Tiipairseq199272* data;
};
struct  Tindex234028  {
NI lastidxkey;
NI lastidxval;
Tiitable199274 tab;
NimStringDesc* r;
NI offset;
};
struct  Memfile232208  {
void* mem;
NI size;
int handle;
};
struct  Trodreader234030  {
  TNimObject Sup;
NI pos;
NCSTRING s;
NU32 options;
NU8 reason;
TY191933* moddeps;
TY191933* files;
NI dataidx;
NI convertersidx;
NI initidx;
NI interfidx;
NI compilerprocsidx;
NI methodsidx;
NimStringDesc* filename;
Tindex234028 index;
Tindex234028 imports;
NI readerindex;
NI line;
NI moduleid;
Tidtable191861 syms;
Memfile232208 memfile;
Tsymseq191815* methods;
NimStringDesc* origfile;
NIM_BOOL inviewmode;
};
struct  Ropeobj162009  {
  TNimObject Sup;
Ropeobj162009* left;
Ropeobj162009* right;
NI length;
NimStringDesc* data;
};
typedef NI TY27420[8];
struct  Tpagedesc46354  {
Tpagedesc46354* next;
NI key;
TY27420 bits;
};
struct  Tbasechunk27438  {
NI prevsize;
NI size;
NIM_BOOL used;
};
struct  Tsmallchunk27440  {
  Tbasechunk27438 Sup;
Tsmallchunk27440* next;
Tsmallchunk27440* prev;
Tfreecell27430* freelist;
NI free;
NI acc;
NF data;
};
struct  Tllchunk28204  {
NI size;
NI acc;
Tllchunk28204* next;
};
struct  Tbigchunk27442  {
  Tbasechunk27438 Sup;
Tbigchunk27442* next;
Tbigchunk27442* prev;
NI align;
NF data;
};
struct  Ttrunk27413  {
Ttrunk27413* next;
NI key;
TY27420 bits;
};
typedef Tavlnode28208* TY28214[2];
struct  Tavlnode28208  {
TY28214 link;
NI key;
NI upperbound;
NI level;
};
struct  Tlib191831  {
  Tlistentry130022 Sup;
NU8 kind;
NIM_BOOL generated;
NIM_BOOL isoverriden;
Ropeobj162009* name;
Tnode191813* path;
};
struct  Ttrunk188052  {
Ttrunk188052* next;
NI key;
TY27420 bits;
};
struct  Tidpair191857  {
Tidobj168015* key;
TNimObject* val;
};
struct  Tctx244048  {
  Tpasscontext242005 Sup;
TY244253* code;
TY165033* debug;
Tnode191813* globals;
Tnode191813* constants;
Ttypeseq191845* types;
Tnode191813* currentexceptiona;
Tnode191813* currentexceptionb;
NI exceptioninstr;
PprocHEX3Aobjecttype244232* prc;
Tsym191843* module;
Tnode191813* callsite;
NU8 mode;
NU8 features;
NIM_BOOL traceactive;
NI loopiterations;
Tlineinfo164338 comesfromheuristic;
TY244272* callbacks;
NimStringDesc* errorflag;
};
struct  Tiipair199270  {
NI key;
NI val;
};
struct  Tfreecell27430  {
Tfreecell27430* next;
NI zerofield;
};
struct TY244239 {
NIM_BOOL Field0;
NU8 Field1;
};
typedef TY244239 TY244236[256];
struct  PprocHEX3Aobjecttype244232  {
TY244233* blocks;
Tsym191843* sym;
TY244236 slots;
NI maxslots;
};
typedef struct {
N_NIMCALL_PTR(void, ClPrc) (Vmargs244042* args, void* ClEnv);
void* ClEnv;
} Vmcallback244044;
struct TY244273 {
NimStringDesc* Field0;
Vmcallback244044 Field1;
};
struct  Tblock244030  {
Tsym191843* label;
TY244213* fixups;
};
struct  Vmargs244042  {
NI ra;
NI rb;
NI rc;
void* slots;
Tnode191813* currentexception;
};
struct Tsymseq191815 {
  TGenericSeq Sup;
  Tsym191843* data[SEQ_DECL_SIZE];
};
struct Ttypeseq191845 {
  TGenericSeq Sup;
  Ttype191849* data[SEQ_DECL_SIZE];
};
struct TY191944 {
  TGenericSeq Sup;
  Tinstantiation191833* data[SEQ_DECL_SIZE];
};
struct TY245141 {
  TGenericSeq Sup;
  Tinstantiationpair245013 data[SEQ_DECL_SIZE];
};
struct Tnodeseq191807 {
  TGenericSeq Sup;
  Tnode191813* data[SEQ_DECL_SIZE];
};
struct TY413757 {
  TGenericSeq Sup;
  TY413758 data[SEQ_DECL_SIZE];
};
struct Ttrunkseq188054 {
  TGenericSeq Sup;
  Ttrunk188052* data[SEQ_DECL_SIZE];
};
struct Tidpairseq191859 {
  TGenericSeq Sup;
  Tidpair191857 data[SEQ_DECL_SIZE];
};
struct TY191933 {
  TGenericSeq Sup;
  NI32 data[SEQ_DECL_SIZE];
};
struct Tiipairseq199272 {
  TGenericSeq Sup;
  Tiipair199270 data[SEQ_DECL_SIZE];
};
struct TY244253 {
  TGenericSeq Sup;
  NU32 data[SEQ_DECL_SIZE];
};
struct TY165033 {
  TGenericSeq Sup;
  Tlineinfo164338 data[SEQ_DECL_SIZE];
};
struct TY244272 {
  TGenericSeq Sup;
  TY244273 data[SEQ_DECL_SIZE];
};
struct TY244233 {
  TGenericSeq Sup;
  Tblock244030 data[SEQ_DECL_SIZE];
};
struct TY244213 {
  TGenericSeq Sup;
  NI data[SEQ_DECL_SIZE];
};
N_NIMCALL(void*, newObj)(TNimType* typ, NI size);
static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src);
static N_INLINE(Tcell46346*, usrtocell_49846)(void* usr);
static N_INLINE(void, rtladdzct_51404)(Tcell46346* c);
N_NOINLINE(void, addzct_49817)(Tcellseq46362* s, Tcell46346* c);
N_NIMCALL(Tident168021*, getident_168463)(NimStringDesc* identifier);
static N_INLINE(void, nimGCunrefNoCycle)(void* p);
N_NIMCALL(void*, newObjRC1)(TNimType* typ, NI size);
N_NIMCALL(Tnode191813*, newidentnode_193313)(Tident168021* ident, Tlineinfo164338 info);
N_NIMCALL(Tlineinfo164338, unknownlineinfo_165024)(void);
N_NIMCALL(Tcontext245023*, newcontext_245181)(Tsym191843* module);
N_NIMCALL(void, internalerror_166199)(Tlineinfo164338 info, NimStringDesc* errmsg);
N_NIMCALL(Tnode191813*, semconstexpr_411485)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semexprwithtype_410211)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semexpr_410201)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(void, suggestexpr_355070)(Tcontext245023* c, Tnode191813* node);
N_NIMCALL(Tsym191843*, lookup_250804)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, semcapturesym_362834)(Tsym191843* s, Tsym191843* owner);
N_NIMCALL(Tnode191813*, semsym_442038)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU16 flags);
N_NIMCALL(void, markused_345251)(Tlineinfo164338 info, Tsym191843* s);
N_NIMCALL(Ttype191849*, skiptypes_195167)(Ttype191849* t, NU64 kinds);
static N_INLINE(Tnode191813*, inlineconst_442028)(Tnode191813* n, Tsym191843* s);
N_NIMCALL(Tnode191813*, copytree_196028)(Tnode191813* src);
N_NIMCALL(Tnode191813*, newsymnode_193338)(Tsym191843* sym, Tlineinfo164338 info);
static N_INLINE(NI, len_192097)(Tnode191813* n);
N_NIMCALL(Tnode191813*, semmacroexpr_411066)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, Tsym191843* sym, NU16 flags);
N_NIMCALL(void, pushinfocontext_165189)(Tlineinfo164338 info);
N_NIMCALL(void, globalerror_166134)(Tlineinfo164338 info, NU16 msg, NimStringDesc* arg);
N_NIMCALL(Tnode191813*, evalmacrocall_398902)(Tsym191843* module, Tnode191813* n, Tnode191813* norig, Tsym191843* sym);
N_NIMCALL(Tnode191813*, semaftermacrocall_416431)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU16 flags);
N_NIMCALL(Tsym191843*, getmodule_199243)(Tsym191843* s);
N_NIMCALL(TGenericSeq*, incrSeq)(TGenericSeq* seq, NI elemsize);
N_NIMCALL(Tnode191813*, semstmt_410277)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semexprnotype_410221)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, discardcheck_433756)(Tcontext245023* c, Tnode191813* result);
N_NIMCALL(void, message_166188)(Tlineinfo164338 info, NU16 msg, NimStringDesc* arg);
N_NIMCALL(NIM_BOOL, implicitlydiscardable_433645)(Tnode191813* n_433647);
N_NIMCALL(Tnode191813*, lastson_194431)(Tnode191813* n);
N_NIMCALL(NIM_BOOL, iscallexpr_192071)(Tnode191813* n);
N_NIMCALL(void, fixniltype_433694)(Tnode191813* n);
static N_INLINE(NIM_BOOL, isatom_196906)(Tnode191813* n);
N_NIMCALL(void, localerror_166155)(Tlineinfo164338 info, NU16 msg, NimStringDesc* arg);
N_NIMCALL(NimStringDesc*, typetostring_221032)(Ttype191849* typ, NU8 prefer);
N_NIMCALL(Ttype191849*, semtypenode_410269)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(void, checksonslen_246249)(Tnode191813* n, NI length);
N_NIMCALL(NI, sonslen_194403)(Tnode191813* n);
N_NIMCALL(Ttype191849*, semanontuple_418414)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Ttype191849*, neworprevtype_416695)(NU8 kind, Ttype191849* prev, Tcontext245023* c);
N_NIMCALL(Ttype191849*, newtypes_245218)(NU8 kind, Tcontext245023* c);
N_NIMCALL(void, addsonskipintlit_239731)(Ttype191849* father, Ttype191849* son);
static N_INLINE(NIM_BOOL, isrange_220612)(Tnode191813* n);
static N_INLINE(Tnode191813*, HEX5BHEX5D_192244)(Tnode191813* n, NI i);
N_NIMCALL(Ttype191849*, semrangeaux_417292)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Tnode191813*, newnodei_193351)(NU8 kind, Tlineinfo164338 info);
static N_INLINE(Ttype191849*, skipintlit_239698)(Ttype191849* t);
N_NIMCALL(Ttype191849*, getsystype_239030)(NU8 kind);
N_NIMCALL(NIM_BOOL, sametype_226092)(Ttype191849* a, Ttype191849* b, NU8 flags);
N_NIMCALL(NIM_BOOL, isordinaltype_221093)(Ttype191849* t);
N_NIMCALL(NIM_BOOL, enumhasholes_221099)(Ttype191849* t);
N_NIMCALL(NIM_BOOL, hasgenericarguments_266765)(Tnode191813* n);
N_NIMCALL(void, addson_193819)(Tnode191813* father, Tnode191813* son);
N_NIMCALL(Tnode191813*, makestaticexpr_245820)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NU8, weaklevalue_199424)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(Ttype191849*, semtypeexpr_422172)(Tcontext245023* c, Tnode191813* n_422175);
N_NIMCALL(Ttype191849*, base_221039)(Ttype191849* t);
N_NIMCALL(NimStringDesc*, rendertree_213058)(Tnode191813* n, NU8 renderflags);
N_NIMCALL(Tident168021*, considerquotedident_250010)(Tnode191813* n);
static N_INLINE(NIM_BOOL, eqStrings)(NimStringDesc* a, NimStringDesc* b);
N_NIMCALL(Ttype191849*, makeandtype_245858)(Tcontext245023* c, Ttype191849* t1, Ttype191849* t2);
N_NIMCALL(Ttype191849*, makeortype_245930)(Tcontext245023* c, Ttype191849* t1, Ttype191849* t2);
static N_INLINE(Ttype191849*, freshtype_422192)(Ttype191849* res, Ttype191849* prev);
N_NIMCALL(Ttype191849*, copytype_194549)(Ttype191849* t, Tsym191843* owner, NIM_BOOL keepid);
N_NIMCALL(Ttype191849*, makenottype_246002)(Tcontext245023* c, Ttype191849* t1);
N_NIMCALL(Ttype191849*, semanyref_417112)(Tcontext245023* c, Tnode191813* n_417115, NU8 kind, Ttype191849* prev);
N_NIMCALL(Ttype191849*, newconstraint_416725)(Tcontext245023* c, NU8 k);
N_NIMCALL(void, checkminsonslen_246259)(Tnode191813* n, NI length);
N_NIMCALL(Tnode191813*, semwhen_411040)(Tcontext245023* c, Tnode191813* n, NIM_BOOL semcheck);
N_NIMCALL(void, illformedast_246229)(Tnode191813* n);
N_NIMCALL(void, idsynchronizationpoint_190453)(NI idrange);
N_NIMCALL(Tsym191843*, semtypeident_417777)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tsym191843*, qualifiedlookup_250864)(Tcontext245023* c, Tnode191813* n, NU8 flags);
N_NIMCALL(Tsym191843*, errorsym_250372)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tsym191843*, copysym_194607)(Tsym191843* s, NIM_BOOL keepid);
N_NIMCALL(NI, len_194377)(Ttype191849* n);
N_NIMCALL(Tsym191843*, initoverloaditer_251108)(Toverloaditer250431* o, Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tsym191843*, nextoverloaditer_251277)(Toverloaditer250431* o, Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, genericReset)(void* dest, TNimType* mt);
N_NIMCALL(Ttype191849*, semarray_417720)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Ttype191849*, semarrayindex_417610)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Ttype191849*, makerangewithstaticexpr_246084)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Ttype191849*, makerangetype_246182)(Tcontext245023* c, NI64 first, NI64 last, Tlineinfo164338 info, Ttype191849* inttype);
N_NIMCALL(Ttype191849*, lastson_194442)(Ttype191849* n);
N_NIMCALL(Ttype191849*, semcontainer_417086)(Tcontext245023* c, Tnode191813* n, NU8 kind, NimStringDesc* kindstr, Ttype191849* prev);
N_NIMCALL(Ttype191849*, errortype_246150)(Tcontext245023* c);
N_NIMCALL(Ttype191849*, semrange_417501)(Tcontext245023* c, Tnode191813* n_417504, Ttype191849* prev);
N_NIMCALL(Ttype191849*, semset_417057)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(NI64, lengthord_221016)(Ttype191849* t);
N_NIMCALL(Ttype191849*, semordinal_417756)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Ttype191849*, semvarargs_417099)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Ttype191849*, maketypedesc_245681)(Tcontext245023* c, Ttype191849* typ);
N_NIMCALL(Tsym191843*, getcurrowner_245255)(void);
N_NIMCALL(void, rawaddson_195478)(Ttype191849* father, Ttype191849* son);
N_NIMCALL(Ttype191849*, semgeneric_421923)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, Ttype191849* prev);
N_NIMCALL(void, localerror_166166)(Tlineinfo164338 info, NimStringDesc* arg);
N_NIMCALL(NimStringDesc*, nsuFormatOpenArray)(NimStringDesc* formatstr, NimStringDesc** a, NI aLen0);
N_NIMCALL(NimStringDesc*, copyString)(NimStringDesc* src);
N_NIMCALL(NimStringDesc*, nsuToLowerStr)(NimStringDesc* s);
N_NIMCALL(NimStringDesc*, copyStr)(NimStringDesc* s, NI start);
N_NIMCALL(NimStringDesc*, copyStr)(NimStringDesc* s, NI first);
N_NIMCALL(NimStringDesc*, reprEnum)(NI e_82529, TNimType* typ);
N_NIMCALL(Ttype191849*, semgenericparamininvocation_421915)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, internalerror_166218)(NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, HEX24_166306)(TY86345 x);
N_NIMCALL(void, newcandidate_345478)(Tcontext245023* ctx, Ttype191849* callee, Tcandidate345209* Result);
N_NOINLINE(void, chckNil)(void* p);
N_NIMCALL(void, matches_351449)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, Tcandidate345209* m);
static N_INLINE(void, appendString)(NimStringDesc* dest, NimStringDesc* src);
N_NIMCALL(NimStringDesc*, describeargs_345974)(Tcontext245023* c, Tnode191813* n, NI startidx, NU8 prefer);
N_NIMCALL(NimStringDesc*, rawNewString)(NI space);
N_NIMCALL(NIM_BOOL, containsgenerictype_230310)(Ttype191849* t);
N_NIMCALL(Ttype191849*, instgenericcontainer_413151)(Tcontext245023* c, Tlineinfo164338 info, Ttype191849* header, NIM_BOOL allowmetatypes);
N_NIMCALL(void, initidtable_195057)(Tidtable191861* x);
N_NIMCALL(Ttype191849*, replacetypevarst_266592)(Trepltypevars266544* cl, Ttype191849* t);
N_NIMCALL(NIM_BOOL, ismetatype_192821)(Ttype191849* t);
N_NIMCALL(Tnode191813*, semgenericstmt_416688)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, initintset_188927)(Intset188056* Result);
N_NIMCALL(Tnode191813*, semgenericstmt_427618)(Tcontext245023* c, Tnode191813* n, NU8 flags_427622, Genericctx427608* ctx);
N_NIMCALL(Tnode191813*, lookup_429004)(Tcontext245023* c, Tnode191813* n, NU8 flags, Genericctx427608* ctx);
N_NIMCALL(Tsym191843*, skipalias_250150)(Tsym191843* s, Tnode191813* n);
N_NIMCALL(Tsym191843*, searchinscopes_250205)(Tcontext245023* c, Tident168021* s);
N_NIMCALL(NIM_BOOL, contains_188829)(Intset188056* s, NI key);
N_NIMCALL(Tnode191813*, symchoice_423316)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU8 r);
N_NIMCALL(Tnode191813*, newnodeit_193807)(NU8 kind, Tlineinfo164338 info, Ttype191849* typ);
N_NIMCALL(Tnode191813*, semgenericstmtsymbol_427643)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, Genericctx427608* ctx);
N_NIMCALL(Tnode191813*, semtemplateexpr_411055)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU16 flags);
N_NIMCALL(Tnode191813*, evaltemplate_384260)(Tnode191813* n, Tsym191843* tmpl, Tsym191843* gensymowner);
N_NIMCALL(void, popinfocontext_165208)(void);
N_NIMCALL(Tnode191813*, newsymnodetypedesc_258736)(Tsym191843* s, Tlineinfo164338 info);
N_NIMCALL(Tnode191813*, fuzzylookup_429062)(Tcontext245023* c, Tnode191813* n_429065, NU8 flags, Genericctx427608* ctx, NIM_BOOL* ismacro);
N_NIMCALL(Tnode191813*, newdot_429051)(Tnode191813* n, Tnode191813* b);
N_NIMCALL(void, add_192164)(Tnode191813* father, Tnode191813* son);
N_NIMCALL(Tnode191813*, semmixinstmt_423521)(Tcontext245023* c, Tnode191813* n, Intset188056* tomixin);
N_NIMCALL(void, incl_188856)(Intset188056* s, NI key);
N_NIMCALL(Tnode191813*, semgenericstmtscope_427625)(Tcontext245023* c, Tnode191813* n, NU8 flags, Genericctx427608* ctx);
N_NIMCALL(Tscope191837*, openscope_250091)(Tcontext245023* c);
N_NIMCALL(void, closescope_250111)(Tcontext245023* c);
N_NIMCALL(void, addtempdecl_429491)(Tcontext245023* c, Tnode191813* n, NU8 kind);
N_NIMCALL(Tsym191843*, newsyms_410904)(NU8 kind, Tnode191813* n, Tcontext245023* c);
N_NIMCALL(Tsym191843*, newsym_192655)(NU8 symkind, Tident168021* name, Tsym191843* owner, Tlineinfo164338 info);
N_NIMCALL(Tnode191813*, getidentnode_427598)(Tnode191813* n);
N_NIMCALL(void, addprelimdecl_250619)(Tcontext245023* c, Tsym191843* sym);
N_NIMCALL(void, adddecl_250607)(Tcontext245023* c, Tsym191843* sym);
N_NIMCALL(Tnode191813*, getbody_236647)(Tsym191843* s);
N_NIMCALL(Ttype191849*, maketypefromexpr_245726)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, assigntype_194452)(Ttype191849* dest, Ttype191849* src);
N_NIMCALL(Ttype191849*, semobjectnode_420016)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Ttype191849*, skiptypesornil_195195)(Ttype191849* t, NU64 kinds);
static N_INLINE(Ttype191849*, skipgenericinvocation_419764)(Ttype191849* t);
N_NIMCALL(void, addinheritedfields_419798)(Tcontext245023* c, Intset188056* check, NI* pos, Ttype191849* obj);
N_NIMCALL(NI, sonslen_194351)(Ttype191849* n);
N_NIMCALL(void, addinheritedfieldsaux_419668)(Tcontext245023* c, Intset188056* check, NI* pos, Tnode191813* n);
N_NIMCALL(void, semrecordnodeaux_419088)(Tcontext245023* c, Tnode191813* n, Intset188056* check, NI* pos, Tnode191813* father, Ttype191849* rectype);
N_NIMCALL(Tnode191813*, semconstboolexpr_416652)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, fitnode_410245)(Tcontext245023* c, Ttype191849* formal, Tnode191813* arg);
N_NIMCALL(Tnode191813*, copynode_195640)(Tnode191813* src);
N_NIMCALL(Tnode191813*, indextypesmatch_410348)(Tcontext245023* c, Ttype191849* f, Ttype191849* a, Tnode191813* arg);
N_NIMCALL(void, initcandidate_345276)(Tcontext245023* ctx, Tcandidate345209* c, Ttype191849* callee);
N_NIMCALL(Tnode191813*, paramtypesmatch_350556)(Tcandidate345209* m, Ttype191849* f, Ttype191849* a, Tnode191813* arg, Tnode191813* argorig);
N_NIMCALL(void, instgenericconvertersarg_415176)(Tcontext245023* c, Tnode191813* a, Tcandidate345209* x);
N_NIMCALL(NIM_BOOL, isgenericroutine_196652)(Tsym191843* s);
N_NIMCALL(Tsym191843*, generateinstance_413450)(Tcontext245023* c, Tsym191843* fn, Tidtable191861 pt, Tlineinfo164338 info);
N_NIMCALL(void, pushowner_245260)(Tsym191843* owner);
N_NIMCALL(Tnode191813*, newsymnode_193325)(Tsym191843* sym);
N_NIMCALL(Tinstantiation191833*, new_413524)(void);
N_NIMCALL(void, instantiategenericparamlist_412213)(Tcontext245023* c, Tnode191813* n, Tidtable191861 pt, Tinstantiation191833* entry);
N_NIMCALL(void*, newSeq)(TNimType* typ, NI len);
N_NIMCALL(void, unsureAsgnRef)(void** dest, void* src);
N_NIMCALL(TNimObject*, idtableget_199182)(Tidtable191861 t, Tidobj168015* key);
N_NIMCALL(Ttype191849*, generatetypeinstance_268631)(Tcontext245023* p, Tidtable191861 pt, Tlineinfo164338 info, Ttype191849* t);
static N_INLINE(void, pushproccon_245358)(Tcontext245023* c, Tsym191843* owner);
static N_INLINE(void, asgnRef)(void** dest, void* src);
static N_INLINE(void, incref_52222)(Tcell46346* c);
static N_INLINE(NIM_BOOL, canbecycleroot_49867)(Tcell46346* c);
static N_INLINE(void, rtladdcycleroot_50623)(Tcell46346* c);
N_NOINLINE(void, incl_47065)(Tcellset46358* s, Tcell46346* cell);
static N_INLINE(void, decref_51804)(Tcell46346* c);
N_NIMCALL(void, instantiateproctype_413176)(Tcontext245023* c, Tidtable191861 pt, Tsym191843* prc, Tlineinfo164338 info);
N_NIMCALL(void, inittypevars_268602)(Tcontext245023* p, Tidtable191861 pt, Tlineinfo164338 info, Trepltypevars266544* Result);
N_NIMCALL(Ttype191849*, instcopytype_267470)(Trepltypevars266544* cl, Ttype191849* t);
N_NIMCALL(Tnode191813*, shallowcopy_195817)(Tnode191813* src);
N_NIMCALL(void, resetidtable_195077)(Tidtable191861* x);
N_NIMCALL(void, propagatetoowner_195274)(Ttype191849* owner, Ttype191849* elem);
N_NIMCALL(void, erasevoidparams_267982)(Ttype191849* t);
N_NIMCALL(void, skipintliteralparams_268136)(Ttype191849* t);
N_NIMCALL(void, maybeaddresult_410301)(Tcontext245023* c, Tsym191843* s, Tnode191813* n);
N_NIMCALL(void, addresult_438997)(Tcontext245023* c, Ttype191849* t, Tlineinfo164338 info, NU8 owner);
N_NIMCALL(void, addparamorresult_412885)(Tcontext245023* c, Tsym191843* param, NU8 kind);
N_NIMCALL(Ttype191849*, findenforcedstatictype_420139)(Ttype191849* t_420141);
N_NIMCALL(Tsym191843*, getcompilerproc_239036)(NimStringDesc* name);
N_NIMCALL(Tsym191843*, getsyssym_239054)(NimStringDesc* name);
N_NIMCALL(void, addresultnode_439031)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tsym191843*, genericcacheget_412447)(Tsym191843* genericsym, Tinstantiation191833* entry);
N_NIMCALL(NIM_BOOL, HEX3DHEX3D_194870)(TY191944* x, TY191944* y);
N_NIMCALL(NIM_BOOL, sameinstantiation_412394)(Tinstantiation191833* a, Tinstantiation191833* b);
N_NIMCALL(NIM_BOOL, comparetypes_228047)(Ttype191849* x, Ttype191849* y, NU8 cmp, NU8 flags);
N_NIMCALL(void, safeadd_413561)(TY191944** x, Tinstantiation191833* y);
N_NIMCALL(void, makeinstpair_245157)(Tsym191843* s, Tinstantiation191833* inst, Tinstantiationpair245013* Result);
N_NIMCALL(void, pragma_261069)(Tcontext245023* c, Tsym191843* sym, Tnode191813* n, Tspecialwords173012 validpragmas);
N_NIMCALL(void, instantiatebody_412941)(Tcontext245023* c, Tnode191813* n, Tnode191813* params, Tsym191843* result);
N_NIMCALL(void, idtableput_199196)(Tidtable191861* t, Tidobj168015* key, TNimObject* val);
N_NIMCALL(void, freshgensyms_412801)(Tnode191813* n, Tsym191843* owner, Tidtable191861* symmap);
static N_INLINE(NI, safelen_192125)(Tnode191813* n);
N_NIMCALL(Tnode191813*, semprocbody_410238)(Tcontext245023* c, Tnode191813* n);
static N_INLINE(NIM_BOOL, isemptytype_196934)(Ttype191849* t);
N_NIMCALL(Tnode191813*, newnodei_193407)(NU8 kind, Tlineinfo164338 info, NI children);
N_NIMCALL(Tnode191813*, semasgn_448081)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, builtinfieldaccess_446958)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(NIM_BOOL, istypeexpr_446444)(Tnode191813* n);
N_NIMCALL(Tsym191843*, getsymfromlist_199228)(Tnode191813* list, Tident168021* ident, NI start);
N_NIMCALL(Tnode191813*, readtypeparameter_446877)(Tcontext245023* c, Ttype191849* typ, Tident168021* paramname, Tlineinfo164338 info);
N_NIMCALL(Ttype191849*, skipgenericalias_227119)(Ttype191849* t);
N_NIMCALL(Tsym191843*, linkto_192884)(Tsym191843* s, Ttype191849* t);
N_NIMCALL(Ttype191849*, newtypewithsons_245807)(Tcontext245023* c, NU8 kind, Ttypeseq191845* sons);
N_NIMCALL(Tsym191843*, lookupinrecordandbuildcheck_446604)(Tcontext245023* c, Tnode191813* n, Tnode191813* r, Tident168021* field, Tnode191813** check);
N_NIMCALL(Ttype191849*, createsettype_446461)(Tcontext245023* c, Ttype191849* basetype);
static N_INLINE(NIM_BOOL, fieldvisible_352059)(Tcontext245023* c, Tsym191843* f);
N_NIMCALL(Tnode191813*, makederef_446833)(Tnode191813* n);
N_NIMCALL(Tnode191813*, propertywriteaccess_447920)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, Tnode191813* a);
static N_INLINE(void, appendChar)(NimStringDesc* dest, NIM_CHAR c);
N_NIMCALL(Tnode191813*, newnode_193607)(NU8 kind, Tlineinfo164338 info, Tnodeseq191807* sons, Ttype191849* typ);
N_NIMCALL(Tnode191813*, semoverloadedcallanalyseeffects_445901)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, NU16 flags);
N_NIMCALL(Tnode191813*, semoverloadedcall_415892)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, NU32 filter);
N_NIMCALL(void, resolveoverloads_414359)(Tcontext245023* c, Tnode191813* n, Tnode191813* orig, NU32 filter, Tsymseq191815** errors, Tcandidate345209* Result);
N_NIMCALL(void, gatherusedsyms_414249)(Tcontext245023* c, Tnodeseq191807** usedsyms);
N_NIMCALL(NIM_BOOL, HEX3DHEX3D_264718)(Tnodeseq191807* x, Tnodeseq191807* y);
N_NIMCALL(void, safeadd_414279)(Tnodeseq191807** x, Tnode191813* y);
N_NIMCALL(void, insert_414412)(Tnodeseq191807** x, Tnode191813* item, NI i);
N_NIMCALL(void, pickbestcandidate_413740)(Tcontext245023* c, Tnode191813* headsymbol, Tnode191813* n, Tnode191813* orig, Tnode191813* initialbinding, NU32 filter, Tcandidate345209* best, Tcandidate345209* alt, Tsymseq191815** errors);
N_NIMCALL(NI, lastoverloadscope_251259)(Toverloaditer250431* o);
N_NIMCALL(void, nimGCvisit)(void* d, NI op);
N_NIMCALL(void, TMP3105)(void* p, NI op);
N_NIMCALL(void, initcandidate_345301)(Tcontext245023* ctx, Tcandidate345209* c, Tsym191843* callee, Tnode191813* binding, NI calleescope);
N_NIMCALL(void, determinetype_413736)(Tcontext245023* c, Tsym191843* s);
N_NIMCALL(Tnode191813*, semprocaux_439890)(Tcontext245023* c, Tnode191813* n, NU8 kind, Tspecialwords173012 validpragmas, NU8 phase);
N_NIMCALL(Tnode191813*, semprocannotation_439127)(Tcontext245023* c, Tnode191813* prc, Tspecialwords173012 validpragmas);
N_NIMCALL(Tsym191843*, lookupmacro_439097)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tsym191843*, searchinscopes_250323)(Tcontext245023* c, Tident168021* s, NU32 filter);
N_NIMCALL(Tnode191813*, copyexcept_439050)(Tnode191813* n, NI i);
N_NIMCALL(Tsym191843*, semidentdef_435142)(Tcontext245023* c, Tnode191813* n, NU8 kind);
static N_INLINE(NIM_BOOL, istoplevel_246269)(Tcontext245023* c);
N_NIMCALL(Tsym191843*, semidentwithpragma_410964)(Tcontext245023* c, NU8 kind, Tnode191813* n, NU32 allowed);
N_NIMCALL(Tsym191843*, semidentvis_410955)(Tcontext245023* c, NU8 kind, Tnode191813* n, NU32 allowed);
N_NIMCALL(Tsym191843*, newsymg_410916)(NU8 kind, Tnode191813* n, Tcontext245023* c);
static N_INLINE(void, suggestsym_354960)(Tlineinfo164338 info, Tsym191843* s);
N_NIMCALL(void, findusages_354892)(Tlineinfo164338 info, Tsym191843* s);
N_NIMCALL(void, finddefinition_354923)(Tlineinfo164338 info, Tsym191843* s);
N_NIMCALL(void, addinterfaceoverloadablesymat_250746)(Tcontext245023* c, Tscope191837* scope, Tsym191843* sym);
N_NIMCALL(Tnode191813*, semgenericparamlist_422951)(Tcontext245023* c, Tnode191813* n, Ttype191849* father);
N_NIMCALL(Ttype191849*, semgenericconstraints_422930)(Tcontext245023* c, Ttype191849* x);
N_NIMCALL(void, semparamlist_410284)(Tcontext245023* c, Tnode191813* n, Tnode191813* genericparams, Tsym191843* s);
N_NIMCALL(Ttype191849*, semproctypenode_421351)(Tcontext245023* c, Tnode191813* n, Tnode191813* genericparams, Ttype191849* prev, NU8 kind, NIM_BOOL istype);
N_NIMCALL(Ttype191849*, newproctype_421342)(Tcontext245023* c, Tlineinfo164338 info, Ttype191849* prev);
N_NIMCALL(Toptionentry245005*, lastoptionentry_245187)(Tcontext245023* c);
N_NIMCALL(Ttype191849*, semparamtype_421322)(Tcontext245023* c, Tnode191813* n, Tnode191813** constraint);
N_NIMCALL(Tnode191813*, semnodekindconstraints_269679)(Tnode191813* p);
N_NIMCALL(Ttype191849*, liftparamtype_420279)(Tcontext245023* c, NU8 prockind, Tnode191813* genericparams, Ttype191849* paramtype, NimStringDesc* paramname, Tlineinfo164338 info, NIM_BOOL anon);
N_NIMCALL(void, TMP3133)(void* p, NI op);
N_NIMCALL(NimStringDesc*, copyStringRC1)(NimStringDesc* src);
N_CLOSURE(Ttype191849*, addimplicitgenericimpl_420301)(Ttype191849* typeclass, Tident168021* typid, void* ClEnv);
N_NIMCALL(NIM_BOOL, containsorincl_188898)(Intset188056* s, NI key);
N_NIMCALL(NIM_BOOL, isinlineiterator_349999)(Ttype191849* t);
N_NIMCALL(Tnode191813*, sempattern_424548)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, flattenstmts_220759)(Tnode191813* n);
N_NIMCALL(Tnode191813*, sempatternbody_426870)(Templctx423582* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, handlesym_427201)(Templctx423582* c, Tnode191813* n, Tsym191843* s);
N_NIMCALL(Tnode191813*, newparam_426884)(Templctx423582* c, Tnode191813* n, Tsym191843* s);
N_NIMCALL(Tnode191813*, sembindstmt_423421)(Tcontext245023* c, Tnode191813* n, Intset188056* tobind);
N_NIMCALL(Tnode191813*, expectparam_427264)(Templctx423582* c, Tnode191813* n);
N_NIMCALL(Tsym191843*, searchforproc_260278)(Tcontext245023* c, Tscope191837* scope, Tsym191843* fn);
N_NIMCALL(void, addinterfacedeclat_250677)(Tcontext245023* c, Tscope191837* scope, Tsym191843* sym);
N_NIMCALL(void, implicitpragmas_264505)(Tcontext245023* c, Tsym191843* sym, Tnode191813* n, Tspecialwords173012 validpragmas);
N_NIMCALL(void, wrongredefinition_250588)(Tlineinfo164338 info, NimStringDesc* s);
N_NIMCALL(void, addgenericparamlisttoscope_438141)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, addparams_410293)(Tcontext245023* c, Tnode191813* n, NU8 kind);
static N_INLINE(NIM_BOOL, importantcomments_155164)(void);
N_NIMCALL(void, popowner_245266)(void);
N_NIMCALL(void, semoverride_439632)(Tcontext245023* c, Tsym191843* s, Tnode191813* n);
N_NIMCALL(NimStringDesc*, nsuNormalize)(NimStringDesc* s);
N_NIMCALL(void, dodestructorstuff_432427)(Tcontext245023* c, Tsym191843* s, Tnode191813* n);
N_NIMCALL(Ttype191849*, instantiatedestructor_432423)(Tcontext245023* c, Ttype191849* typ);
static N_INLINE(NIM_BOOL, contains_433053)(Tsym191843** a, NI aLen0, Tsym191843* item);
static N_INLINE(NI, find_433063)(Tsym191843** a, NI aLen0, Tsym191843* item);
N_NIMCALL(Tnode191813*, generatedestructor_432970)(Tcontext245023* c, Ttype191849* t);
N_NIMCALL(Tnode191813*, destroyfieldorfields_432596)(Tcontext245023* c, Tnode191813* field, Tnode191813* holder);
N_NIMCALL(Tnode191813*, destroycase_432652)(Tcontext245023* c, Tnode191813* n, Tnode191813* holder);
N_NIMCALL(Tnodeseq191807*, HEX5BHEX5D_432717)(Tnodeseq191807* s, Slice85773 x);
static N_INLINE(Slice85773, HEX2EHEX2E_105273)(NI a, NI b);
N_NIMCALL(Tnode191813*, newnode_192401)(NU8 kind);
N_NIMCALL(Tnode191813*, destroysym_432601)(Tcontext245023* c, Tsym191843* field, Tnode191813* holder);
N_NIMCALL(Tnode191813*, usesym_355055)(Tsym191843* sym);
N_NIMCALL(Tnode191813*, symnodefromtype_411113)(Tcontext245023* c, Ttype191849* t, Tlineinfo164338 info);
N_NIMCALL(Tsym191843*, symfromtype_411078)(Ttype191849* t, Tlineinfo164338 info);
N_NIMCALL(Ttype191849*, makevartype_245642)(Tcontext245023* c, Ttype191849* basetype);
N_NIMCALL(Tnode191813*, semproc_432397)(Tcontext245023* c, Tnode191813* n);
static N_INLINE(NIM_BOOL, experimentalmode_246279)(Tcontext245023* c);
static N_INLINE(void, paramstypecheck_411015)(Tcontext245023* c, Ttype191849* typ);
N_NIMCALL(void, typeallowedcheck_410980)(Tlineinfo164338 info, Ttype191849* typ, NU8 kind);
N_NIMCALL(Ttype191849*, typeallowed_229654)(Ttype191849* t, NU8 kind);
N_NIMCALL(Tnode191813*, hlobody_412161)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, hlo_411542)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, applypatterns_411630)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, applyrule_402303)(Tcontext245023* c, Tsym191843* s, Tnode191813* n);
N_NIMCALL(Tnode191813*, evalpattern_411546)(Tcontext245023* c, Tnode191813* n, Tnode191813* orig);
N_NIMCALL(Tnode191813*, semdirectop_411032)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, aftercallactions_446367)(Tcontext245023* c, Tnode191813* n, Tnode191813* orig, NU16 flags);
N_NIMCALL(void, semfinishoperands_351385)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, activate_410327)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, fixabstracttype_444407)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, changetype_410253)(Tnode191813* n, Ttype191849* newtype, NIM_BOOL check);
N_NIMCALL(Ttype191849*, elemtype_221522)(Ttype191849* t);
N_NIMCALL(NI64, firstord_221004)(Ttype191849* t);
N_NIMCALL(NI64, lastord_221010)(Ttype191849* t);
N_NIMCALL(NimStringDesc*, nimInt64ToStr)(NI64 x);
N_NIMCALL(void, analyseifaddresstakenincall_444851)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NU8, isassignable_444642)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NU8, isassignable_270056)(Tsym191843* owner, Tnode191813* n);
N_NIMCALL(void, semprocvarcheck_432366)(Tcontext245023* c, Tnode191813* n_432369);
N_NIMCALL(Tnode191813*, skipconv_230935)(Tnode191813* n);
N_NIMCALL(void, performprocvarcheck_432302)(Tcontext245023* c, Tnode191813* n, Tsym191843* s);
N_NIMCALL(Tnode191813*, analyseifaddresstaken_444699)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, newhiddenaddrtaken_444650)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, magicsafteroverloadresolution_445354)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semaddr_445049)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Ttype191849*, makeptrtype_245211)(Tcontext245023* c, Ttype191849* basetype);
N_NIMCALL(Tnode191813*, semtypeof_445070)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semispartof_445082)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(NU8, ispartof_400375)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(Tnode191813*, newintnodet_257028)(NI64 intval, Tnode191813* n);
N_NIMCALL(Tnode191813*, semtypetraits_445167)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, evaltypetrait_445130)(Tnode191813* trait, Ttype191849* operand, Tsym191843* context);
N_NIMCALL(Tnode191813*, newstrnode_192643)(NU8 kind, NimStringDesc* strval);
N_NIMCALL(Ttype191849*, newtype_194140)(NU8 kind, Tsym191843* owner);
N_NIMCALL(Tnode191813*, newintnode_192607)(NU8 kind, NI64 intval);
N_NIMCALL(Tnode191813*, newstrnodet_257042)(NimStringDesc* strval, Tnode191813* n);
N_NIMCALL(Tnode191813*, seminstantiationinfo_445111)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NI, expectintlit_445100)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tlineinfo164338, getinfocontext_165234)(NI index);
N_NIMCALL(NimStringDesc*, tofullpath_165273)(NI32 fileidx);
N_NIMCALL(NimStringDesc*, tofilename_165263)(NI32 fileidx);
static N_INLINE(NI, tolinenumber_165439)(Tlineinfo164338 info);
N_NIMCALL(Tnode191813*, semord_445205)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semlowhigh_443647)(Tcontext245023* c, Tnode191813* n, NU16 m);
N_NIMCALL(Tnode191813*, semshallowcopy_445277)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, sembindsym_445215)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, errornode_246160)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NIM_BOOL, isnegative_445299)(Tnode191813* n_445301);
N_NIMCALL(NU8, checkforsideeffects_269869)(Tnode191813* n);
N_NIMCALL(NimStringDesc*, nsuFormatSingleElem)(NimStringDesc* formatstr, NimStringDesc* a);
N_NIMCALL(NIM_BOOL, isstrangearray_445282)(Ttype191849* t_445284);
N_NIMCALL(Tsym191843*, createmagic_196987)(NimStringDesc* name, NU16 m);
N_NIMCALL(Transformation407013, getplugin_407094)(Tsym191843* fn);
N_NIMCALL(Tnode191813*, evalatcompiletime_445429)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, getconstexpr_257004)(Tsym191843* m, Tnode191813* n);
N_NIMCALL(Ttype191849*, getintervaltype_257365)(NU16 m, Tnode191813* n);
N_NIMCALL(Tnode191813*, evalstaticexpr_398832)(Tsym191843* module, Tnode191813* e, Tsym191843* prc);
N_NIMCALL(Tnode191813*, fixuptypeaftereval_411201)(Tcontext245023* c, Tnode191813* evaluated, Tnode191813* eorig);
N_NIMCALL(void, annotatetype_403134)(Tnode191813* n, Ttype191849* t);
N_NIMCALL(Tnode191813*, evalconstexpr_398821)(Tsym191843* module, Tnode191813* e);
N_NIMCALL(Tnode191813*, commonoptimizations_370597)(Tsym191843* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, transformbody_371118)(Tsym191843* module, Tnode191813* n, Tsym191843* prc);
static N_INLINE(void, popproccon_245390)(Tcontext245023* c);
N_NIMCALL(void, fixupinstantiatedsymbols_413063)(Tcontext245023* c, Tsym191843* s);
N_NIMCALL(void, semborrow_438975)(Tcontext245023* c, Tnode191813* n, Tsym191843* s);
N_NIMCALL(Tsym191843*, searchforborrowproc_416322)(Tcontext245023* c, Tscope191837* startscope, Tsym191843* fn);
N_NIMCALL(Ttype191849*, baseofdistinct_230320)(Ttype191849* t);
N_NIMCALL(void, sideeffectscheck_413116)(Tcontext245023* c, Tsym191843* s);
N_NIMCALL(NIM_BOOL, HEX3DHEX3D_413853)(Tsymseq191815* x, Tsymseq191815* y);
N_NIMCALL(void, safeadd_413966)(Tsymseq191815** x, Tsym191843* y);
N_NIMCALL(void, genericAssign)(void* dest, void* src, TNimType* mt);
N_NIMCALL(NI, cmpcandidates_345824)(Tcandidate345209* a, Tcandidate345209* b);
N_NIMCALL(void, delete_414490)(Tnodeseq191807** x, NI i);
N_NIMCALL(Tnode191813*, withinfo_193302)(Tnode191813* n, Tlineinfo164338 info);
N_NIMCALL(void, HEX5BHEX5DHEX3D_414619)(Tnodeseq191807** s, Slice85773 x, Tnode191813** b, NI bLen0);
static N_INLINE(NimStringDesc*, HEX5BHEX5D_85766)(NimStringDesc* s, Slice85773 x);
N_NIMCALL(NimStringDesc*, copyStrLast)(NimStringDesc* s, NI start_76243, NI last);
N_NIMCALL(NimStringDesc*, copyStrLast)(NimStringDesc* s, NI first, NI last);
N_NIMCALL(NIM_BOOL, samemethoddispatcher_413675)(Tsym191843* a, Tsym191843* b);
N_NIMCALL(NimStringDesc*, resizeString)(NimStringDesc* dest, NI addlen);
N_NIMCALL(NimStringDesc*, msgkindtostring_165616)(NU16 kind);
N_NIMCALL(NimStringDesc*, getprocheader_221447)(Tsym191843* sym, NU8 prefer);
N_NIMCALL(Tnode191813*, semresolvedcall_415507)(Tcontext245023* c, Tnode191813* n, Tcandidate345209* x);
N_NIMCALL(void, instgenericconverterssons_415212)(Tcontext245023* c, Tnode191813* n, Tcandidate345209* x);
static N_INLINE(NIM_BOOL, canderef_415851)(Tnode191813* n);
N_NIMCALL(Tnode191813*, tryderef_415884)(Tnode191813* n);
N_NIMCALL(void, notfounderror_414121)(Tcontext245023* c, Tnode191813* n_414124, Tsymseq191815* errors);
N_NIMCALL(NimStringDesc*, addChar)(NimStringDesc* s, NIM_CHAR c);
N_NIMCALL(Tnode191813*, dottransformation_447679)(Tcontext245023* c, Tnode191813* n);
static N_INLINE(NIM_BOOL, issymchoice_443471)(Tnode191813* n);
N_NIMCALL(Tnode191813*, semsubscript_447774)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semderef_447761)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NI64, getordvalue_221178)(Tnode191813* n);
N_NIMCALL(Tnode191813*, buildoverloadedsubscripts_447722)(Tnode191813* n, Tident168021* ident);
N_NIMCALL(NU8, cmptypes_349708)(Tcontext245023* c, Ttype191849* f, Ttype191849* a);
N_NIMCALL(void, typemismatch_410379)(Tnode191813* n, Ttype191849* formal, Ttype191849* actual);
N_NIMCALL(Tnode191813*, overloadedasgn_436296)(Tcontext245023* c, Tnode191813* dest, Tnode191813* src);
N_NIMCALL(Tsym191843*, getasgnorliftbody_436276)(Tcontext245023* c, Ttype191849* typ, Tlineinfo164338 info);
N_NIMCALL(Tsym191843*, liftbody_435301)(Tcontext245023* c, Ttype191849* typ, Tlineinfo164338 info);
N_NIMCALL(Ttype191849*, newproctype_436194)(Tlineinfo164338 info, Tsym191843* owner);
N_NIMCALL(void, addparam_436202)(Ttype191849* proctype, Tsym191843* param);
N_NIMCALL(void, liftbodyaux_435293)(Tliftctx435286* c, Ttype191849* t, Tnode191813* body, Tnode191813* x, Tnode191813* y);
N_NIMCALL(void, defaultop_436006)(Tliftctx435286* c, Ttype191849* t, Tnode191813* body, Tnode191813* x, Tnode191813* y);
N_NIMCALL(Tnode191813*, newasgnstmt_435510)(Tnode191813* le, Tnode191813* ri);
N_NIMCALL(Tnode191813*, newseqcall_436101)(Tcontext245023* c, Tnode191813* x, Tnode191813* y);
N_NIMCALL(Tnode191813*, genbuiltin_436065)(NU16 magic, NimStringDesc* name, Tnode191813* i);
N_NIMCALL(Tnode191813*, declarecounter_436039)(Tliftctx435286* c, Tnode191813* body, NI64 first);
N_NIMCALL(void, addvar_436027)(Tnode191813* father, Tnode191813* v, Tnode191813* value);
N_NIMCALL(Tnode191813*, newintlit_360438)(NI64 value);
N_NIMCALL(Tnode191813*, genwhileloop_436077)(Tliftctx435286* c, Tnode191813* i, Tnode191813* dest);
N_NIMCALL(Tnode191813*, genhigh_360448)(Tnode191813* n);
N_NIMCALL(Tnode191813*, at_435306)(Tnode191813* a, Tnode191813* i, Ttype191849* elemtype);
N_NIMCALL(void, addincstmt_436091)(Tnode191813* body, Tnode191813* i);
N_NIMCALL(NIM_BOOL, consideroverloadedop_435540)(Tliftctx435286* c, Ttype191849* t, Tnode191813* body, Tnode191813* x, Tnode191813* y);
N_NIMCALL(Tnode191813*, newdestructorcall_435520)(Tsym191843* op, Tnode191813* x);
N_NIMCALL(Tnode191813*, newasgncall_435485)(Tcontext245023* c, Tsym191843* op, Tnode191813* x, Tnode191813* y);
N_NIMCALL(Tnode191813*, genaddr_435467)(Tcontext245023* c, Tnode191813* x);
N_NIMCALL(Tnode191813*, newdeepcopycall_435531)(Tsym191843* op, Tnode191813* x, Tnode191813* y);
N_NIMCALL(void, liftbodyobj_435378)(Tliftctx435286* c, Tnode191813* n, Tnode191813* body, Tnode191813* x, Tnode191813* y);
N_NIMCALL(Tnode191813*, dotfield_435367)(Tnode191813* x, Tsym191843* f);
N_NIMCALL(void, illformedastlocal_246239)(Tnode191813* n);
N_NIMCALL(void, liftbodytup_435317)(Tliftctx435286* c, Ttype191849* t, Tnode191813* body, Tnode191813* x, Tnode191813* y);
static N_INLINE(Tnode191813*, newderef_358024)(Tnode191813* n);
static N_INLINE(void, asgntoresultvar_448017)(Tcontext245023* c, Tnode191813* n, Tnode191813* le, Tnode191813* ri);
N_NIMCALL(Tnode191813*, takeimplicitaddr_447986)(Tcontext245023* c, Tnode191813* n);
static N_INLINE(Tsym191843*, pop_368918)(Tsymseq191815** s);
N_NIMCALL(TGenericSeq*, setLengthSeq)(TGenericSeq* seq, NI elemsize, NI newlen);
N_NIMCALL(void, finishmethod_410341)(Tcontext245023* c, Tsym191843* s);
N_NIMCALL(NIM_BOOL, hasobjparam_440633)(Tsym191843* s);
N_NIMCALL(void, methoddef_356634)(Tsym191843* s, NIM_BOOL fromcache);
N_NIMCALL(Tnode191813*, skiphiddensubconv_231078)(Tnode191813* n);
N_NIMCALL(Tnode191813*, forcebool_416629)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, assign_188946)(Intset188056* dest, Intset188056* src);
N_NIMCALL(void, semrecordcase_419098)(Tcontext245023* c, Tnode191813* n, Intset188056* check, NI* pos, Tnode191813* father, Ttype191849* rectype);
N_NIMCALL(void, semcasebranch_418947)(Tcontext245023* c, Tnode191813* t, Tnode191813* branch, NI branchindex, NI64* covered);
N_NIMCALL(Tnode191813*, semcasebranchrange_418900)(Tcontext245023* c, Tnode191813* t, Tnode191813* b, NI64* covered);
N_NIMCALL(Tnode191813*, sembranchrange_418878)(Tcontext245023* c, Tnode191813* t, Tnode191813* a, Tnode191813* b, NI64* covered);
N_NIMCALL(Tnode191813*, skipconvtaketype_230967)(Tnode191813* n);
N_NIMCALL(NIM_BOOL, emptyrange_241034)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(void, delson_195577)(Tnode191813* father, NI idx);
N_NIMCALL(Tnode191813*, semcasebranchsetelem_418913)(Tcontext245023* c, Tnode191813* t, Tnode191813* b, NI64* covered);
N_NIMCALL(void, checkforoverlap_418804)(Tcontext245023* c, Tnode191813* t, NI currentex, NI branchindex);
N_NIMCALL(NIM_BOOL, overlap_241012)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(Ropeobj162009*, rope_162320)(NimStringDesc* s);
N_NIMCALL(Ttype191849*, semtuple_418454)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Ttype191849*, semtypeclass_422208)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(void, safeadd_266489)(Ttypeseq191845** x, Ttype191849* y);
N_NIMCALL(Ttype191849*, semvartype_417260)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Ttype191849*, semdistinct_417280)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Ttype191849*, semproctypewithscope_422277)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev, NU8 kind);
N_NIMCALL(void, seteffectsforproctype_330412)(Ttype191849* t, Tnode191813* n);
N_NIMCALL(NIM_BOOL, haspragma_264698)(Tnode191813* n, NU16 pragma);
N_NIMCALL(Ttype191849*, semenum_416733)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(void, strtableadd_199103)(Tstrtable191817* t, Tsym191843* n);
N_NIMCALL(Ttype191849*, semstmtlisttype_421829)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
N_NIMCALL(Ttype191849*, semblocktype_421873)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev);
static N_INLINE(void, markindirect_246197)(Tcontext245023* c, Tsym191843* s);
N_NIMCALL(void, setintlittype_239776)(Tnode191813* result);
N_NIMCALL(Ttype191849*, getfloatlittype_239688)(Tnode191813* literal);
N_NIMCALL(Tnode191813*, semfieldaccess_441814)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semconv_443510)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, maybelifttype_443488)(Ttype191849** t, Tcontext245023* c, Tlineinfo164338 info);
N_NIMCALL(Tnode191813*, inferwithmetatype_410463)(Tcontext245023* c, Ttype191849* formal, Tnode191813* arg, NIM_BOOL coercedistincts);
N_NIMCALL(NU8, checkconvertible_443223)(Tcontext245023* c, Ttype191849* castdest, Ttype191849* src);
N_NIMCALL(NU8, checkconversionbetweenobjects_443209)(Ttype191849* castdest, Ttype191849* src);
N_NIMCALL(NI, inheritancediff_228064)(Ttype191849* a, Ttype191849* b);
N_NIMCALL(Tnode191813*, semobjconstr_446041)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(void, checkinitialized_450320)(Tnode191813* n, Intset188056* ids, Tlineinfo164338 info);
N_NIMCALL(Tnode191813*, semmagic_449578)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU16 flags);
N_NIMCALL(Tnode191813*, semdefined_448719)(Tcontext245023* c, Tnode191813* n, NIM_BOOL onlycurrentscope);
N_NIMCALL(NIM_BOOL, isdefined_169167)(Tident168021* symbol);
N_NIMCALL(Tsym191843*, lookupfordefined_448670)(Tcontext245023* c, Tnode191813* n, NIM_BOOL onlycurrentscope);
N_NIMCALL(Tsym191843*, lookupfordefined_448661)(Tcontext245023* c, Tident168021* i, NIM_BOOL onlycurrentscope);
N_NIMCALL(Tsym191843*, localsearchinscope_250194)(Tcontext245023* c, Tident168021* s);
N_NIMCALL(Tsym191843*, strtableget_199111)(Tstrtable191817 t, Tident168021* name);
N_NIMCALL(Tnode191813*, setms_449568)(Tnode191813* n, Tsym191843* s);
N_NIMCALL(Tnode191813*, semcompiles_449463)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, tryexpr_410317)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(NI, getinfocontextlen_165153)(void);
N_NIMCALL(void*, newSeqRC1)(TNimType* typ, NI len);
static N_INLINE(void, pushSafePoint)(TSafePoint* s);
static N_INLINE(void, popSafePoint)(void);
N_NIMCALL(NIM_BOOL, isObj)(TNimType* obj, TNimType* subclass);
static N_INLINE(Exception*, getCurrentException)(void);
static N_INLINE(void, popCurrentException)(void);
N_NIMCALL(void, reraiseException)(void);
N_NIMCALL(void, genericSeqAssign)(void* dest, void* src_81204, TNimType* mt);
N_NIMCALL(void, setinfocontextlen_165170)(NI L);
N_NIMCALL(Tnode191813*, semsizeof_443694)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semis_443917)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, maketypesymnode_245711)(Tcontext245023* c, Ttype191849* typ, Tlineinfo164338 info);
N_NIMCALL(Tnode191813*, isopimpl_411048)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NU8, typerel_346064)(Tcandidate345209* c, Ttype191849* f, Ttype191849* aorig, NIM_BOOL dobind);
N_NIMCALL(Tnode191813*, semof_443705)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semexpandtoast_449069)(Tcontext245023* c, Tnode191813* n, Tsym191843* magicsym, NU16 flags);
N_NIMCALL(Tnode191813*, semexpandtoast_448913)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tsym191843*, expectmacroortemplatecall_411025)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Ttype191849*, systypefromname_239213)(NimStringDesc* name);
N_NIMCALL(Tnode191813*, semquoteast_410334)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NimStringDesc*, expectstring_448791)(Tcontext245023* c, Tnode191813* n_448794);
N_NIMCALL(Tnodeseq191807*, newseq_449261)(NI len);
N_NIMCALL(void, processquotations_449082)(Tnode191813** n, NimStringDesc* op, Tnodeseq191807** quotes, Tnodeseq191807** ids);
N_NIMCALL(NimStringDesc*, nimIntToStr)(NI x);
N_NIMCALL(NIM_BOOL, nsuStartsWith)(NimStringDesc* s, NimStringDesc* prefix);
N_NIMCALL(Tsym191843*, newanonsym_448826)(NU8 kind, Tlineinfo164338 info, Tsym191843* owner);
N_NIMCALL(Tnode191813*, semtemplatedef_426550)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semtemplbodydirty_426220)(Templctx423582* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semtemplbody_423688)(Templctx423582* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semtemplsymbol_424011)(Tcontext245023* c, Tnode191813* n, Tsym191843* s);
N_NIMCALL(void, openscope_423693)(Templctx423582* c);
N_NIMCALL(void, closescope_423700)(Templctx423582* c);
N_NIMCALL(Tnode191813*, semtemplbodyscope_423707)(Templctx423582* c, Tnode191813* n);
N_NIMCALL(void, addlocaldecl_423875)(Templctx423582* c, Tnode191813** n, NU8 k);
N_NIMCALL(NU8, symbinding_423251)(Tnode191813* n);
N_NIMCALL(NU16, whichkeyword_173386)(Tident168021* id);
N_NIMCALL(Tnode191813*, onlyreplaceparams_423716)(Templctx423582* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, getidentnode_423589)(Templctx423582* c, Tnode191813* n);
static N_INLINE(NIM_BOOL, istemplparam_423636)(Templctx423582* c, Tnode191813* n);
N_NIMCALL(void, replaceidentbysym_423569)(Tnode191813** n, Tnode191813* s);
N_NIMCALL(Tsym191843*, newgensym_423843)(NU8 kind, Tnode191813* n, Templctx423582* c);
N_NIMCALL(void, semtemplsomedecl_424438)(Templctx423582* c, Tnode191813* n, NU8 symkind, NI start);
N_NIMCALL(Tnode191813*, semroutineintemplbody_424236)(Templctx423582* c, Tnode191813* n, NU8 k);
N_NIMCALL(Tnode191813*, semroutineintemplname_424054)(Templctx423582* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, transformtoexpr_426509)(Tnode191813* n);
N_NIMCALL(void, symtabreplace_203415)(Tstrtable191817* t, Tsym191843* prevsym, Tsym191843* newsym);
N_NIMCALL(Tsym191843*, getmagicsym_448811)(NU16 magic);
N_NIMCALL(NU8, spawnresult_359965)(Ttype191849* t, NIM_BOOL inparallel);
N_NIMCALL(Ttype191849*, createflowvar_449503)(Tcontext245023* c, Ttype191849* t, Tlineinfo164338 info);
N_NIMCALL(Tsym191843*, instantiatecreateflowvarcall_449513)(Tcontext245023* c, Ttype191849* t, Tlineinfo164338 info);
N_NIMCALL(Tnode191813*, semindirectop_446072)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(void, semopaux_443960)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, resolveindirectcall_446046)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, Ttype191849* t, Tcandidate345209* Result);
N_NIMCALL(Tnode191813*, overloadedcallopr_444019)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, setgenericparams_451037)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semsymgenericinstantiation_442019)(Tcontext245023* c, Tnode191813* n, Tsym191843* s);
N_NIMCALL(Tnode191813*, explicitgenericinstantiation_416005)(Tcontext245023* c, Tnode191813* n, Tsym191843* s_416009);
N_NIMCALL(Tnode191813*, explicitgenericsym_415939)(Tcontext245023* c, Tnode191813* n, Tsym191843* s);
N_NIMCALL(Tnode191813*, explicitgenericinsterror_415932)(Tnode191813* n);
N_NIMCALL(Tnode191813*, semarrayaccess_447898)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(NU8, checkpar_449990)(Tnode191813* n);
N_NIMCALL(Tnode191813*, semtuplepositionsconstr_450204)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(NIM_BOOL, istupletype_450260)(Tnode191813* n);
N_NIMCALL(Tnode191813*, semtuplefieldsconstr_450092)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semsetconstr_449734)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semarrayconstr_444273)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Ttype191849*, commontype_410477)(Ttype191849* x, Ttype191849* y);
N_NIMCALL(NIM_BOOL, HEX3DHEX3D_230739)(Ttypeseq191845* x, Ttypeseq191845* y);
N_NIMCALL(NIM_BOOL, isemptycontainer_230978)(Ttype191849* t);
N_NIMCALL(Ttype191849*, commonsuperclass_228468)(Ttype191849* a, Ttype191849* b);
N_NIMCALL(Tnode191813*, semlambda_410261)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semdo_439430)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semcast_443625)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NIM_BOOL, iscastable_443383)(Ttype191849* dst, Ttype191849* src);
N_NIMCALL(NI64, computesize_221184)(Ttype191849* typ);
N_NIMCALL(Tnode191813*, semif_433860)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semexprbranch_433604)(Tcontext245023* c, Tnode191813* n);
static N_INLINE(void, semdestructorcheck_433440)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semexprbranchscope_433635)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semtableconstr_449895)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semstaticexpr_445882)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semblock_450650)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semstmtlist_441086)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semtry_434715)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NIM_BOOL, usesresult_441004)(Tnode191813* n);
N_NIMCALL(void, insertdestructors_433265)(Tcontext245023* c, Tnode191813* varsection, TY433269* Result);
N_NIMCALL(Tnode191813*, semraise_438101)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semvarorlet_436418)(Tcontext245023* c, Tnode191813* n, NU8 symkind);
N_NIMCALL(void, suggeststmt_355301)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, newsons_194272)(Tnode191813* father, NI length);
N_NIMCALL(void, addtovarsection_436306)(Tcontext245023* c, Tnode191813** result, Tnode191813* orig, Tnode191813* identdefs);
N_NIMCALL(NIM_BOOL, isdiscardunderscore_436399)(Tsym191843* v);
N_NIMCALL(void, addinterfacedecl_250736)(Tcontext245023* c, Tsym191843* sym);
N_NIMCALL(Tsym191843*, findshadowedvar_435035)(Tcontext245023* c, Tsym191843* v);
N_NIMCALL(NIM_BOOL, identwithin_435093)(Tnode191813* n, Tident168021* s);
N_NIMCALL(void, checknilable_435204)(Tsym191843* v);
N_NIMCALL(void, setupcompiletimevar_398855)(Tsym191843* module, Tnode191813* n);
N_NIMCALL(Tnode191813*, semconst_436982)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, fitremovehiddenconv_435013)(Tcontext245023* c, Ttype191849* typ, Tnode191813* n);
N_NIMCALL(Tnode191813*, semtypesection_438873)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, typesectionleftsidepass_438199)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, typesectionrightsidepass_438297)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, processmagictype_422888)(Tcontext245023* c, Tsym191843* m);
N_NIMCALL(void, setmagictype_422877)(Tsym191843* m, NU8 kind, NI size);
N_NIMCALL(void, typesectionfinalpass_438746)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, checkconstructedtype_266110)(Tlineinfo164338 info, Ttype191849* typ);
N_NIMCALL(void, checkformetafields_438580)(Tnode191813* n);
N_NIMCALL(Tnode191813*, semdiscard_432006)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semwhile_432217)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, sembreakorcontinue_432027)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semfor_437981)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semexprnoderef_410228)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, semforvars_437804)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tsym191843*, symforvar_437707)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, addforvardecl_437675)(Tcontext245023* c, Tsym191843* v);
N_NIMCALL(Tnode191813*, semforfields_437434)(Tcontext245023* c, Tnode191813* n, NU16 m);
N_NIMCALL(Tnode191813*, instfieldloopbody_437152)(Tfieldinstctx437147* c, Tnode191813* n, Tnode191813* forloop);
N_NIMCALL(void, semforobjectfields_437312)(Tfieldsctx437309 c, Tnode191813* typ, Tnode191813* forloop, Tnode191813* father);
N_NIMCALL(NIM_BOOL, containsnode_196365)(Tnode191813* n, TY433644 kinds);
N_NIMCALL(Tnode191813*, implicititerator_437947)(Tcontext245023* c, NimStringDesc* it, Tnode191813* arg);
N_NIMCALL(Tnode191813*, semcase_434301)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NI64, tocover_432259)(Ttype191849* t);
N_NIMCALL(Tnode191813*, semreturn_448260)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semusing_448837)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, adddeclat_250629)(Tscope191837* scope, Tsym191843* sym);
N_NIMCALL(Tnode191813*, semasm_432207)(Tcontext245023* con, Tnode191813* n);
N_NIMCALL(NIM_CHAR, pragmaasm_261088)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semasmoremit_262547)(Tcontext245023* con, Tnode191813* n, NIM_CHAR marker);
N_NIMCALL(Tnode191813*, semyield_448527)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, semyieldvarresult_448425)(Tcontext245023* c, Tnode191813* n, Ttype191849* restype);
N_NIMCALL(Tnode191813*, semiterator_440512)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semmethod_440688)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semconverterdef_440699)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, addconverter_245561)(Tcontext245023* c, Tsym191843* conv);
N_NIMCALL(Tnode191813*, semmacrodef_440724)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, evalimport_252004)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, evalimportexcept_252857)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, evalfrom_252011)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, evalinclude_440760)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NI32, checkmodulename_252064)(Tnode191813* n);
N_NIMCALL(void, excl_188871)(Intset188056* s, NI key);
N_NIMCALL(Tnode191813*, semexport_450816)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tsym191843*, inittabiter_199124)(Ttabiter199119* ti, Tstrtable191817 tab);
N_NIMCALL(Tsym191843*, nextiter_199132)(Ttabiter199119* ti, Tstrtable191817 tab);
N_NIMCALL(Tnode191813*, sempragmablock_440846)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(NU16, whichpragma_220673)(Tnode191813* n);
N_NIMCALL(void, setline_440802)(Tnode191813* n, Tlineinfo164338 info);
N_NIMCALL(Tnode191813*, semstaticstmt_440898)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, evalstaticstmt_398844)(Tsym191843* module, Tnode191813* e, Tsym191843* prc);
N_NIMCALL(NIM_BOOL, HEX3DHEX3D_165789)(Tlineinfo164338 a, Tlineinfo164338 b);
N_NIMCALL(Tnode191813*, tryconstexpr_411420)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, semoperand_441821)(Tcontext245023* c, Tnode191813* n, NU16 flags);
N_NIMCALL(Tnode191813*, seminferredlambda_439457)(Tcontext245023* c, Tidtable191861 pt, Tnode191813* n_439461);
N_NIMCALL(Tnode191813*, replacetypesinbody_268617)(Tcontext245023* p, Tidtable191861 pt, Tnode191813* n);
N_NIMCALL(Tsym191843*, insttypeboundop_351551)(Tcontext245023* c, Tsym191843* dc, Ttype191849* t, Tlineinfo164338 info, NU8 op);
N_NIMCALL(void, importallsymbols_252389)(Tcontext245023* c, Tsym191843* frommod);
N_NIMCALL(Tpasscontext242005*, myopen_451686)(Tsym191843* module);
N_NIMCALL(Tnode191813*, semstmtandgenerategenerics_451760)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(void, addcodeforgenerics_451577)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, hlostmt_412187)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, buildechostmt_446413)(Tcontext245023* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, transformstmt_371207)(Tsym191843* module, Tnode191813* n);
N_NIMCALL(void, recovercontext_451798)(Tcontext245023* c);
static N_INLINE(NIM_BOOL, isObjWithCache)(TNimType* obj, TNimType* subclass, TNimType** cache);
N_NOINLINE(NIM_BOOL, isobjslowpath_22817)(TNimType* obj, TNimType* subclass, TNimType** cache);
N_NIMCALL(void, rawclosescope_250102)(Tcontext245023* c);
STRING_LITERAL(TMP1035, "typedesc", 8);
STRING_LITERAL(TMP1036, "destroy_", 8);
STRING_LITERAL(TMP1037, "this_", 5);
STRING_LITERAL(TMP1038, "destructor", 10);
STRING_LITERAL(TMP1963, "sem.myOpen", 10);
STRING_LITERAL(TMP2991, "", 0);
static NIM_CONST TY433644 TMP2992 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00,
0x00, 0x00, 0xE0, 0x11, 0x02, 0x0C, 0x01, 0xC0,
0x00, 0x00, 0x00, 0x00}
;
STRING_LITERAL(TMP2993, "|", 1);
STRING_LITERAL(TMP2994, "invalid type", 12);
STRING_LITERAL(TMP2995, "region needs to be an object type", 33);
STRING_LITERAL(TMP2997, "openarray", 9);
STRING_LITERAL(TMP2998, "range", 5);
STRING_LITERAL(TMP2999, "set", 3);
STRING_LITERAL(TMP3000, "ordinal", 7);
STRING_LITERAL(TMP3001, "seq", 3);
STRING_LITERAL(TMP3002, "varargs", 7);
STRING_LITERAL(TMP3003, "cannot instantiate the \'$1\' $2", 30);
STRING_LITERAL(TMP3005, "semtypes.nim", 12);
NIM_CONST TY86345 TMP3004 = {((NimStringDesc*) &TMP3005),
((NI) 1036)}
;
STRING_LITERAL(TMP3006, "cannot instantiate ", 19);
STRING_LITERAL(TMP3007, "\012got: (", 7);
STRING_LITERAL(TMP3011, ")\012but expected: (", 17);
STRING_LITERAL(TMP3012, ")", 1);
STRING_LITERAL(TMP3013, "result", 6);
NIM_CONST TY86345 TMP3014 = {((NimStringDesc*) &TMP3005),
((NI) 1227)}
;
STRING_LITERAL(TMP3015, "object", 6);
STRING_LITERAL(TMP3016, "addInheritedFieldsAux", 21);
STRING_LITERAL(TMP3017, "addInheritedFieldsAux(record case branch)", 41);
STRING_LITERAL(TMP3018, "addInheritedFieldsAux()", 23);
STRING_LITERAL(TMP3019, "semObjectNode", 13);
STRING_LITERAL(TMP3020, "nesting too deep", 16);
STRING_LITERAL(TMP3022, "seminst.nim", 11);
NIM_CONST TY86345 TMP3021 = {((NimStringDesc*) &TMP3022),
((NI) 237)}
;
STRING_LITERAL(TMP3023, "instantiateGenericParamList; no generic params", 46);
STRING_LITERAL(TMP3024, "instantiateGenericParamList; no symbol", 38);
STRING_LITERAL(TMP3025, "owner is nil", 12);
NIM_CONST TY86345 TMP3026 = {((NimStringDesc*) &TMP3022),
((NI) 184)}
;
STRING_LITERAL(TMP3027, "result", 6);
STRING_LITERAL(TMP3028, "NimNode", 7);
STRING_LITERAL(TMP3029, "NimNode", 7);
STRING_LITERAL(TMP3030, "PNimrodNode", 11);
static NIM_CONST Tspecialwords173012 TMP3101 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xC0, 0xE0, 0x3F, 0xFA, 0x5D, 0x00, 0x30,
0xFE, 0x07, 0x00, 0x84, 0x30, 0x03, 0x60, 0x48,
0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3103, "semexprs.nim", 12);
NIM_CONST TY86345 TMP3102 = {((NimStringDesc*) &TMP3103),
((NI) 998)}
;
STRING_LITERAL(TMP3106, "()", 2);
STRING_LITERAL(TMP3108, "sem.nim", 7);
NIM_CONST TY86345 TMP3107 = {((NimStringDesc*) &TMP3108),
((NI) 178)}
;
static NIM_CONST Tspecialwords173012 TMP3109 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x36, 0x00, 0x40, 0x00, 0x10,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
static NIM_CONST Tspecialwords173012 TMP3110 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x40, 0x00, 0x36, 0x12, 0x4C, 0x00, 0x10,
0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x60, 0x62,
0x01, 0x20, 0x02, 0x08, 0x00, 0x40, 0x00, 0x00,
0x00}
;
static NIM_CONST Tspecialwords173012 TMP3111 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x40, 0x00, 0x36, 0x12, 0x40, 0x00, 0x10,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00,
0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3131, "\':\' expected", 12);
STRING_LITERAL(TMP3134, ":type", 5);
NIM_CONST TY86345 TMP3143 = {((NimStringDesc*) &TMP3005),
((NI) 706)}
;
STRING_LITERAL(TMP3146, "invalid return type: \'stmt\'", 27);
STRING_LITERAL(TMP3147, "*", 1);
STRING_LITERAL(TMP3148, "**", 2);
STRING_LITERAL(TMP3149, "~", 1);
STRING_LITERAL(TMP3154, "semProcAux", 10);
STRING_LITERAL(TMP3156, "destroy", 7);
STRING_LITERAL(TMP3157, "=destroy", 8);
STRING_LITERAL(TMP3158, "deepcopy", 8);
STRING_LITERAL(TMP3159, "=deepcopy", 9);
STRING_LITERAL(TMP3160, "=", 1);
STRING_LITERAL(TMP3161, "nimDestroyRange", 15);
STRING_LITERAL(TMP3163, "semdestruct.nim", 15);
NIM_CONST TY86345 TMP3162 = {((NimStringDesc*) &TMP3163),
((NI) 115)}
;
NIM_CONST TY86345 TMP3164 = {((NimStringDesc*) &TMP3163),
((NI) 106)}
;
NIM_CONST TY86345 TMP3165 = {((NimStringDesc*) &TMP3163),
((NI) 154)}
;
STRING_LITERAL(TMP3166, "AnonType", 8);
static NIM_CONST Tspecialwords173012 TMP3167 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xC0, 0xE0, 0x3F, 0xFA, 0x5D, 0x00, 0x30,
0xFE, 0x07, 0x00, 0x84, 0x30, 0x03, 0x60, 0x48,
0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3168, "use the {.experimental.} pragma to enable destructors", 53);
STRING_LITERAL(TMP3169, "cannot bind another \'deepCopy\' to: ", 35);
STRING_LITERAL(TMP3170, "cannot bind \'deepCopy\' to: ", 27);
STRING_LITERAL(TMP3171, "signature for \'deepCopy\' must be proc[T: ptr|ref](x: T): T", 58);
STRING_LITERAL(TMP3172, "cannot bind another \'=\' to: ", 28);
STRING_LITERAL(TMP3173, "signature for \'=\' must be proc[T: object](x: var T; y: T)", 57);
STRING_LITERAL(TMP3174, "\'destroy\' or \'deepCopy\' expected for \'override\'", 47);
STRING_LITERAL(TMP3175, "invalid type: \'", 15);
STRING_LITERAL(TMP3176, "\'", 1);
STRING_LITERAL(TMP3177, "\' in this context: \'", 20);
STRING_LITERAL(TMP3191, "hlo.nim", 7);
NIM_CONST TY86345 TMP3190 = {((NimStringDesc*) &TMP3191),
((NI) 15)}
;
STRING_LITERAL(TMP3192, "changeType: no tuple type for constructor", 41);
STRING_LITERAL(TMP3193, "changeType(): invalid tuple constr", 34);
STRING_LITERAL(TMP3194, "changeType(): invalid identifier", 32);
STRING_LITERAL(TMP3195, "cannot convert ", 15);
STRING_LITERAL(TMP3196, " to ", 4);
static NIM_CONST TY444856 TMP3197 = {
0x00, 0x80, 0x80, 0x1D, 0x18, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x38, 0x8C, 0x80, 0x00, 0x00,
0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3198, "analyseIfAddressTaken", 21);
STRING_LITERAL(TMP3201, "semmagic.nim", 12);
NIM_CONST TY86345 TMP3200 = {((NimStringDesc*) &TMP3201),
((NI) 66)}
;
STRING_LITERAL(TMP3202, "name", 4);
STRING_LITERAL(TMP3203, "arity", 5);
NIM_CONST TY86345 TMP3204 = {((NimStringDesc*) &TMP3201),
((NI) 61)}
;
STRING_LITERAL(TMP3205, "low", 3);
STRING_LITERAL(TMP3206, "high", 4);
NIM_CONST TY443654 optostr_443653 = {((NimStringDesc*) &TMP3205),
((NimStringDesc*) &TMP3206)}
;
STRING_LITERAL(TMP3207, "use \'^\' instead of \'-\'; negative indexing is obsolete", 53);
STRING_LITERAL(TMP3208, "no surrounding array access context for \'^\'", 43);
STRING_LITERAL(TMP3209, "invalid context for \'^\' as \'$#\' has side effects", 48);
STRING_LITERAL(TMP3210, "invalid context for \'^\' as len!=high+1 for \'$#\'", 47);
STRING_LITERAL(TMP3211, "len", 3);
STRING_LITERAL(TMP3212, "\'$#\' has to be of an ordinal type for \'^\'", 41);
STRING_LITERAL(TMP3213, "-", 1);
STRING_LITERAL(TMP3214, "cannot find plugin ", 19);
static NIM_CONST TY444856 TMP3215 = {
0x01, 0x00, 0xC0, 0xE3, 0x7F, 0xFE, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x3F, 0xF8, 0x01, 0x0C, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3296, " --> \'", 6);
static NIM_CONST Tspecialwords173012 TMP3349 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3351, "semcall.nim", 11);
NIM_CONST TY86345 TMP3350 = {((NimStringDesc*) &TMP3351),
((NI) 182)}
;
STRING_LITERAL(TMP3352, ".()", 3);
STRING_LITERAL(TMP3353, ".", 1);
NIM_CONST TY86345 TMP3354 = {((NimStringDesc*) &TMP3351),
((NI) 203)}
;
STRING_LITERAL(TMP3355, ".=", 2);
NIM_CONST TY86345 TMP3356 = {((NimStringDesc*) &TMP3351),
((NI) 232)}
;
STRING_LITERAL(TMP3357, "ambiguous call", 14);
STRING_LITERAL(TMP3358, "(", 1);
STRING_LITERAL(TMP3359, ", ", 2);
STRING_LITERAL(TMP3360, "calleeSym.ast is nil", 20);
STRING_LITERAL(TMP3361, "\012", 1);
STRING_LITERAL(TMP3362, "semOverloadedCallAnalyseEffects", 31);
STRING_LITERAL(TMP3363, "[]=", 3);
STRING_LITERAL(TMP3364, "{}=", 3);
NIM_CONST TY86345 TMP3365 = {((NimStringDesc*) &TMP3103),
((NI) 1306)}
;
STRING_LITERAL(TMP3366, ") ", 2);
STRING_LITERAL(TMP3367, ":lifted=", 8);
STRING_LITERAL(TMP3368, "dest", 4);
STRING_LITERAL(TMP3369, "src", 3);
STRING_LITERAL(TMP3370, "newSeq", 6);
STRING_LITERAL(TMP3371, "len", 3);
STRING_LITERAL(TMP3372, ":tmp", 4);
STRING_LITERAL(TMP3373, "<=", 2);
STRING_LITERAL(TMP3375, "inc", 3);
STRING_LITERAL(TMP3376, "cannot lift assignment operator to \'case\' object", 48);
STRING_LITERAL(TMP3377, "deepCopy", 8);
STRING_LITERAL(TMP3378, "cannot copy openArray", 21);
STRING_LITERAL(TMP3379, "assignment requested for type: ", 31);
STRING_LITERAL(TMP3380, "semRecordNodeAux", 16);
STRING_LITERAL(TMP3381, "semRecordCase: discriminant is no symbol", 40);
STRING_LITERAL(TMP3382, "dummy", 5);
static NIM_CONST Tspecialwords173012 TMP3383 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x40, 0x01, 0xF6, 0x56, 0x48, 0x00, 0x10,
0x00, 0x00, 0x00, 0x20, 0x00, 0x61, 0x60, 0x81,
0x00, 0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0xC0,
0x00}
;
STRING_LITERAL(TMP3384, "use \'concept\' instead; \'generic\'", 32);
static NIM_CONST Tspecialwords173012 TMP3385 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x80, 0x00, 0x00, 0x60, 0x00, 0x00, 0x20,
0xFE, 0x07, 0x00, 0x84, 0x00, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
NIM_CONST TY86345 TMP3388 = {((NimStringDesc*) &TMP3103),
((NI) 117)}
;
NIM_CONST TY86345 TMP3389 = {((NimStringDesc*) &TMP3103),
((NI) 122)}
;
STRING_LITERAL(TMP3391, "bind", 4);
STRING_LITERAL(TMP3392, ":anon", 5);
STRING_LITERAL(TMP3393, "object constructor needs an object type", 39);
STRING_LITERAL(TMP3394, "checkInitialized", 16);
STRING_LITERAL(TMP3395, "field not initialized: ", 23);
STRING_LITERAL(TMP3396, "defined", 7);
STRING_LITERAL(TMP3397, "obsolete usage of \'defined\', use \'declared\' instead", 51);
STRING_LITERAL(TMP3399, "sizeof", 6);
STRING_LITERAL(TMP3400, "is", 2);
NIM_CONST TY86345 TMP3401 = {((NimStringDesc*) &TMP3103),
((NI) 373)}
;
STRING_LITERAL(TMP3402, "closure", 7);
STRING_LITERAL(TMP3403, "of", 2);
NIM_CONST TY86345 TMP3404 = {((NimStringDesc*) &TMP3103),
((NI) 1539)}
;
NIM_CONST TY86345 TMP3405 = {((NimStringDesc*) &TMP3103),
((NI) 1577)}
;
STRING_LITERAL(TMP3406, "``", 2);
STRING_LITERAL(TMP3407, "block", 5);
STRING_LITERAL(TMP3408, "stmt", 4);
STRING_LITERAL(TMP3409, "expr", 4);
static NIM_CONST Tspecialwords173012 TMP3410 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x90, 0x00, 0x00, 0x40, 0x00, 0x10,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3413, "FlowVar", 7);
STRING_LITERAL(TMP3414, "nimCreateFlowVar", 16);
STRING_LITERAL(TMP3416, ")\012", 2);
STRING_LITERAL(TMP3417, "cannot instantiate: ", 20);
STRING_LITERAL(TMP3418, "; got ", 6);
STRING_LITERAL(TMP3419, " type(s) but expected ", 22);
STRING_LITERAL(TMP3420, "[]", 2);
STRING_LITERAL(TMP3421, "{}", 2);
STRING_LITERAL(TMP3422, "semExpr() to implement", 22);
static NIM_CONST Tspecialwords173012 TMP3423 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x80, 0x00, 0x36, 0xFA, 0x04, 0x00, 0x10,
0xFE, 0x07, 0x00, 0x84, 0x00, 0x00, 0x00, 0x08,
0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3424, "use \'defer\'; standalone \'finally\'", 33);
STRING_LITERAL(TMP3425, "use an explicit \'try\'; standalone \'except\'", 42);
STRING_LITERAL(TMP3426, "type class predicate failed", 27);
STRING_LITERAL(TMP3427, "\'typedesc\' metatype is not valid here; typed \'=\' instead of \':\'"
"?", 64);
STRING_LITERAL(TMP3428, "tuple", 5);
STRING_LITERAL(TMP3429, "_", 1);
STRING_LITERAL(TMP3430, "shared", 6);
STRING_LITERAL(TMP3432, "semstmts.nim", 12);
NIM_CONST TY86345 TMP3431 = {((NimStringDesc*) &TMP3432),
((NI) 699)}
;
NIM_CONST TY86345 TMP3433 = {((NimStringDesc*) &TMP3432),
((NI) 700)}
;
STRING_LITERAL(TMP3434, ":ObjectType", 11);
NIM_CONST TY86345 TMP3435 = {((NimStringDesc*) &TMP3432),
((NI) 726)}
;
STRING_LITERAL(TMP3436, "\'continue\' cannot have a label", 30);
STRING_LITERAL(TMP3437, "true", 4);
STRING_LITERAL(TMP3438, "true", 4);
STRING_LITERAL(TMP3439, "no object or tuple type", 23);
STRING_LITERAL(TMP3440, "Field", 5);
STRING_LITERAL(TMP3441, "\'continue\' not supported in a \'fields\' loop", 43);
STRING_LITERAL(TMP3442, "parallel \'fields\' iterator does not work for \'case\' objects", 59);
static NIM_CONST TY433644 TMP3443 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00}
;
STRING_LITERAL(TMP3444, "items", 5);
STRING_LITERAL(TMP3445, "pairs", 5);
STRING_LITERAL(TMP3446, "use \'else: discard\'; non-ordinal case without \'else\'", 52);
STRING_LITERAL(TMP3447, "\'return\'", 8);
STRING_LITERAL(TMP3448, "use the {.experimental.} pragma to enable \'using\'", 49);
STRING_LITERAL(TMP3449, "semYield", 8);
STRING_LITERAL(TMP3450, "tuple constructor", 17);
STRING_LITERAL(TMP3451, "yield statement must yield a value", 34);
static NIM_CONST Tspecialwords173012 TMP3452 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x04, 0x00, 0x04, 0xE0, 0xFD, 0x9F,
0x00, 0xE0, 0xFF, 0x43, 0xCD, 0x8C, 0x0F, 0x04,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
static NIM_CONST Tspecialwords173012 TMP3453 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x40, 0x00, 0x36, 0x6A, 0x40, 0x00, 0x10,
0xFE, 0x07, 0x00, 0x84, 0x00, 0x03, 0x60, 0x00,
0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3454, "iterator", 8);
STRING_LITERAL(TMP3455, "method", 6);
STRING_LITERAL(TMP3456, "converter", 9);
static NIM_CONST Tspecialwords173012 TMP3457 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x40, 0x90, 0x36, 0x22, 0x48, 0x00, 0x10,
0xFE, 0x07, 0x00, 0x00, 0x00, 0x02, 0x60, 0x00,
0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3458, "macro", 5);
STRING_LITERAL(TMP3459, "import", 6);
STRING_LITERAL(TMP3470, "from", 4);
STRING_LITERAL(TMP3473, "include", 7);
STRING_LITERAL(TMP3474, "export", 6);
STRING_LITERAL(TMP3475, "cannot export: ", 15);
static NIM_CONST Tspecialwords173012 TMP3476 = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00}
;
STRING_LITERAL(TMP3477, "\'defer\' not allowed in this context", 35);
STRING_LITERAL(TMP3483, "no code for ", 12);
STRING_LITERAL(TMP3484, "echo", 4);
STRING_LITERAL(TMP3485, "echo", 4);
STRING_LITERAL(TMP3487, "n is not nil", 12);
Ttype191849* commontypebegin_410472;
extern TNimType NTI191809; /* PType */
extern TNimType NTI191849; /* TType */
extern Tgcheap48216 gch_48244;
Tident168021* typedescid_420273;
Ttype191849* enforcevoidcontext_432005;
Tsym191843* analyzingdestructor_432401;
Tsym191843* destructoristrivial_432402;
extern TNimType NTI191811; /* PSym */
extern TNimType NTI191843; /* TSym */
Tident168021* destructorname_432419;
Tident168021* destructorparam_432420;
Tnode191813* destructorpragma_432421;
Tsym191843* rangedestructorproc_432422;
extern NU8 gcmd_155130;
extern NI evaltemplatecounter_384256;
extern TNimType NTI191813; /* TNode */
extern TNimType NTI191441; /* TSymKind */
extern TNimType NTI191845; /* TTypeSeq */
extern TNimType NTI245009; /* PProcCon */
extern Tnode191813* emptynode_192807;
extern Tsym191843* opcontains_197000;
extern Tsym191843* opnot_196999;
extern TNimType NTI191807; /* TNodeSeq */
TNimType NTI413758; /* tuple[a: PSym, b: int] */
extern TNimType NTI108; /* int */
TNimType NTI413757; /* seq[tuple[a: PSym, b: int]] */
extern Tident168021* iddelegator_168550;
extern Tident168021* idanon_168495;
extern NU8 gidecmd_155115;
TNimType NTI421253; /* object */
extern TNimType NTI311033; /* range -1..0(int) */
extern TNimType NTI149; /* string */
extern TNimType NTI191805; /* PNode */
extern TNimType NTI164338; /* TLineInfo */
extern TNimType NTI245021; /* PContext */
TNimType NTI421311; /* ref object */
extern NU32 goptions_155126;
extern NIM_BOOL gexperimentalmode_155145;
extern NU64 gnotes_165011;
extern TNimType NTI345209; /* TCandidate */
extern TNimType NTI191815; /* TSymSeq */
extern NI gerrorcounter_165012;
extern NI gerrormax_165015;
extern Tsymseq191815* gowners_245288;
extern NU8 erroroutputs_165053;
extern TNimType NTI245141; /* seq[TInstantiationPair] */
extern TSafePoint* exchandler_17043;
extern TNimType NTI164344; /* ERecoverableError */
extern Exception* currexception_17045;
extern TNimType NTI191529; /* TMagic */
extern Tsym191843* systemmodule_239019;
extern Tlineinfo164338 gcodegenlineinfo_164959;
extern NU32 gglobaloptions_155128;
extern NI ptrsize_160625;
extern TNimType NTI191260; /* TTypeKind */
extern NI intsize_160623;
extern NI floatsize_160624;
extern TY242069 gincludefile_242073;
extern TNimType NTI164346; /* ESuggestDone */
static TNimType* Nim_OfCheck_CACHE1[2];
TNimType NTI433269; /* tuple[outer: PNode, inner: PNode] */

static N_INLINE(Tcell46346*, usrtocell_49846)(void* usr) {
	Tcell46346* result;
	result = 0;
	result = ((Tcell46346*) ((NI)((NU64)(((NI) (usr))) - (NU64)(((NI)sizeof(Tcell46346))))));
	return result;
}

static N_INLINE(void, rtladdzct_51404)(Tcell46346* c) {
	addzct_49817((&gch_48244.zct), c);
}

static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src) {
	{
		Tcell46346* c;
		if (!!((src == NIM_NIL))) goto LA3;
		c = usrtocell_49846(src);
		(*c).refcount += ((NI) 8);
	}
	LA3: ;
	{
		Tcell46346* c;
		if (!!(((*dest) == NIM_NIL))) goto LA7;
		c = usrtocell_49846((*dest));
		{
			(*c).refcount -= ((NI) 8);
			if (!((NU64)((*c).refcount) < (NU64)(((NI) 8)))) goto LA11;
			rtladdzct_51404(c);
		}
		LA11: ;
	}
	LA7: ;
	(*dest) = src;
}

static N_INLINE(void, nimGCunrefNoCycle)(void* p) {
	Tcell46346* c;
	c = usrtocell_49846(p);
	{
		(*c).refcount -= ((NI) 8);
		if (!((NU64)((*c).refcount) < (NU64)(((NI) 8)))) goto LA3;
		rtladdzct_51404(c);
	}
	LA3: ;
}

static N_INLINE(Tnode191813*, inlineconst_442028)(Tnode191813* n, Tsym191843* s) {
	Tnode191813* result;
	result = 0;
	result = copytree_196028((*s).ast);
	asgnRefNoCycle((void**) (&(*result).typ), (*s).typ);
	(*result).info = (*n).info;
	return result;
}

static N_INLINE(NI, len_192097)(Tnode191813* n) {
	NI result;
	result = 0;
	{
		if (!(*n).kindU.S6.sons == 0) goto LA3;
		result = ((NI) 0);
	}
	goto LA1;
	LA3: ;
	{
		result = ((*n).kindU.S6.sons ? (*n).kindU.S6.sons->Sup.len : 0);
	}
	LA1: ;
	return result;
}

N_NIMCALL(NIM_BOOL, implicitlydiscardable_433645)(Tnode191813* n_433647) {
	NIM_BOOL result;
	Tnode191813* n;
	NIM_BOOL LOC3;
	NIM_BOOL LOC4;
	result = 0;
	n = n_433647;
	{
		while (1) {
			if (!((TMP2992[(*n).kind/8] &(1<<((*n).kind%8)))!=0)) goto LA2;
			n = lastson_194431(n);
		} LA2: ;
	}
	LOC3 = 0;
	LOC4 = 0;
	LOC4 = iscallexpr_192071(n);
	if (!(LOC4)) goto LA5;
	LOC4 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3));
	LA5: ;
	LOC3 = LOC4;
	if (!(LOC3)) goto LA6;
	LOC3 = (((*(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).flags &(1<<((((NU8) 29))&31)))!=0);
	LA6: ;
	result = LOC3;
	return result;
}

static N_INLINE(NIM_BOOL, isatom_196906)(Tnode191813* n) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = (((NU8) 0) <= (*n).kind);
	if (!(LOC1)) goto LA2;
	LOC1 = ((*n).kind <= ((NU8) 23));
	LA2: ;
	result = LOC1;
	return result;
}

N_NIMCALL(void, fixniltype_433694)(Tnode191813* n) {
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = isatom_196906(n);
		if (!LOC3) goto LA4;
		{
			NIM_BOOL LOC8;
			NimStringDesc* LOC12;
			LOC8 = 0;
			LOC8 = !(((*n).kind == ((NU8) 23)));
			if (!(LOC8)) goto LA9;
			LOC8 = !(((*n).typ == NIM_NIL));
			LA9: ;
			if (!LOC8) goto LA10;
			LOC12 = 0;
			LOC12 = typetostring_221032((*n).typ, ((NU8) 0));
			localerror_166155((*n).info, ((NU16) 140), LOC12);
		}
		LA10: ;
	}
	goto LA1;
	LA4: ;
	{
		if (!((*n).kind == ((NU8) 115) || (*n).kind == ((NU8) 126))) goto LA14;
		(*n).kind = ((NU8) 115);
		{
			Tnode191813* it_433729;
			it_433729 = 0;
			{
				NI i_433734;
				NI HEX3Atmp_433736;
				NI LOC18;
				NI res_433738;
				i_433734 = 0;
				HEX3Atmp_433736 = 0;
				LOC18 = 0;
				LOC18 = len_192097(n);
				HEX3Atmp_433736 = (LOC18 - 1);
				res_433738 = ((NI) 0);
				{
					while (1) {
						if (!(res_433738 <= HEX3Atmp_433736)) goto LA20;
						i_433734 = res_433738;
						it_433729 = (*n).kindU.S6.sons->data[i_433734];
						fixniltype_433694(it_433729);
						res_433738 += ((NI) 1);
					} LA20: ;
				}
			}
		}
	}
	goto LA1;
	LA14: ;
	LA1: ;
	asgnRefNoCycle((void**) (&(*n).typ), NIM_NIL);
}

N_NIMCALL(void, discardcheck_433756)(Tcontext245023* c, Tnode191813* result) {
{	{
		if (!(((NI) 0) < (*c).intypeclass)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	{
		NIM_BOOL LOC7;
		LOC7 = 0;
		LOC7 = !(((*result).typ == NIM_NIL));
		if (!(LOC7)) goto LA8;
		LOC7 = !(((136 &(IL64(1)<<(((*(*result).typ).kind)&IL64(63))))!=0));
		LA8: ;
		if (!LOC7) goto LA9;
		{
			if (!((*result).kind == ((NU8) 23))) goto LA13;
			asgnRefNoCycle((void**) (&(*result).typ), NIM_NIL);
			message_166188((*result).info, ((NU16) 243), ((NimStringDesc*) &TMP2991));
		}
		goto LA11;
		LA13: ;
		{
			NIM_BOOL LOC16;
			Tnode191813* n;
			LOC16 = 0;
			LOC16 = implicitlydiscardable_433645(result);
			if (!LOC16) goto LA17;
			n = result;
			asgnRefNoCycle((void**) (&(*result).typ), NIM_NIL);
			{
				while (1) {
					if (!((TMP2992[(*n).kind/8] &(1<<((*n).kind%8)))!=0)) goto LA20;
					n = lastson_194431(n);
					asgnRefNoCycle((void**) (&(*n).typ), NIM_NIL);
				} LA20: ;
			}
		}
		goto LA11;
		LA17: ;
		{
			NIM_BOOL LOC22;
			LOC22 = 0;
			LOC22 = !(((*(*result).typ).kind == ((NU8) 50)));
			if (!(LOC22)) goto LA23;
			LOC22 = !((gcmd_155130 == ((NU8) 18)));
			LA23: ;
			if (!LOC22) goto LA24;
			{
				if (!((*(*result).typ).kind == ((NU8) 5))) goto LA28;
				fixniltype_433694(result);
				message_166188((*result).info, ((NU16) 243), ((NimStringDesc*) &TMP2991));
			}
			goto LA26;
			LA28: ;
			{
				Tnode191813* n;
				NimStringDesc* LOC33;
				n = result;
				{
					while (1) {
						if (!((TMP2992[(*n).kind/8] &(1<<((*n).kind%8)))!=0)) goto LA32;
						n = lastson_194431(n);
					} LA32: ;
				}
				LOC33 = 0;
				LOC33 = typetostring_221032((*result).typ, ((NU8) 0));
				localerror_166155((*n).info, ((NU16) 140), LOC33);
			}
			LA26: ;
		}
		goto LA11;
		LA24: ;
		LA11: ;
	}
	LA9: ;
	}BeforeRet: ;
}

N_NIMCALL(Tnode191813*, semexprnotype_410221)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = semexpr_410201(c, n, 8);
	discardcheck_433756(c, result);
	return result;
}

N_NIMCALL(Tnode191813*, semstmt_410277)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = semexprnotype_410221(c, n);
	return result;
}

N_NIMCALL(Ttype191849*, neworprevtype_416695)(NU8 kind, Ttype191849* prev, Tcontext245023* c) {
	Ttype191849* result;
	result = 0;
	{
		if (!(prev == NIM_NIL)) goto LA3;
		result = newtypes_245218(kind, c);
	}
	goto LA1;
	LA3: ;
	{
		result = prev;
		{
			if (!((*result).kind == ((NU8) 30))) goto LA8;
			(*result).kind = kind;
		}
		LA8: ;
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, semanontuple_418414)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 0))) goto LA4;
		localerror_166155((*n).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
	}
	LA4: ;
	result = neworprevtype_416695(((NU8) 18), prev, c);
	{
		NI i_418432;
		NI HEX3Atmp_418435;
		NI LOC7;
		NI res_418438;
		i_418432 = 0;
		HEX3Atmp_418435 = 0;
		LOC7 = 0;
		LOC7 = sonslen_194403(n);
		HEX3Atmp_418435 = (NI)(LOC7 - ((NI) 1));
		res_418438 = ((NI) 0);
		{
			while (1) {
				Ttype191849* LOC10;
				if (!(res_418438 <= HEX3Atmp_418435)) goto LA9;
				i_418432 = res_418438;
				LOC10 = 0;
				LOC10 = semtypenode_410269(c, (*n).kindU.S6.sons->data[i_418432], NIM_NIL);
				addsonskipintlit_239731(result, LOC10);
				res_418438 += ((NI) 1);
			} LA9: ;
		}
	}
	return result;
}

static N_INLINE(Tnode191813*, HEX5BHEX5D_192244)(Tnode191813* n, NI i) {
	Tnode191813* result;
	result = 0;
	result = (*n).kindU.S6.sons->data[i];
	return result;
}

static N_INLINE(NIM_BOOL, isrange_220612)(Tnode191813* n) {
	NIM_BOOL result;
	result = 0;
	{
		if (!((*n).kind == ((NU8) 27) || (*n).kind == ((NU8) 29) || (*n).kind == ((NU8) 30) || (*n).kind == ((NU8) 31) || (*n).kind == ((NU8) 26) || (*n).kind == ((NU8) 28) || (*n).kind == ((NU8) 32))) goto LA3;
		{
			NIM_BOOL LOC7;
			NIM_BOOL LOC8;
			Tnode191813* LOC9;
			Tnode191813* LOC11;
			NIM_BOOL LOC13;
			Tnode191813* LOC14;
			Tnode191813* LOC16;
			Tnode191813* LOC17;
			LOC7 = 0;
			LOC8 = 0;
			LOC9 = 0;
			LOC9 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC8 = ((*LOC9).kind == ((NU8) 2));
			if (!(LOC8)) goto LA10;
			LOC11 = 0;
			LOC11 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC8 = ((*(*LOC11).kindU.S5.ident).Sup.id == ((NI) 75));
			LA10: ;
			LOC7 = LOC8;
			if (LOC7) goto LA12;
			LOC13 = 0;
			LOC14 = 0;
			LOC14 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC13 = ((*LOC14).kind == ((NU8) 56) || (*LOC14).kind == ((NU8) 57));
			if (!(LOC13)) goto LA15;
			LOC16 = 0;
			LOC16 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC17 = 0;
			LOC17 = HEX5BHEX5D_192244(LOC16, ((NI) 1));
			LOC13 = ((*(*(*LOC17).kindU.S4.sym).name).Sup.id == ((NI) 75));
			LA15: ;
			LOC7 = LOC13;
			LA12: ;
			if (!LOC7) goto LA18;
			result = NIM_TRUE;
		}
		LA18: ;
	}
	LA3: ;
	return result;
}

static N_INLINE(Ttype191849*, skipintlit_239698)(Ttype191849* t) {
	Ttype191849* result;
{	result = 0;
	{
		if (!!(((*t).n == NIM_NIL))) goto LA3;
		{
			if (!((IL64(70866960384) &(IL64(1)<<(((*t).kind)&IL64(63))))!=0)) goto LA7;
			result = getsystype_239030((*t).kind);
			goto BeforeRet;
		}
		LA7: ;
	}
	LA3: ;
	result = t;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, semrangeaux_417292)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	TY417419 range;
	Tnode191813* LOC9;
	Tnode191813* LOC10;
	TY417424 ranget;
	result = 0;
	checksonslen_246249(n, ((NI) 3));
	result = neworprevtype_416695(((NU8) 20), prev, c);
	asgnRefNoCycle((void**) (&(*result).n), newnodei_193351(((NU8) 44), (*n).info));
	{
		NIM_BOOL LOC3;
		Tnode191813* LOC4;
		Tnode191813* LOC6;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC3 = ((*LOC4).kind == ((NU8) 1));
		if (LOC3) goto LA5;
		LOC6 = 0;
		LOC6 = HEX5BHEX5D_192244(n, ((NI) 2));
		LOC3 = ((*LOC6).kind == ((NU8) 1));
		LA5: ;
		if (!LOC3) goto LA7;
		localerror_166155((*n).info, ((NU16) 106), ((NimStringDesc*) &TMP2991));
	}
	LA7: ;
	memset((void*)range, 0, sizeof(range));
	LOC9 = 0;
	LOC9 = HEX5BHEX5D_192244(n, ((NI) 1));
	range[(((NI) 0))- 0] = semexprwithtype_410211(c, LOC9, 32);
	LOC10 = 0;
	LOC10 = HEX5BHEX5D_192244(n, ((NI) 2));
	range[(((NI) 1))- 0] = semexprwithtype_410211(c, LOC10, 32);
	memset((void*)ranget, 0, sizeof(ranget));
	{
		NI i_417437;
		NI res_417469;
		i_417437 = 0;
		res_417469 = ((NI) 0);
		{
			while (1) {
				Ttype191849* LOC14;
				if (!(res_417469 <= ((NI) 1))) goto LA13;
				i_417437 = res_417469;
				LOC14 = 0;
				LOC14 = skiptypes_195167((*range[(i_417437)- 0]).typ, IL64(576460752303423488));
				ranget[(i_417437)- 0] = skipintlit_239698(LOC14);
				res_417469 += ((NI) 1);
			} LA13: ;
		}
	}
	{
		Ttype191849* LOC17;
		Ttype191849* LOC18;
		NIM_BOOL LOC19;
		LOC17 = 0;
		LOC17 = skiptypes_195167(ranget[(((NI) 0))- 0], 1048576);
		LOC18 = 0;
		LOC18 = skiptypes_195167(ranget[(((NI) 1))- 0], 1048576);
		LOC19 = 0;
		LOC19 = sametype_226092(LOC17, LOC18, 0);
		if (!!(LOC19)) goto LA20;
		localerror_166155((*n).info, ((NU16) 128), ((NimStringDesc*) &TMP2991));
	}
	goto LA15;
	LA20: ;
	{
		NIM_BOOL LOC23;
		LOC23 = 0;
		LOC23 = isordinaltype_221093(ranget[(((NI) 0))- 0]);
		if (!!(LOC23)) goto LA24;
		localerror_166155((*n).info, ((NU16) 74), ((NimStringDesc*) &TMP2991));
	}
	goto LA15;
	LA24: ;
	{
		NIM_BOOL LOC27;
		LOC27 = 0;
		LOC27 = enumhasholes_221099(ranget[(((NI) 0))- 0]);
		if (!LOC27) goto LA28;
		localerror_166155((*n).info, ((NU16) 146), (*(*(*ranget[(((NI) 0))- 0]).sym).name).s);
	}
	goto LA15;
	LA28: ;
	LA15: ;
	{
		NI i_417452;
		NI res_417476;
		i_417452 = 0;
		res_417476 = ((NI) 0);
		{
			while (1) {
				if (!(res_417476 <= ((NI) 1))) goto LA32;
				i_417452 = res_417476;
				{
					NIM_BOOL LOC35;
					Tnode191813* LOC38;
					LOC35 = 0;
					LOC35 = hasgenericarguments_266765(range[(i_417452)- 0]);
					if (!LOC35) goto LA36;
					LOC38 = 0;
					LOC38 = makestaticexpr_245820(c, range[(i_417452)- 0]);
					addson_193819((*result).n, LOC38);
				}
				goto LA33;
				LA36: ;
				{
					Tnode191813* LOC40;
					LOC40 = 0;
					LOC40 = semconstexpr_411485(c, range[(i_417452)- 0]);
					addson_193819((*result).n, LOC40);
				}
				LA33: ;
				res_417476 += ((NI) 1);
			} LA32: ;
		}
	}
	{
		Tnode191813* LOC43;
		Tnode191813* LOC44;
		NU8 LOC45;
		LOC43 = 0;
		LOC43 = HEX5BHEX5D_192244((*result).n, ((NI) 0));
		LOC44 = 0;
		LOC44 = HEX5BHEX5D_192244((*result).n, ((NI) 1));
		LOC45 = 0;
		LOC45 = weaklevalue_199424(LOC43, LOC44);
		if (!(LOC45 == ((NU8) 1))) goto LA46;
		localerror_166155((*n).info, ((NU16) 106), ((NimStringDesc*) &TMP2991));
	}
	LA46: ;
	addsonskipintlit_239731(result, ranget[(((NI) 0))- 0]);
	return result;
}

N_NIMCALL(Ttype191849*, semtypeexpr_422172)(Tcontext245023* c, Tnode191813* n_422175) {
	Ttype191849* result;
	Tnode191813* n;
	result = 0;
	n = semexprwithtype_410211(c, n_422175, 32);
	{
		if (!((*(*n).typ).kind == ((NU8) 8))) goto LA3;
		result = base_221039((*n).typ);
	}
	goto LA1;
	LA3: ;
	{
		NimStringDesc* LOC6;
		LOC6 = 0;
		LOC6 = rendertree_213058(n, 0);
		localerror_166155((*n).info, ((NU16) 63), LOC6);
	}
	LA1: ;
	return result;
}

static N_INLINE(NIM_BOOL, eqStrings)(NimStringDesc* a, NimStringDesc* b) {
	NIM_BOOL result;
	NIM_BOOL LOC11;
	int LOC13;
{	result = 0;
	{
		if (!(a == b)) goto LA3;
		result = NIM_TRUE;
		goto BeforeRet;
	}
	LA3: ;
	{
		NIM_BOOL LOC7;
		LOC7 = 0;
		LOC7 = (a == NIM_NIL);
		if (LOC7) goto LA8;
		LOC7 = (b == NIM_NIL);
		LA8: ;
		if (!LOC7) goto LA9;
		result = NIM_FALSE;
		goto BeforeRet;
	}
	LA9: ;
	LOC11 = 0;
	LOC11 = ((*a).Sup.len == (*b).Sup.len);
	if (!(LOC11)) goto LA12;
	LOC13 = 0;
	LOC13 = memcmp(((NCSTRING) ((*a).data)), ((NCSTRING) ((*b).data)), (*a).Sup.len);
	LOC11 = (LOC13 == ((NI32) 0));
	LA12: ;
	result = LOC11;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

static N_INLINE(Ttype191849*, freshtype_422192)(Ttype191849* res, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	{
		if (!prev == 0) goto LA3;
		result = copytype_194549(res, (*res).owner, NIM_FALSE);
	}
	goto LA1;
	LA3: ;
	{
		result = res;
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, newconstraint_416725)(Tcontext245023* c, NU8 k) {
	Ttype191849* result;
	Ttype191849* LOC1;
	result = 0;
	result = newtypes_245218(((NU8) 51), c);
	LOC1 = 0;
	LOC1 = newtypes_245218(k, c);
	addsonskipintlit_239731(result, LOC1);
	return result;
}

N_NIMCALL(Ttype191849*, semanyref_417112)(Tcontext245023* c, Tnode191813* n_417115, NU8 kind, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = len_192097(n_417115);
		if (!(LOC3 < ((NI) 1))) goto LA4;
		result = newconstraint_416725(c, kind);
	}
	goto LA1;
	LA4: ;
	{
		NI iscall;
		Tnode191813* n;
		Ttype191849* base;
		Tnode191813* LOC24;
		iscall = ((*n_417115).kind == ((NU8) 27) || (*n_417115).kind == ((NU8) 29) || (*n_417115).kind == ((NU8) 30) || (*n_417115).kind == ((NU8) 31) || (*n_417115).kind == ((NU8) 26) || (*n_417115).kind == ((NU8) 28) || (*n_417115).kind == ((NU8) 32));
		{
			Tnode191813* LOC9;
			LOC9 = 0;
			LOC9 = HEX5BHEX5D_192244(n_417115, ((NI) 0));
			if (!((*LOC9).kind == ((NU8) 41))) goto LA10;
			n = HEX5BHEX5D_192244(n_417115, ((NI) 0));
		}
		goto LA7;
		LA10: ;
		{
			n = n_417115;
		}
		LA7: ;
		checkminsonslen_246259(n, ((NI) 1));
		result = neworprevtype_416695(kind, prev, c);
		{
			NI i_417224;
			NI HEX3Atmp_417241;
			NI LOC14;
			NI res_417244;
			i_417224 = 0;
			HEX3Atmp_417241 = 0;
			LOC14 = 0;
			LOC14 = len_192097(n);
			HEX3Atmp_417241 = (NI)(LOC14 - ((NI) 2));
			res_417244 = ((NI) (iscall));
			{
				while (1) {
					Ttype191849* region;
					Tnode191813* LOC17;
					if (!(res_417244 <= HEX3Atmp_417241)) goto LA16;
					i_417224 = res_417244;
					LOC17 = 0;
					LOC17 = HEX5BHEX5D_192244(n, i_417224);
					region = semtypenode_410269(c, LOC17, NIM_NIL);
					{
						Ttype191849* LOC20;
						Tnode191813* LOC23;
						LOC20 = 0;
						LOC20 = skiptypes_195167(region, 2048);
						if (!!(((IL64(1125899906973696) &(IL64(1)<<(((*LOC20).kind)&IL64(63))))!=0))) goto LA21;
						LOC23 = 0;
						LOC23 = HEX5BHEX5D_192244(n, i_417224);
						message_166188((*LOC23).info, ((NU16) 4), ((NimStringDesc*) &TMP2995));
					}
					LA21: ;
					addsonskipintlit_239731(result, region);
					res_417244 += ((NI) 1);
				} LA16: ;
			}
		}
		LOC24 = 0;
		LOC24 = lastson_194431(n);
		base = semtypenode_410269(c, LOC24, NIM_NIL);
		addsonskipintlit_239731(result, base);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semwhen_411040)(Tcontext245023* c, Tnode191813* n, NIM_BOOL semcheck) {
	Tnode191813* result;
	result = 0;
	result = NIM_NIL;
	{
		NI i_449660;
		NI HEX3Atmp_449715;
		NI LOC2;
		NI res_449718;
		i_449660 = 0;
		HEX3Atmp_449715 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_449715 = (NI)(LOC2 - ((NI) 1));
		res_449718 = ((NI) 0);
		{
			while (1) {
				Tnode191813* it;
				if (!(res_449718 <= HEX3Atmp_449715)) goto LA4;
				i_449660 = res_449718;
				it = (*n).kindU.S6.sons->data[i_449660];
				switch ((*it).kind) {
				case ((NU8) 86):
				case ((NU8) 49):
				{
					Tnode191813* e;
					checksonslen_246249(it, ((NI) 2));
					e = semconstexpr_411485(c, (*it).kindU.S6.sons->data[((NI) 0)]);
					{
						if (!!(((*e).kind == ((NU8) 6)))) goto LA8;
					}
					goto LA6;
					LA8: ;
					{
						NIM_BOOL LOC11;
						LOC11 = 0;
						LOC11 = !(((*e).kindU.S1.intval == IL64(0)));
						if (!(LOC11)) goto LA12;
						LOC11 = (result == NIM_NIL);
						LA12: ;
						if (!LOC11) goto LA13;
						{
							if (!semcheck) goto LA17;
							result = semstmt_410277(c, (*it).kindU.S6.sons->data[((NI) 1)]);
						}
						goto LA15;
						LA17: ;
						{
							result = (*it).kindU.S6.sons->data[((NI) 1)];
						}
						LA15: ;
					}
					goto LA6;
					LA13: ;
					LA6: ;
				}
				break;
				case ((NU8) 88):
				case ((NU8) 50):
				{
					checksonslen_246249(it, ((NI) 1));
					{
						if (!(result == NIM_NIL)) goto LA23;
						{
							if (!semcheck) goto LA27;
							result = semstmt_410277(c, (*it).kindU.S6.sons->data[((NI) 0)]);
						}
						goto LA25;
						LA27: ;
						{
							result = (*it).kindU.S6.sons->data[((NI) 0)];
						}
						LA25: ;
					}
					LA23: ;
				}
				break;
				default:
				{
					illformedast_246229(n);
				}
				break;
				}
				res_449718 += ((NI) 1);
			} LA4: ;
		}
	}
	{
		if (!(result == NIM_NIL)) goto LA33;
		result = newnodei_193351(((NU8) 1), (*n).info);
	}
	LA33: ;
	idsynchronizationpoint_190453(((NI) 200));
	return result;
}

N_NIMCALL(Tsym191843*, semtypeident_417777)(Tcontext245023* c, Tnode191813* n) {
	Tsym191843* result;
{	result = 0;
	{
		if (!((*n).kind == ((NU8) 3))) goto LA3;
		result = (*n).kindU.S4.sym;
	}
	goto LA1;
	LA3: ;
	{
		result = qualifiedlookup_250864(c, n, 3);
		{
			if (!!((result == NIM_NIL))) goto LA8;
			markused_345251((*n).info, result);
			{
				NIM_BOOL LOC12;
				LOC12 = 0;
				LOC12 = ((*result).kind == ((NU8) 3));
				if (!(LOC12)) goto LA13;
				LOC12 = ((*(*result).typ).kind == ((NU8) 8));
				LA13: ;
				if (!LOC12) goto LA14;
				{
					Tsym191843* bound;
					if (!(((NI) 0) < (*c).ingenericinst)) goto LA18;
					bound = (*(*(*result).typ).sons->data[((NI) 0)]).sym;
					{
						if (!!((bound == NIM_NIL))) goto LA22;
						result = bound;
						goto BeforeRet;
					}
					LA22: ;
					goto BeforeRet;
				}
				LA18: ;
				{
					if (!((*(*result).typ).sym == NIM_NIL)) goto LA26;
					localerror_166155((*n).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
					result = errorsym_250372(c, n);
					goto BeforeRet;
				}
				LA26: ;
				result = copysym_194607((*(*result).typ).sym, NIM_FALSE);
				asgnRefNoCycle((void**) (&(*result).typ), copytype_194549((*result).typ, (*(*result).typ).owner, NIM_TRUE));
				(*(*result).typ).flags |= ((NI32)1)<<((((NU8) 9))%(sizeof(NI32)*8));
			}
			LA14: ;
			{
				if (!((*result).kind == ((NU8) 4))) goto LA30;
				{
					NIM_BOOL LOC34;
					NIM_BOOL LOC35;
					NI LOC37;
					LOC34 = 0;
					LOC35 = 0;
					LOC35 = ((*(*result).typ).kind == ((NU8) 12));
					if (!(LOC35)) goto LA36;
					LOC37 = 0;
					LOC37 = len_194377((*result).typ);
					LOC35 = (LOC37 == ((NI) 0));
					LA36: ;
					LOC34 = LOC35;
					if (!(LOC34)) goto LA38;
					LOC34 = (((*(*result).typ).flags &(1<<((((NU8) 25))&31)))!=0);
					LA38: ;
					if (!LOC34) goto LA39;
					(*result).kind = ((NU8) 7);
					(*(*result).typ).flags &= ~(((NI32)1) << ((((NU8) 25)) % (sizeof(NI32)*8)));
					goto BeforeRet;
				}
				goto LA32;
				LA39: ;
				{
					localerror_166155((*n).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
					result = errorsym_250372(c, n);
					goto BeforeRet;
				}
				LA32: ;
			}
			LA30: ;
			{
				Toverloaditer250431 ov;
				Tsym191843* amb;
				if (!!(((*result).kind == ((NU8) 7)))) goto LA44;
				memset((void*)(&ov), 0, sizeof(ov));
				amb = initoverloaditer_251108((&ov), c, n);
				{
					while (1) {
						NIM_BOOL LOC48;
						LOC48 = 0;
						LOC48 = !((amb == NIM_NIL));
						if (!(LOC48)) goto LA49;
						LOC48 = !(((*amb).kind == ((NU8) 7)));
						LA49: ;
						if (!LOC48) goto LA47;
						amb = nextoverloaditer_251277((&ov), c, n);
					} LA47: ;
				}
				{
					if (!!((amb == NIM_NIL))) goto LA52;
					result = amb;
				}
				goto LA50;
				LA52: ;
				{
					{
						if (!!(((*result).kind == ((NU8) 0)))) goto LA57;
						localerror_166155((*n).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
					}
					LA57: ;
					result = errorsym_250372(c, n);
					goto BeforeRet;
				}
				LA50: ;
			}
			LA44: ;
			{
				Tlineinfo164338 oldinfo;
				if (!!(((*(*result).typ).kind == ((NU8) 12)))) goto LA61;
				oldinfo = (*n).info;
				genericReset((void*)(&(*n)), (&NTI191813));
				(*n).kind = ((NU8) 3);
				asgnRefNoCycle((void**) (&(*n).kindU.S4.sym), result);
				(*n).info = oldinfo;
				asgnRefNoCycle((void**) (&(*n).typ), (*result).typ);
			}
			LA61: ;
		}
		goto LA6;
		LA8: ;
		{
			localerror_166155((*n).info, ((NU16) 19), ((NimStringDesc*) &TMP2991));
			result = errorsym_250372(c, n);
		}
		LA6: ;
	}
	LA1: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, semarrayindex_417610)(Tcontext245023* c, Tnode191813* n) {
	Ttype191849* result;
{	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = isrange_220612(n);
		if (!LOC3) goto LA4;
		result = semrangeaux_417292(c, n, NIM_NIL);
	}
	goto LA1;
	LA4: ;
	{
		Tnode191813* e;
		e = semexprwithtype_410211(c, n, 32);
		{
			if (!((*(*e).typ).kind == ((NU8) 60))) goto LA9;
			result = makerangewithstaticexpr_246084(c, (*(*e).typ).n);
		}
		goto LA7;
		LA9: ;
		{
			if (!((*e).kind >= ((NU8) 6) && (*e).kind <= ((NU8) 15))) goto LA12;
			result = makerangetype_246182(c, IL64(0), (NI64)((*e).kindU.S1.intval - IL64(1)), (*n).info, (*e).typ);
		}
		goto LA7;
		LA12: ;
		{
			NIM_BOOL LOC15;
			LOC15 = 0;
			LOC15 = ((*e).kind == ((NU8) 3));
			if (!(LOC15)) goto LA16;
			LOC15 = ((*(*e).typ).kind == ((NU8) 59));
			LA16: ;
			if (!LOC15) goto LA17;
			{
				if (!!(((*(*e).kindU.S4.sym).ast == NIM_NIL))) goto LA21;
				result = semarrayindex_417610(c, (*(*e).kindU.S4.sym).ast);
				goto BeforeRet;
			}
			LA21: ;
			{
				Ttype191849* LOC25;
				NIM_BOOL LOC26;
				Tnode191813* LOC29;
				LOC25 = 0;
				LOC25 = lastson_194442((*e).typ);
				LOC26 = 0;
				LOC26 = isordinaltype_221093(LOC25);
				if (!!(LOC26)) goto LA27;
				LOC29 = 0;
				LOC29 = HEX5BHEX5D_192244(n, ((NI) 1));
				localerror_166155((*LOC29).info, ((NU16) 74), ((NimStringDesc*) &TMP2991));
			}
			LA27: ;
			result = makerangewithstaticexpr_246084(c, e);
			{
				if (!(((NI) 0) < (*c).ingenericcontext)) goto LA32;
				(*result).flags |= ((NI32)1)<<((((NU8) 9))%(sizeof(NI32)*8));
			}
			LA32: ;
		}
		goto LA7;
		LA17: ;
		{
			NIM_BOOL LOC35;
			LOC35 = 0;
			LOC35 = ((*e).kind == ((NU8) 27) || (*e).kind == ((NU8) 29) || (*e).kind == ((NU8) 30) || (*e).kind == ((NU8) 31) || (*e).kind == ((NU8) 26) || (*e).kind == ((NU8) 28) || (*e).kind == ((NU8) 32));
			if (!(LOC35)) goto LA36;
			LOC35 = hasgenericarguments_266765(e);
			LA36: ;
			if (!LOC35) goto LA37;
			{
				NIM_BOOL LOC41;
				Tnode191813* LOC44;
				LOC41 = 0;
				LOC41 = isordinaltype_221093((*e).typ);
				if (!!(LOC41)) goto LA42;
				LOC44 = 0;
				LOC44 = HEX5BHEX5D_192244(n, ((NI) 1));
				localerror_166155((*LOC44).info, ((NU16) 74), ((NimStringDesc*) &TMP2991));
			}
			LA42: ;
			result = makerangewithstaticexpr_246084(c, e);
		}
		goto LA7;
		LA37: ;
		{
			if (!((*e).kind == ((NU8) 2))) goto LA46;
			result = skiptypes_195167((*e).typ, 256);
		}
		goto LA7;
		LA46: ;
		{
			Tnode191813* x;
			x = semconstexpr_411485(c, e);
			{
				Ttype191849* LOC53;
				if (!((*x).kind >= ((NU8) 6) && (*x).kind <= ((NU8) 15))) goto LA51;
				LOC53 = 0;
				LOC53 = skiptypes_195167((*x).typ, 256);
				result = makerangetype_246182(c, IL64(0), (NI64)((*x).kindU.S1.intval - IL64(1)), (*n).info, LOC53);
			}
			goto LA49;
			LA51: ;
			{
				result = skiptypes_195167((*x).typ, 256);
			}
			LA49: ;
		}
		LA7: ;
	}
	LA1: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, semarray_417720)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	Ttype191849* base;
	result = 0;
	base = 0;
	result = neworprevtype_416695(((NU8) 16), prev, c);
	{
		NI LOC3;
		Ttype191849* indx;
		Tnode191813* LOC6;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 3))) goto LA4;
		LOC6 = 0;
		LOC6 = HEX5BHEX5D_192244(n, ((NI) 1));
		indx = semarrayindex_417610(c, LOC6);
		addsonskipintlit_239731(result, indx);
		{
			if (!((*indx).kind == ((NU8) 11))) goto LA9;
			indx = lastson_194442(indx);
		}
		LA9: ;
		{
			if (!!(((IL64(1729382256910274560) &(IL64(1)<<(((*indx).kind)&IL64(63))))!=0))) goto LA13;
			{
				NIM_BOOL LOC17;
				LOC17 = 0;
				LOC17 = isordinaltype_221093(indx);
				if (!!(LOC17)) goto LA18;
				localerror_166155((*(*n).kindU.S6.sons->data[((NI) 1)]).info, ((NU16) 74), ((NimStringDesc*) &TMP2991));
			}
			goto LA15;
			LA18: ;
			{
				NIM_BOOL LOC21;
				Ttype191849* LOC24;
				NimStringDesc* LOC25;
				LOC21 = 0;
				LOC21 = enumhasholes_221099(indx);
				if (!LOC21) goto LA22;
				LOC24 = 0;
				LOC24 = skiptypes_195167(indx, 1048576);
				LOC25 = 0;
				LOC25 = typetostring_221032(LOC24, ((NU8) 0));
				localerror_166155((*(*n).kindU.S6.sons->data[((NI) 1)]).info, ((NU16) 146), LOC25);
			}
			goto LA15;
			LA22: ;
			LA15: ;
		}
		LA13: ;
		base = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 2)], NIM_NIL);
		addsonskipintlit_239731(result, base);
	}
	goto LA1;
	LA4: ;
	{
		localerror_166155((*n).info, ((NU16) 173), ((NimStringDesc*) &TMP2991));
		result = neworprevtype_416695(((NU8) 50), prev, c);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, semcontainer_417086)(Tcontext245023* c, Tnode191813* n, NU8 kind, NimStringDesc* kindstr, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	result = neworprevtype_416695(kind, prev, c);
	{
		NI LOC3;
		Ttype191849* base;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 2))) goto LA4;
		base = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 1)], NIM_NIL);
		addsonskipintlit_239731(result, base);
	}
	goto LA1;
	LA4: ;
	{
		Ttype191849* LOC7;
		localerror_166155((*n).info, ((NU16) 172), kindstr);
		LOC7 = 0;
		LOC7 = errortype_246150(c);
		addsonskipintlit_239731(result, LOC7);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, semrange_417501)(Tcontext245023* c, Tnode191813* n_417504, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	result = NIM_NIL;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n_417504);
		if (!(LOC3 == ((NI) 2))) goto LA4;
		{
			Tnode191813* LOC8;
			NIM_BOOL LOC9;
			Tnode191813* LOC12;
			Tnode191813* n;
			LOC8 = 0;
			LOC8 = HEX5BHEX5D_192244(n_417504, ((NI) 1));
			LOC9 = 0;
			LOC9 = isrange_220612(LOC8);
			if (!LOC9) goto LA10;
			LOC12 = 0;
			LOC12 = HEX5BHEX5D_192244(n_417504, ((NI) 1));
			result = semrangeaux_417292(c, LOC12, prev);
			n = (*result).n;
			{
				NIM_BOOL LOC15;
				LOC15 = 0;
				LOC15 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind >= ((NU8) 5) && (*(*n).kindU.S6.sons->data[((NI) 0)]).kind <= ((NU8) 15));
				if (!(LOC15)) goto LA16;
				LOC15 = (IL64(0) < (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S1.intval);
				LA16: ;
				if (!LOC15) goto LA17;
				(*result).flags |= ((NI32)1)<<((((NU8) 17))%(sizeof(NI32)*8));
			}
			goto LA13;
			LA17: ;
			{
				NIM_BOOL LOC20;
				LOC20 = 0;
				LOC20 = ((*(*n).kindU.S6.sons->data[((NI) 1)]).kind >= ((NU8) 5) && (*(*n).kindU.S6.sons->data[((NI) 1)]).kind <= ((NU8) 15));
				if (!(LOC20)) goto LA21;
				LOC20 = ((*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S1.intval < IL64(0));
				LA21: ;
				if (!LOC20) goto LA22;
				(*result).flags |= ((NI32)1)<<((((NU8) 17))%(sizeof(NI32)*8));
			}
			goto LA13;
			LA22: ;
			{
				NIM_BOOL LOC25;
				LOC25 = 0;
				LOC25 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind >= ((NU8) 16) && (*(*n).kindU.S6.sons->data[((NI) 0)]).kind <= ((NU8) 18));
				if (!(LOC25)) goto LA26;
				LOC25 = (0.0 < (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S2.floatval);
				LA26: ;
				if (!LOC25) goto LA27;
				(*result).flags |= ((NI32)1)<<((((NU8) 17))%(sizeof(NI32)*8));
			}
			goto LA13;
			LA27: ;
			{
				NIM_BOOL LOC30;
				LOC30 = 0;
				LOC30 = ((*(*n).kindU.S6.sons->data[((NI) 1)]).kind >= ((NU8) 16) && (*(*n).kindU.S6.sons->data[((NI) 1)]).kind <= ((NU8) 18));
				if (!(LOC30)) goto LA31;
				LOC30 = ((*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S2.floatval < 0.0);
				LA31: ;
				if (!LOC30) goto LA32;
				(*result).flags |= ((NI32)1)<<((((NU8) 17))%(sizeof(NI32)*8));
			}
			goto LA13;
			LA32: ;
			LA13: ;
		}
		goto LA6;
		LA10: ;
		{
			localerror_166155((*(*n_417504).kindU.S6.sons->data[((NI) 0)]).info, ((NU16) 96), ((NimStringDesc*) &TMP2991));
			result = neworprevtype_416695(((NU8) 50), prev, c);
		}
		LA6: ;
	}
	goto LA1;
	LA4: ;
	{
		localerror_166155((*n_417504).info, ((NU16) 172), ((NimStringDesc*) &TMP2998));
		result = neworprevtype_416695(((NU8) 50), prev, c);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, semset_417057)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	result = neworprevtype_416695(((NU8) 19), prev, c);
	{
		NI LOC3;
		Ttype191849* base;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 2))) goto LA4;
		base = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 1)], NIM_NIL);
		addsonskipintlit_239731(result, base);
		{
			if (!((*base).kind == ((NU8) 11))) goto LA8;
			base = lastson_194442(base);
		}
		LA8: ;
		{
			if (!!(((*base).kind == ((NU8) 12)))) goto LA12;
			{
				NIM_BOOL LOC16;
				LOC16 = 0;
				LOC16 = isordinaltype_221093(base);
				if (!!(LOC16)) goto LA17;
				localerror_166155((*n).info, ((NU16) 74), ((NimStringDesc*) &TMP2991));
			}
			goto LA14;
			LA17: ;
			{
				NI64 LOC20;
				LOC20 = 0;
				LOC20 = lengthord_221016(base);
				if (!(IL64(65536) < LOC20)) goto LA21;
				localerror_166155((*n).info, ((NU16) 119), ((NimStringDesc*) &TMP2991));
			}
			goto LA14;
			LA21: ;
			LA14: ;
		}
		LA12: ;
	}
	goto LA1;
	LA4: ;
	{
		Ttype191849* LOC24;
		localerror_166155((*n).info, ((NU16) 172), ((NimStringDesc*) &TMP2999));
		LOC24 = 0;
		LOC24 = errortype_246150(c);
		addsonskipintlit_239731(result, LOC24);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, semordinal_417756)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	result = neworprevtype_416695(((NU8) 15), prev, c);
	{
		NI LOC3;
		Ttype191849* base;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 2))) goto LA4;
		base = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 1)], NIM_NIL);
		{
			if (!!(((*base).kind == ((NU8) 12)))) goto LA8;
			{
				NIM_BOOL LOC12;
				LOC12 = 0;
				LOC12 = isordinaltype_221093(base);
				if (!!(LOC12)) goto LA13;
				localerror_166155((*(*n).kindU.S6.sons->data[((NI) 1)]).info, ((NU16) 74), ((NimStringDesc*) &TMP2991));
			}
			LA13: ;
		}
		LA8: ;
		addsonskipintlit_239731(result, base);
	}
	goto LA1;
	LA4: ;
	{
		localerror_166155((*n).info, ((NU16) 172), ((NimStringDesc*) &TMP3000));
		result = neworprevtype_416695(((NU8) 50), prev, c);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, semvarargs_417099)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	result = neworprevtype_416695(((NU8) 48), prev, c);
	{
		NIM_BOOL LOC3;
		NI LOC4;
		NI LOC6;
		Ttype191849* base;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = sonslen_194403(n);
		LOC3 = (LOC4 == ((NI) 2));
		if (LOC3) goto LA5;
		LOC6 = 0;
		LOC6 = sonslen_194403(n);
		LOC3 = (LOC6 == ((NI) 3));
		LA5: ;
		if (!LOC3) goto LA7;
		base = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 1)], NIM_NIL);
		addsonskipintlit_239731(result, base);
		{
			NI LOC11;
			Tident168021* LOC14;
			LOC11 = 0;
			LOC11 = sonslen_194403(n);
			if (!(LOC11 == ((NI) 3))) goto LA12;
			LOC14 = 0;
			LOC14 = considerquotedident_250010((*n).kindU.S6.sons->data[((NI) 2)]);
			asgnRefNoCycle((void**) (&(*result).n), newidentnode_193313(LOC14, (*(*n).kindU.S6.sons->data[((NI) 2)]).info));
		}
		LA12: ;
	}
	goto LA1;
	LA7: ;
	{
		Ttype191849* LOC16;
		localerror_166155((*n).info, ((NU16) 172), ((NimStringDesc*) &TMP3002));
		LOC16 = 0;
		LOC16 = errortype_246150(c);
		addsonskipintlit_239731(result, LOC16);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, semgenericparamininvocation_421915)(Tcontext245023* c, Tnode191813* n) {
	Ttype191849* result;
	result = 0;
	result = semtypenode_410269(c, n, NIM_NIL);
	return result;
}

static N_INLINE(void, appendString)(NimStringDesc* dest, NimStringDesc* src) {
	memcpy(((NCSTRING) ((&(*dest).data[((*dest).Sup.len)- 0]))), ((NCSTRING) ((*src).data)), (NI)((*src).Sup.len + ((NI) 1)));
	(*dest).Sup.len += (*src).Sup.len;
}

N_NIMCALL(Ttype191849*, instgenericcontainer_413151)(Tcontext245023* c, Tlineinfo164338 info, Ttype191849* header, NIM_BOOL allowmetatypes) {
	Ttype191849* result;
	Trepltypevars266544 cl;
	result = 0;
	memset((void*)(&cl), 0, sizeof(cl));
	initidtable_195057((&cl.symmap));
	initidtable_195057((&cl.typemap));
	initidtable_195057((&cl.localcache));
	cl.info = info;
	cl.c = c;
	cl.allowmetatypes = allowmetatypes;
	result = replacetypevarst_266592((&cl), header);
	return result;
}

N_NIMCALL(Ttype191849*, semgeneric_421923)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, Ttype191849* prev) {
	Ttype191849* result;
	Ttype191849* t;
{	result = 0;
	{
		TY155965 LOC5;
		NimStringDesc* LOC6;
		NimStringDesc* LOC7;
		if (!((*s).typ == NIM_NIL)) goto LA3;
		memset((void*)LOC5, 0, sizeof(LOC5));
		LOC5[0] = copyString((*(*s).name).s);
		LOC6 = 0;
		LOC6 = copyStr(reprEnum((*s).kind, (&NTI191441)), ((NI) 2));
		LOC5[1] = nsuToLowerStr(LOC6);
		LOC7 = 0;
		LOC7 = nsuFormatOpenArray(((NimStringDesc*) &TMP3003), LOC5, 2);
		localerror_166166((*n).info, LOC7);
		result = neworprevtype_416695(((NU8) 50), prev, c);
		goto BeforeRet;
	}
	LA3: ;
	t = (*s).typ;
	{
		NIM_BOOL LOC10;
		Ttype191849* LOC12;
		LOC10 = 0;
		LOC10 = ((*t).kind == ((NU8) 54));
		if (!(LOC10)) goto LA11;
		LOC12 = 0;
		LOC12 = base_221039(t);
		LOC10 = ((*LOC12).kind == ((NU8) 10));
		LA11: ;
		if (!LOC10) goto LA13;
		t = base_221039(t);
	}
	LA13: ;
	result = neworprevtype_416695(((NU8) 9), prev, c);
	addsonskipintlit_239731(result, t);
	{
		if (!((*t).kind == ((NU8) 30))) goto LA17;
		{
			NI i_422000;
			NI HEX3Atmp_422136;
			NI LOC20;
			NI res_422139;
			i_422000 = 0;
			HEX3Atmp_422136 = 0;
			LOC20 = 0;
			LOC20 = sonslen_194403(n);
			HEX3Atmp_422136 = (NI)(LOC20 - ((NI) 1));
			res_422139 = ((NI) 1);
			{
				while (1) {
					Ttype191849* elem;
					if (!(res_422139 <= HEX3Atmp_422136)) goto LA22;
					i_422000 = res_422139;
					elem = semgenericparamininvocation_421915(c, (*n).kindU.S6.sons->data[i_422000]);
					{
						if (!elem == 0) goto LA25;
						{
							NimStringDesc* LOC31;
							if (!NIM_TRUE) goto LA29;
							LOC31 = 0;
							LOC31 = HEX24_166306(TMP3004);
							internalerror_166218(LOC31);
						}
						LA29: ;
						rawaddson_195478(result, elem);
					}
					goto LA23;
					LA25: ;
					{
						addsonskipintlit_239731(result, elem);
					}
					LA23: ;
					res_422139 += ((NI) 1);
				} LA22: ;
			}
		}
		goto BeforeRet;
	}
	goto LA15;
	LA17: ;
	{
		if (!!(((*t).kind == ((NU8) 10)))) goto LA34;
		localerror_166155((*n).info, ((NU16) 156), (*(*s).name).s);
		result = neworprevtype_416695(((NU8) 50), prev, c);
		goto BeforeRet;
	}
	goto LA15;
	LA34: ;
	{
		Tcandidate345209 m;
		Tnode191813* LOC37;
		NIM_BOOL isconcrete;
		memset((void*)(&m), 0, sizeof(m));
		chckNil((void*)(&m));
		memset((void*)(&m), 0, sizeof(m));
		newcandidate_345478(c, t, (&m));
		LOC37 = 0;
		LOC37 = copytree_196028(n);
		matches_351449(c, n, LOC37, (&m));
		{
			NIM_BOOL LOC40;
			NimStringDesc* err;
			NimStringDesc* LOC44;
			NimStringDesc* LOC45;
			NimStringDesc* LOC46;
			NimStringDesc* LOC47;
			LOC40 = 0;
			LOC40 = !((m.state == ((NU8) 1)));
			if (!(LOC40)) goto LA41;
			LOC40 = !(m.typedescmatched);
			LA41: ;
			if (!LOC40) goto LA42;
			LOC44 = 0;
			LOC45 = 0;
			LOC45 = typetostring_221032(t, ((NU8) 0));
			LOC46 = 0;
			LOC46 = describeargs_345974(c, n, ((NI) 1), ((NU8) 0));
			LOC47 = 0;
			LOC47 = describeargs_345974(c, (*t).n, ((NI) 0), ((NU8) 0));
			LOC44 = rawNewString(LOC45->Sup.len + LOC46->Sup.len + LOC47->Sup.len + 44);
appendString(LOC44, ((NimStringDesc*) &TMP3006));
appendString(LOC44, LOC45);
appendString(LOC44, ((NimStringDesc*) &TMP3007));
appendString(LOC44, LOC46);
appendString(LOC44, ((NimStringDesc*) &TMP3011));
appendString(LOC44, LOC47);
appendString(LOC44, ((NimStringDesc*) &TMP3012));
			err = LOC44;
			localerror_166155((*n).info, ((NU16) 4), err);
			result = neworprevtype_416695(((NU8) 50), prev, c);
			goto BeforeRet;
		}
		LA42: ;
		isconcrete = NIM_TRUE;
		{
			NI i_422060;
			NI HEX3Atmp_422144;
			NI LOC49;
			NI res_422147;
			i_422060 = 0;
			HEX3Atmp_422144 = 0;
			LOC49 = 0;
			LOC49 = len_192097(m.call);
			HEX3Atmp_422144 = (LOC49 - 1);
			res_422147 = ((NI) 1);
			{
				while (1) {
					Ttype191849* typ;
					Tnode191813* LOC52;
					if (!(res_422147 <= HEX3Atmp_422144)) goto LA51;
					i_422060 = res_422147;
					LOC52 = 0;
					LOC52 = HEX5BHEX5D_192244(m.call, i_422060);
					typ = (*LOC52).typ;
					{
						NIM_BOOL LOC55;
						LOC55 = 0;
						LOC55 = ((*typ).kind == ((NU8) 8));
						if (!(LOC55)) goto LA56;
						LOC55 = ((*(*typ).sons->data[((NI) 0)]).kind == ((NU8) 0));
						LA56: ;
						if (!LOC55) goto LA57;
						isconcrete = NIM_FALSE;
						{
							if (!typ == 0) goto LA61;
							{
								NimStringDesc* LOC67;
								if (!NIM_TRUE) goto LA65;
								LOC67 = 0;
								LOC67 = HEX24_166306(TMP3004);
								internalerror_166218(LOC67);
							}
							LA65: ;
							rawaddson_195478(result, typ);
						}
						goto LA59;
						LA61: ;
						{
							addsonskipintlit_239731(result, typ);
						}
						LA59: ;
					}
					goto LA53;
					LA57: ;
					{
						typ = skiptypes_195167(typ, 256);
						{
							NIM_BOOL LOC72;
							LOC72 = 0;
							LOC72 = containsgenerictype_230310(typ);
							if (!LOC72) goto LA73;
							isconcrete = NIM_FALSE;
						}
						LA73: ;
						{
							if (!typ == 0) goto LA77;
							{
								NimStringDesc* LOC83;
								if (!NIM_TRUE) goto LA81;
								LOC83 = 0;
								LOC83 = HEX24_166306(TMP3004);
								internalerror_166218(LOC83);
							}
							LA81: ;
							rawaddson_195478(result, typ);
						}
						goto LA75;
						LA77: ;
						{
							addsonskipintlit_239731(result, typ);
						}
						LA75: ;
					}
					LA53: ;
					res_422147 += ((NI) 1);
				} LA51: ;
			}
		}
		{
			if (!isconcrete) goto LA87;
			{
				NIM_BOOL LOC91;
				LOC91 = 0;
				LOC91 = ((*s).ast == NIM_NIL);
				if (!(LOC91)) goto LA92;
				LOC91 = !(((*(*s).typ).kind == ((NU8) 54)));
				LA92: ;
				if (!LOC91) goto LA93;
				localerror_166155((*n).info, ((NU16) 124), (*(*s).name).s);
				result = neworprevtype_416695(((NU8) 50), prev, c);
			}
			goto LA89;
			LA93: ;
			{
				result = instgenericcontainer_413151(c, (*n).info, result, NIM_FALSE);
			}
			LA89: ;
		}
		LA87: ;
	}
	LA15: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, symchoice_423316)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU8 r) {
	Tnode191813* result;
	Tsym191843* a;
	Toverloaditer250431 o;
	NI i;
	result = 0;
	a = 0;
	memset((void*)(&o), 0, sizeof(o));
	i = ((NI) 0);
	a = initoverloaditer_251108((&o), c, n);
	{
		while (1) {
			if (!!((a == NIM_NIL))) goto LA2;
			a = nextoverloaditer_251277((&o), c, n);
			i += ((NI) 1);
			{
				if (!(((NI) 1) < i)) goto LA5;
				goto LA1;
			}
			LA5: ;
		} LA2: ;
	} LA1: ;
	{
		NIM_BOOL LOC9;
		LOC9 = 0;
		LOC9 = (i <= ((NI) 1));
		if (!(LOC9)) goto LA10;
		LOC9 = !((r == ((NU8) 2)));
		LA10: ;
		if (!LOC9) goto LA11;
		result = newsymnode_193338(s, (*n).info);
		markused_345251((*n).info, s);
	}
	goto LA7;
	LA11: ;
	{
		NU8 kind;
		Ttype191849* LOC21;
		{
			NIM_BOOL LOC16;
			LOC16 = 0;
			LOC16 = (r == ((NU8) 0));
			if (LOC16) goto LA17;
			LOC16 = ((*n).kind == ((NU8) 45));
			LA17: ;
			if (!LOC16) goto LA18;
			kind = ((NU8) 56);
		}
		goto LA14;
		LA18: ;
		{
			kind = ((NU8) 57);
		}
		LA14: ;
		LOC21 = 0;
		LOC21 = newtypes_245218(((NU8) 0), c);
		result = newnodeit_193807(kind, (*n).info, LOC21);
		a = initoverloaditer_251108((&o), c, n);
		{
			while (1) {
				Tnode191813* LOC24;
				if (!!((a == NIM_NIL))) goto LA23;
				(*a).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
				LOC24 = 0;
				LOC24 = newsymnode_193338(a, (*n).info);
				addson_193819(result, LOC24);
				a = nextoverloaditer_251277((&o), c, n);
			} LA23: ;
		}
	}
	LA7: ;
	return result;
}

N_NIMCALL(Tnode191813*, semtemplateexpr_411055)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU16 flags) {
	Tnode191813* result;
	Tsym191843* LOC1;
	result = 0;
	markused_345251((*n).info, s);
	pushinfocontext_165189((*n).info);
	LOC1 = 0;
	LOC1 = getcurrowner_245255();
	result = evaltemplate_384260(n, s, LOC1);
	{
		if (!!(((flags &(1<<((((NU8) 9))&15)))!=0))) goto LA4;
		result = semaftermacrocall_416431(c, result, s, flags);
	}
	LA4: ;
	popinfocontext_165208();
	return result;
}

N_NIMCALL(Tnode191813*, semgenericstmtsymbol_427643)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, Genericctx427608* ctx) {
	Tnode191813* result;
	result = 0;
	(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
	switch ((*s).kind) {
	case ((NU8) 0):
	{
		result = n;
	}
	break;
	case ((NU8) 12):
	case ((NU8) 13):
	case ((NU8) 14):
	case ((NU8) 16):
	case ((NU8) 15):
	{
		result = symchoice_423316(c, n, s, ((NU8) 1));
	}
	break;
	case ((NU8) 18):
	{
		{
			NIM_BOOL LOC6;
			NIM_BOOL LOC8;
			NI LOC9;
			LOC6 = 0;
			LOC6 = ((393216 &(1<<(((*s).kind)&31)))!=0);
			if (!(LOC6)) goto LA7;
			LOC8 = 0;
			LOC9 = 0;
			LOC9 = len_194377((*s).typ);
			LOC8 = (LOC9 == ((NI) 1));
			if (LOC8) goto LA10;
			LOC8 = (((*s).flags &(1<<((((NU8) 25))&31)))!=0);
			LA10: ;
			LOC6 = LOC8;
			LA7: ;
			if (!LOC6) goto LA11;
			result = semtemplateexpr_411055(c, n, s, 512);
			result = semgenericstmt_427618(c, result, 0, ctx);
		}
		goto LA4;
		LA11: ;
		{
			result = symchoice_423316(c, n, s, ((NU8) 1));
		}
		LA4: ;
	}
	break;
	case ((NU8) 17):
	{
		{
			NIM_BOOL LOC17;
			NIM_BOOL LOC19;
			NI LOC20;
			LOC17 = 0;
			LOC17 = ((393216 &(1<<(((*s).kind)&31)))!=0);
			if (!(LOC17)) goto LA18;
			LOC19 = 0;
			LOC20 = 0;
			LOC20 = len_194377((*s).typ);
			LOC19 = (LOC20 == ((NI) 1));
			if (LOC19) goto LA21;
			LOC19 = (((*s).flags &(1<<((((NU8) 25))&31)))!=0);
			LA21: ;
			LOC17 = LOC19;
			LA18: ;
			if (!LOC17) goto LA22;
			result = semmacroexpr_411066(c, n, n, s, 512);
			result = semgenericstmt_427618(c, result, 0, ctx);
		}
		goto LA15;
		LA22: ;
		{
			result = symchoice_423316(c, n, s, ((NU8) 1));
		}
		LA15: ;
	}
	break;
	case ((NU8) 4):
	{
		{
			NIM_BOOL LOC28;
			LOC28 = 0;
			LOC28 = !(((*s).typ == NIM_NIL));
			if (!(LOC28)) goto LA29;
			LOC28 = ((*(*s).typ).kind == ((NU8) 59));
			LA29: ;
			if (!LOC28) goto LA30;
			{
				if (!!(((*(*s).typ).n == NIM_NIL))) goto LA34;
				result = (*(*s).typ).n;
			}
			goto LA32;
			LA34: ;
			{
				result = n;
			}
			LA32: ;
		}
		goto LA26;
		LA30: ;
		{
			result = newsymnodetypedesc_258736(s, (*n).info);
		}
		LA26: ;
	}
	break;
	case ((NU8) 3):
	{
		result = n;
	}
	break;
	case ((NU8) 7):
	{
		{
			NIM_BOOL LOC42;
			LOC42 = 0;
			LOC42 = !(((*s).typ == NIM_NIL));
			if (!(LOC42)) goto LA43;
			LOC42 = (((*(*s).typ).flags & 25165824) == 0);
			LA43: ;
			if (!LOC42) goto LA44;
			result = newsymnodetypedesc_258736(s, (*n).info);
		}
		goto LA40;
		LA44: ;
		{
			result = n;
		}
		LA40: ;
	}
	break;
	default:
	{
		result = newsymnode_193338(s, (*n).info);
	}
	break;
	}
	return result;
}

N_NIMCALL(Tnode191813*, lookup_429004)(Tcontext245023* c, Tnode191813* n, NU8 flags, Genericctx427608* ctx) {
	Tnode191813* result;
	Tident168021* ident;
	Tsym191843* s;
	Tsym191843* LOC1;
	result = 0;
	result = n;
	ident = considerquotedident_250010(n);
	LOC1 = 0;
	LOC1 = searchinscopes_250205(c, ident);
	s = skipalias_250150(LOC1, n);
	{
		if (!(s == NIM_NIL)) goto LA4;
		{
			NIM_BOOL LOC8;
			NIM_BOOL LOC9;
			LOC8 = 0;
			LOC9 = 0;
			LOC9 = contains_188829((&(*ctx).tomixin), (*ident).Sup.id);
			LOC8 = !(LOC9);
			if (!(LOC8)) goto LA10;
			LOC8 = !(((flags &(1<<((((NU8) 2))&7)))!=0));
			LA10: ;
			if (!LOC8) goto LA11;
			localerror_166155((*n).info, ((NU16) 61), (*ident).s);
		}
		LA11: ;
	}
	goto LA2;
	LA4: ;
	{
		{
			if (!((flags &(1<<((((NU8) 0))&7)))!=0)) goto LA16;
			result = symchoice_423316(c, n, s, ((NU8) 0));
		}
		goto LA14;
		LA16: ;
		{
			NIM_BOOL LOC19;
			LOC19 = 0;
			LOC19 = contains_188829((&(*ctx).tomixin), (*(*s).name).Sup.id);
			if (!LOC19) goto LA20;
			result = symchoice_423316(c, n, s, ((NU8) 2));
		}
		goto LA14;
		LA20: ;
		{
			result = semgenericstmtsymbol_427643(c, n, s, ctx);
		}
		LA14: ;
	}
	LA2: ;
	return result;
}

N_NIMCALL(Tnode191813*, newdot_429051)(Tnode191813* n, Tnode191813* b) {
	Tnode191813* result;
	result = 0;
	result = newnodei_193351(((NU8) 45), (*n).info);
	add_192164(result, (*n).kindU.S6.sons->data[((NI) 0)]);
	add_192164(result, b);
	return result;
}

N_NIMCALL(Tnode191813*, fuzzylookup_429062)(Tcontext245023* c, Tnode191813* n_429065, NU8 flags, Genericctx427608* ctx, NIM_BOOL* ismacro) {
	Tnode191813* result;
	NU8 luf;
	Tsym191843* s_429415;
	result = 0;
	{
		if (!!(((flags &(1<<((((NU8) 2))&7)))!=0))) goto LA3;
		luf = 2;
	}
	goto LA1;
	LA3: ;
	{
		luf = 0;
	}
	LA1: ;
	s_429415 = qualifiedlookup_250864(c, n_429065, luf);
	{
		if (!!((s_429415 == NIM_NIL))) goto LA8;
		result = semgenericstmtsymbol_427643(c, n_429065, s_429415, ctx);
	}
	goto LA6;
	LA8: ;
	{
		Tnode191813* n;
		Tident168021* ident;
		Tsym191843* s;
		Tsym191843* LOC11;
		asgnRefNoCycle((void**) (&(*n_429065).kindU.S6.sons->data[((NI) 0)]), semgenericstmt_427618(c, (*n_429065).kindU.S6.sons->data[((NI) 0)], flags, ctx));
		result = n_429065;
		n = HEX5BHEX5D_192244(n_429065, ((NI) 1));
		ident = considerquotedident_250010(n);
		LOC11 = 0;
		LOC11 = searchinscopes_250205(c, ident);
		s = skipalias_250150(LOC11, n);
		{
			NIM_BOOL LOC14;
			LOC14 = 0;
			LOC14 = !((s == NIM_NIL));
			if (!(LOC14)) goto LA15;
			LOC14 = ((520192 &(1<<(((*s).kind)&31)))!=0);
			LA15: ;
			if (!LOC14) goto LA16;
			(*ismacro) = ((393216 &(1<<(((*s).kind)&31)))!=0);
			{
				Tnode191813* LOC22;
				if (!((flags &(1<<((((NU8) 0))&7)))!=0)) goto LA20;
				LOC22 = 0;
				LOC22 = symchoice_423316(c, n, s, ((NU8) 0));
				result = newdot_429051(result, LOC22);
			}
			goto LA18;
			LA20: ;
			{
				NIM_BOOL LOC24;
				Tnode191813* LOC27;
				LOC24 = 0;
				LOC24 = contains_188829((&(*ctx).tomixin), (*(*s).name).Sup.id);
				if (!LOC24) goto LA25;
				LOC27 = 0;
				LOC27 = symchoice_423316(c, n, s, ((NU8) 2));
				result = newdot_429051(result, LOC27);
			}
			goto LA18;
			LA25: ;
			{
				Tnode191813* sym;
				sym = semgenericstmtsymbol_427643(c, n, s, ctx);
				{
					Tnode191813* LOC33;
					if (!((*sym).kind == ((NU8) 3))) goto LA31;
					LOC33 = 0;
					LOC33 = symchoice_423316(c, n, s, ((NU8) 2));
					result = newdot_429051(result, LOC33);
				}
				goto LA29;
				LA31: ;
				{
					result = newdot_429051(result, sym);
				}
				LA29: ;
			}
			LA18: ;
		}
		LA16: ;
	}
	LA6: ;
	return result;
}

N_NIMCALL(Tnode191813*, semmixinstmt_423521)(Tcontext245023* c, Tnode191813* n, Intset188056* tomixin) {
	Tnode191813* result;
	result = 0;
	{
		NI i_423547;
		NI HEX3Atmp_423550;
		NI LOC2;
		NI res_423553;
		i_423547 = 0;
		HEX3Atmp_423550 = 0;
		LOC2 = 0;
		LOC2 = len_192097(n);
		HEX3Atmp_423550 = (LOC2 - 1);
		res_423553 = ((NI) 0);
		{
			while (1) {
				Tident168021* LOC5;
				if (!(res_423553 <= HEX3Atmp_423550)) goto LA4;
				i_423547 = res_423553;
				LOC5 = 0;
				LOC5 = considerquotedident_250010((*n).kindU.S6.sons->data[i_423547]);
				incl_188856(tomixin, (*LOC5).Sup.id);
				res_423553 += ((NI) 1);
			} LA4: ;
		}
	}
	result = newnodei_193351(((NU8) 1), (*n).info);
	return result;
}

N_NIMCALL(Tnode191813*, semgenericstmtscope_427625)(Tcontext245023* c, Tnode191813* n, NU8 flags, Genericctx427608* ctx) {
	Tnode191813* result;
	Tscope191837* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	result = semgenericstmt_427618(c, n, flags, ctx);
	closescope_250111(c);
	return result;
}

N_NIMCALL(Tsym191843*, newsyms_410904)(NU8 kind, Tnode191813* n, Tcontext245023* c) {
	Tsym191843* result;
	Tident168021* LOC1;
	Tsym191843* LOC2;
	result = 0;
	LOC1 = 0;
	LOC1 = considerquotedident_250010(n);
	LOC2 = 0;
	LOC2 = getcurrowner_245255();
	result = newsym_192655(kind, LOC1, LOC2, (*n).info);
	return result;
}

N_NIMCALL(Tnode191813*, getidentnode_427598)(Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	switch ((*n).kind) {
	case ((NU8) 31):
	{
		result = getidentnode_427598((*n).kindU.S6.sons->data[((NI) 1)]);
	}
	break;
	case ((NU8) 43):
	{
		result = getidentnode_427598((*n).kindU.S6.sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 2):
	case ((NU8) 53):
	case ((NU8) 3):
	{
		result = n;
	}
	break;
	default:
	{
		illformedast_246229(n);
		result = n;
	}
	break;
	}
	return result;
}

N_NIMCALL(void, addtempdecl_429491)(Tcontext245023* c, Tnode191813* n, NU8 kind) {
	Tsym191843* s;
	Tnode191813* LOC1;
	LOC1 = 0;
	LOC1 = getidentnode_427598(n);
	s = newsyms_410904(((NU8) 0), LOC1, c);
	addprelimdecl_250619(c, s);
}

N_NIMCALL(Tnode191813*, semgenericstmt_427618)(Tcontext245023* c, Tnode191813* n, NU8 flags_427622, Genericctx427608* ctx) {
	Tnode191813* result;
	result = 0;
	result = n;
	switch ((*n).kind) {
	case ((NU8) 2):
	case ((NU8) 53):
	{
		result = lookup_429004(c, n, flags_427622, ctx);
	}
	break;
	case ((NU8) 45):
	{
		NIM_BOOL dummy;
		dummy = 0;
		result = fuzzylookup_429062(c, n, flags_427622, ctx, (&dummy));
	}
	break;
	case ((NU8) 1):
	case ((NU8) 3) ... ((NU8) 23):
	{
	}
	break;
	case ((NU8) 55):
	{
		result = semgenericstmt_427618(c, (*n).kindU.S6.sons->data[((NI) 0)], (flags_427622 | 1), ctx);
	}
	break;
	case ((NU8) 123):
	{
		result = semmixinstmt_423521(c, n, (&(*ctx).tomixin));
	}
	break;
	case ((NU8) 27):
	case ((NU8) 32):
	case ((NU8) 29):
	case ((NU8) 30):
	case ((NU8) 26):
	case ((NU8) 28):
	{
		Tnode191813* fn;
		Tsym191843* s;
		NI first;
		NIM_BOOL mixincontext;
		NU8 flags;
		checkminsonslen_246259(n, ((NI) 1));
		fn = (*n).kindU.S6.sons->data[((NI) 0)];
		s = qualifiedlookup_250864(c, fn, 0);
		{
			NIM_BOOL LOC9;
			NIM_BOOL LOC10;
			NIM_BOOL LOC11;
			Tident168021* LOC15;
			NIM_BOOL LOC16;
			NimStringDesc* LOC19;
			LOC9 = 0;
			LOC10 = 0;
			LOC11 = 0;
			LOC11 = (s == NIM_NIL);
			if (!(LOC11)) goto LA12;
			LOC11 = !(((flags_427622 &(1<<((((NU8) 2))&7)))!=0));
			LA12: ;
			LOC10 = LOC11;
			if (!(LOC10)) goto LA13;
			LOC10 = ((*fn).kind == ((NU8) 2) || (*fn).kind == ((NU8) 53));
			LA13: ;
			LOC9 = LOC10;
			if (!(LOC9)) goto LA14;
			LOC15 = 0;
			LOC15 = considerquotedident_250010(fn);
			LOC16 = 0;
			LOC16 = contains_188829((&(*ctx).tomixin), (*LOC15).Sup.id);
			LOC9 = !(LOC16);
			LA14: ;
			if (!LOC9) goto LA17;
			LOC19 = 0;
			LOC19 = rendertree_213058(fn, 0);
			localerror_166155((*n).info, ((NU16) 61), LOC19);
		}
		LA17: ;
		first = ((NI) 0);
		mixincontext = NIM_FALSE;
		{
			NU8 scoption;
			if (!!((s == NIM_NIL))) goto LA22;
			(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
			mixincontext = ((*s).magic == ((NU16) 1) || (*s).magic == ((NU16) 2) || (*s).magic == ((NU16) 3));
			{
				NIM_BOOL LOC26;
				LOC26 = 0;
				LOC26 = contains_188829((&(*ctx).tomixin), (*(*s).name).Sup.id);
				if (!LOC26) goto LA27;
				scoption = ((NU8) 2);
			}
			goto LA24;
			LA27: ;
			{
				scoption = ((NU8) 1);
			}
			LA24: ;
			switch ((*s).kind) {
			case ((NU8) 17):
			{
				{
					NIM_BOOL LOC33;
					NIM_BOOL LOC35;
					NI LOC36;
					LOC33 = 0;
					LOC33 = ((393216 &(1<<(((*s).kind)&31)))!=0);
					if (!(LOC33)) goto LA34;
					LOC35 = 0;
					LOC36 = 0;
					LOC36 = len_194377((*s).typ);
					LOC35 = (LOC36 == ((NI) 1));
					if (LOC35) goto LA37;
					LOC35 = (((*s).flags &(1<<((((NU8) 25))&31)))!=0);
					LA37: ;
					LOC33 = LOC35;
					LA34: ;
					if (!LOC33) goto LA38;
					result = semmacroexpr_411066(c, n, n, s, 512);
					result = semgenericstmt_427618(c, result, 0, ctx);
				}
				goto LA31;
				LA38: ;
				{
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), symchoice_423316(c, fn, s, scoption));
					result = n;
				}
				LA31: ;
				mixincontext = NIM_TRUE;
			}
			break;
			case ((NU8) 18):
			{
				{
					NIM_BOOL LOC44;
					NIM_BOOL LOC46;
					NI LOC47;
					LOC44 = 0;
					LOC44 = ((393216 &(1<<(((*s).kind)&31)))!=0);
					if (!(LOC44)) goto LA45;
					LOC46 = 0;
					LOC47 = 0;
					LOC47 = len_194377((*s).typ);
					LOC46 = (LOC47 == ((NI) 1));
					if (LOC46) goto LA48;
					LOC46 = (((*s).flags &(1<<((((NU8) 25))&31)))!=0);
					LA48: ;
					LOC44 = LOC46;
					LA45: ;
					if (!LOC44) goto LA49;
					result = semtemplateexpr_411055(c, n, s, 512);
					result = semgenericstmt_427618(c, result, 0, ctx);
				}
				goto LA42;
				LA49: ;
				{
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), symchoice_423316(c, fn, s, scoption));
					result = n;
				}
				LA42: ;
				mixincontext = NIM_TRUE;
			}
			break;
			case ((NU8) 0):
			case ((NU8) 3):
			{
			}
			break;
			case ((NU8) 12):
			case ((NU8) 13):
			case ((NU8) 14):
			case ((NU8) 16):
			case ((NU8) 15):
			{
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), symchoice_423316(c, fn, s, scoption));
				first = ((NI) 1);
			}
			break;
			case ((NU8) 4):
			{
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), newsymnodetypedesc_258736(s, (*fn).info));
				first = ((NI) 1);
			}
			break;
			case ((NU8) 7):
			{
				{
					NIM_BOOL LOC58;
					LOC58 = 0;
					LOC58 = !(((*s).typ == NIM_NIL));
					if (!(LOC58)) goto LA59;
					LOC58 = !(((*(*s).typ).kind == ((NU8) 12)));
					LA59: ;
					if (!LOC58) goto LA60;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), newsymnodetypedesc_258736(s, (*fn).info));
					first = ((NI) 1);
				}
				LA60: ;
			}
			break;
			default:
			{
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(s, (*fn).info));
				first = ((NI) 1);
			}
			break;
			}
		}
		goto LA20;
		LA22: ;
		{
			if (!((*fn).kind == ((NU8) 45))) goto LA64;
			asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), fuzzylookup_429062(c, fn, flags_427622, ctx, (&mixincontext)));
			first = ((NI) 1);
		}
		goto LA20;
		LA64: ;
		LA20: ;
		{
			if (!mixincontext) goto LA68;
			flags = (flags_427622 | 4);
		}
		goto LA66;
		LA68: ;
		{
			flags = flags_427622;
		}
		LA66: ;
		{
			NI i_430838;
			NI HEX3Atmp_431501;
			NI LOC72;
			NI res_431504;
			i_430838 = 0;
			HEX3Atmp_431501 = 0;
			LOC72 = 0;
			LOC72 = sonslen_194403(result);
			HEX3Atmp_431501 = (NI)(LOC72 - ((NI) 1));
			res_431504 = first;
			{
				while (1) {
					if (!(res_431504 <= HEX3Atmp_431501)) goto LA74;
					i_430838 = res_431504;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_430838]), semgenericstmt_427618(c, (*result).kindU.S6.sons->data[i_430838], flags, ctx));
					res_431504 += ((NI) 1);
				} LA74: ;
			}
		}
	}
	break;
	case ((NU8) 92):
	{
		{
			NI i_430853;
			NI HEX3Atmp_431509;
			NI LOC77;
			NI res_431512;
			i_430853 = 0;
			HEX3Atmp_431509 = 0;
			LOC77 = 0;
			LOC77 = sonslen_194403(n);
			HEX3Atmp_431509 = (NI)(LOC77 - ((NI) 1));
			res_431512 = ((NI) 0);
			{
				while (1) {
					if (!(res_431512 <= HEX3Atmp_431509)) goto LA79;
					i_430853 = res_431512;
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_430853]), semgenericstmtscope_427625(c, (*n).kindU.S6.sons->data[i_430853], flags_427622, ctx));
					res_431512 += ((NI) 1);
				} LA79: ;
			}
		}
	}
	break;
	case ((NU8) 93):
	{
		{
			NI i_430868;
			NI HEX3Atmp_431517;
			NI LOC82;
			NI res_431520;
			i_430868 = 0;
			HEX3Atmp_431517 = 0;
			LOC82 = 0;
			LOC82 = sonslen_194403(n);
			HEX3Atmp_431517 = (NI)(LOC82 - ((NI) 1));
			res_431520 = ((NI) 0);
			{
				while (1) {
					if (!(res_431520 <= HEX3Atmp_431517)) goto LA84;
					i_430868 = res_431520;
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_430868]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[i_430868], (flags_427622 | 4), ctx));
					res_431520 += ((NI) 1);
				} LA84: ;
			}
		}
	}
	break;
	case ((NU8) 96):
	{
		Tscope191837* LOC86;
		LOC86 = 0;
		LOC86 = openscope_250091(c);
		{
			NI i_430896;
			NI HEX3Atmp_431525;
			NI LOC88;
			NI res_431528;
			i_430896 = 0;
			HEX3Atmp_431525 = 0;
			LOC88 = 0;
			LOC88 = sonslen_194403(n);
			HEX3Atmp_431525 = (NI)(LOC88 - ((NI) 1));
			res_431528 = ((NI) 0);
			{
				while (1) {
					if (!(res_431528 <= HEX3Atmp_431525)) goto LA90;
					i_430896 = res_431528;
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_430896]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[i_430896], flags_427622, ctx));
					res_431528 += ((NI) 1);
				} LA90: ;
			}
		}
		closescope_250111(c);
	}
	break;
	case ((NU8) 97):
	{
		Tscope191837* LOC92;
		LOC92 = 0;
		LOC92 = openscope_250091(c);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[((NI) 0)], flags_427622, ctx));
		{
			NI i_430913;
			NI HEX3Atmp_431541;
			NI LOC94;
			NI res_431544;
			i_430913 = 0;
			HEX3Atmp_431541 = 0;
			LOC94 = 0;
			LOC94 = sonslen_194403(n);
			HEX3Atmp_431541 = (NI)(LOC94 - ((NI) 1));
			res_431544 = ((NI) 1);
			{
				while (1) {
					Tnode191813* a;
					NI L;
					if (!(res_431544 <= HEX3Atmp_431541)) goto LA96;
					i_430913 = res_431544;
					a = (*n).kindU.S6.sons->data[i_430913];
					checkminsonslen_246259(a, ((NI) 1));
					L = sonslen_194403(a);
					{
						NI j_430929;
						NI HEX3Atmp_431534;
						NI res_431537;
						j_430929 = 0;
						HEX3Atmp_431534 = 0;
						HEX3Atmp_431534 = (NI)(L - ((NI) 2));
						res_431537 = ((NI) 0);
						{
							while (1) {
								if (!(res_431537 <= HEX3Atmp_431534)) goto LA99;
								j_430929 = res_431537;
								asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[j_430929]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[j_430929], flags_427622, ctx));
								res_431537 += ((NI) 1);
							} LA99: ;
						}
					}
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), semgenericstmtscope_427625(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))], flags_427622, ctx));
					res_431544 += ((NI) 1);
				} LA96: ;
			}
		}
		closescope_250111(c);
	}
	break;
	case ((NU8) 94):
	case ((NU8) 95):
	{
		NI L;
		Tscope191837* LOC101;
		L = sonslen_194403(n);
		LOC101 = 0;
		LOC101 = openscope_250091(c);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[(NI)(L - ((NI) 2))]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[(NI)(L - ((NI) 2))], flags_427622, ctx));
		{
			NI i_430949;
			NI HEX3Atmp_431549;
			NI res_431552;
			i_430949 = 0;
			HEX3Atmp_431549 = 0;
			HEX3Atmp_431549 = (NI)(L - ((NI) 3));
			res_431552 = ((NI) 0);
			{
				while (1) {
					if (!(res_431552 <= HEX3Atmp_431549)) goto LA104;
					i_430949 = res_431552;
					addtempdecl_429491(c, (*n).kindU.S6.sons->data[i_430949], ((NU8) 21));
					res_431552 += ((NI) 1);
				} LA104: ;
			}
		}
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[(NI)(L - ((NI) 1))], flags_427622, ctx));
		closescope_250111(c);
	}
	break;
	case ((NU8) 112):
	case ((NU8) 127):
	case ((NU8) 129):
	{
		Tscope191837* LOC106;
		checksonslen_246249(n, ((NI) 2));
		LOC106 = 0;
		LOC106 = openscope_250091(c);
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA109;
			addtempdecl_429491(c, (*n).kindU.S6.sons->data[((NI) 0)], ((NU8) 22));
		}
		LA109: ;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[((NI) 1)], flags_427622, ctx));
		closescope_250111(c);
	}
	break;
	case ((NU8) 106):
	{
		checkminsonslen_246259(n, ((NI) 2));
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semgenericstmtscope_427625(c, (*n).kindU.S6.sons->data[((NI) 0)], flags_427622, ctx));
		{
			NI i_430980;
			NI HEX3Atmp_431565;
			NI LOC113;
			NI res_431568;
			i_430980 = 0;
			HEX3Atmp_431565 = 0;
			LOC113 = 0;
			LOC113 = sonslen_194403(n);
			HEX3Atmp_431565 = (NI)(LOC113 - ((NI) 1));
			res_431568 = ((NI) 1);
			{
				while (1) {
					Tnode191813* a;
					NI L;
					if (!(res_431568 <= HEX3Atmp_431565)) goto LA115;
					i_430980 = res_431568;
					a = (*n).kindU.S6.sons->data[i_430980];
					checkminsonslen_246259(a, ((NI) 1));
					L = sonslen_194403(a);
					{
						NI j_430996;
						NI HEX3Atmp_431558;
						NI res_431561;
						j_430996 = 0;
						HEX3Atmp_431558 = 0;
						HEX3Atmp_431558 = (NI)(L - ((NI) 2));
						res_431561 = ((NI) 0);
						{
							while (1) {
								if (!(res_431561 <= HEX3Atmp_431558)) goto LA118;
								j_430996 = res_431561;
								asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[j_430996]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[j_430996], (flags_427622 | 2), ctx));
								res_431561 += ((NI) 1);
							} LA118: ;
						}
					}
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), semgenericstmtscope_427625(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))], flags_427622, ctx));
					res_431568 += ((NI) 1);
				} LA115: ;
			}
		}
	}
	break;
	case ((NU8) 99):
	case ((NU8) 100):
	{
		{
			NI i_431026;
			NI HEX3Atmp_431582;
			NI LOC121;
			NI res_431585;
			i_431026 = 0;
			HEX3Atmp_431582 = 0;
			LOC121 = 0;
			LOC121 = sonslen_194403(n);
			HEX3Atmp_431582 = (NI)(LOC121 - ((NI) 1));
			res_431585 = ((NI) 0);
			{
				while (1) {
					if (!(res_431585 <= HEX3Atmp_431582)) goto LA123;
					i_431026 = res_431585;
					{
						Tnode191813* a;
						NI L;
						a = (*n).kindU.S6.sons->data[i_431026];
						{
							if (!((*a).kind == ((NU8) 125))) goto LA127;
							goto LA124;
						}
						LA127: ;
						{
							NIM_BOOL LOC131;
							LOC131 = 0;
							LOC131 = !(((*a).kind == ((NU8) 35)));
							if (!(LOC131)) goto LA132;
							LOC131 = !(((*a).kind == ((NU8) 36)));
							LA132: ;
							if (!LOC131) goto LA133;
							illformedast_246229(a);
						}
						LA133: ;
						checkminsonslen_246259(a, ((NI) 3));
						L = sonslen_194403(a);
						asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 2))]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 2))], (flags_427622 | 2), ctx));
						asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))], flags_427622, ctx));
						{
							NI j_431086;
							NI HEX3Atmp_431575;
							NI res_431578;
							j_431086 = 0;
							HEX3Atmp_431575 = 0;
							HEX3Atmp_431575 = (NI)(L - ((NI) 3));
							res_431578 = ((NI) 0);
							{
								while (1) {
									Tnode191813* LOC138;
									if (!(res_431578 <= HEX3Atmp_431575)) goto LA137;
									j_431086 = res_431578;
									LOC138 = 0;
									LOC138 = getidentnode_427598((*a).kindU.S6.sons->data[j_431086]);
									addtempdecl_429491(c, LOC138, ((NU8) 8));
									res_431578 += ((NI) 1);
								} LA137: ;
							}
						}
					} LA124: ;
					res_431585 += ((NI) 1);
				} LA123: ;
			}
		}
	}
	break;
	case ((NU8) 75):
	{
		{
			NI i_431100;
			NI HEX3Atmp_431598;
			NI LOC141;
			NI res_431601;
			i_431100 = 0;
			HEX3Atmp_431598 = 0;
			LOC141 = 0;
			LOC141 = sonslen_194403(n);
			HEX3Atmp_431598 = (NI)(LOC141 - ((NI) 1));
			res_431601 = ((NI) 0);
			{
				while (1) {
					Tnode191813* a;
					NI L;
					if (!(res_431601 <= HEX3Atmp_431598)) goto LA143;
					i_431100 = res_431601;
					a = (*n).kindU.S6.sons->data[i_431100];
					{
						if (!!(((*a).kind == ((NU8) 35)))) goto LA146;
						illformedast_246229(a);
					}
					LA146: ;
					checkminsonslen_246259(a, ((NI) 3));
					L = sonslen_194403(a);
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 2))]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 2))], (flags_427622 | 2), ctx));
					{
						NI j_431140;
						NI HEX3Atmp_431591;
						NI res_431594;
						j_431140 = 0;
						HEX3Atmp_431591 = 0;
						HEX3Atmp_431591 = (NI)(L - ((NI) 3));
						res_431594 = ((NI) 0);
						{
							while (1) {
								Tnode191813* LOC151;
								if (!(res_431594 <= HEX3Atmp_431591)) goto LA150;
								j_431140 = res_431594;
								LOC151 = 0;
								LOC151 = getidentnode_427598((*a).kindU.S6.sons->data[j_431140]);
								addtempdecl_429491(c, LOC151, ((NU8) 7));
								res_431594 += ((NI) 1);
							} LA150: ;
						}
					}
					res_431601 += ((NI) 1);
				} LA143: ;
			}
		}
	}
	break;
	case ((NU8) 101):
	{
		{
			NI i_431154;
			NI HEX3Atmp_431607;
			NI LOC154;
			NI res_431610;
			i_431154 = 0;
			HEX3Atmp_431607 = 0;
			LOC154 = 0;
			LOC154 = sonslen_194403(n);
			HEX3Atmp_431607 = (NI)(LOC154 - ((NI) 1));
			res_431610 = ((NI) 0);
			{
				while (1) {
					if (!(res_431610 <= HEX3Atmp_431607)) goto LA156;
					i_431154 = res_431610;
					{
						Tnode191813* a;
						Tnode191813* LOC166;
						a = (*n).kindU.S6.sons->data[i_431154];
						{
							if (!((*a).kind == ((NU8) 125))) goto LA160;
							goto LA157;
						}
						LA160: ;
						{
							if (!!(((*a).kind == ((NU8) 102)))) goto LA164;
							illformedast_246229(a);
						}
						LA164: ;
						checksonslen_246249(a, ((NI) 3));
						LOC166 = 0;
						LOC166 = getidentnode_427598((*a).kindU.S6.sons->data[((NI) 0)]);
						addtempdecl_429491(c, LOC166, ((NU8) 10));
						asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 1)]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[((NI) 1)], (flags_427622 | 2), ctx));
						asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 2)]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[((NI) 2)], flags_427622, ctx));
					} LA157: ;
					res_431610 += ((NI) 1);
				} LA156: ;
			}
		}
	}
	break;
	case ((NU8) 98):
	{
		{
			NI i_431205;
			NI HEX3Atmp_431616;
			NI LOC169;
			NI res_431619;
			i_431205 = 0;
			HEX3Atmp_431616 = 0;
			LOC169 = 0;
			LOC169 = sonslen_194403(n);
			HEX3Atmp_431616 = (NI)(LOC169 - ((NI) 1));
			res_431619 = ((NI) 0);
			{
				while (1) {
					if (!(res_431619 <= HEX3Atmp_431616)) goto LA171;
					i_431205 = res_431619;
					{
						Tnode191813* a;
						Tnode191813* LOC181;
						a = (*n).kindU.S6.sons->data[i_431205];
						{
							if (!((*a).kind == ((NU8) 125))) goto LA175;
							goto LA172;
						}
						LA175: ;
						{
							if (!!(((*a).kind == ((NU8) 103)))) goto LA179;
							illformedast_246229(a);
						}
						LA179: ;
						checksonslen_246249(a, ((NI) 3));
						LOC181 = 0;
						LOC181 = getidentnode_427598((*a).kindU.S6.sons->data[((NI) 0)]);
						addtempdecl_429491(c, LOC181, ((NU8) 7));
					} LA172: ;
					res_431619 += ((NI) 1);
				} LA171: ;
			}
		}
		{
			NI i_431239;
			NI HEX3Atmp_431625;
			NI LOC183;
			NI res_431628;
			i_431239 = 0;
			HEX3Atmp_431625 = 0;
			LOC183 = 0;
			LOC183 = sonslen_194403(n);
			HEX3Atmp_431625 = (NI)(LOC183 - ((NI) 1));
			res_431628 = ((NI) 0);
			{
				while (1) {
					if (!(res_431628 <= HEX3Atmp_431625)) goto LA185;
					i_431239 = res_431628;
					{
						Tnode191813* a;
						a = (*n).kindU.S6.sons->data[i_431239];
						{
							if (!((*a).kind == ((NU8) 125))) goto LA189;
							goto LA186;
						}
						LA189: ;
						{
							if (!!(((*a).kind == ((NU8) 103)))) goto LA193;
							illformedast_246229(a);
						}
						LA193: ;
						checksonslen_246249(a, ((NI) 3));
						{
							Tscope191837* LOC199;
							if (!!(((*(*a).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1)))) goto LA197;
							LOC199 = 0;
							LOC199 = openscope_250091(c);
							asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 1)]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[((NI) 1)], flags_427622, ctx));
							asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 2)]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[((NI) 2)], (flags_427622 | 2), ctx));
							closescope_250111(c);
						}
						goto LA195;
						LA197: ;
						{
							asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 2)]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[((NI) 2)], (flags_427622 | 2), ctx));
						}
						LA195: ;
					} LA186: ;
					res_431628 += ((NI) 1);
				} LA185: ;
			}
		}
	}
	break;
	case ((NU8) 150):
	{
		{
			NI LOC204;
			LOC204 = 0;
			LOC204 = sonslen_194403(n);
			if (!(((NI) 0) < LOC204)) goto LA205;
			{
				if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA209;
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[((NI) 0)], (flags_427622 | 2), ctx));
			}
			LA209: ;
			{
				NI i_431340;
				NI HEX3Atmp_431634;
				NI LOC212;
				NI res_431637;
				i_431340 = 0;
				HEX3Atmp_431634 = 0;
				LOC212 = 0;
				LOC212 = sonslen_194403(n);
				HEX3Atmp_431634 = (NI)(LOC212 - ((NI) 1));
				res_431637 = ((NI) 1);
				{
					while (1) {
						Tnode191813* a;
						Tnode191813* LOC218;
						Tsym191843* LOC219;
						if (!(res_431637 <= HEX3Atmp_431634)) goto LA214;
						i_431340 = res_431637;
						a = 0;
						switch ((*(*n).kindU.S6.sons->data[i_431340]).kind) {
						case ((NU8) 151):
						{
							a = (*(*n).kindU.S6.sons->data[i_431340]).kindU.S6.sons->data[((NI) 0)];
						}
						break;
						case ((NU8) 2):
						{
							a = (*n).kindU.S6.sons->data[i_431340];
						}
						break;
						default:
						{
							illformedast_246229(n);
						}
						break;
						}
						LOC218 = 0;
						LOC218 = getidentnode_427598((*a).kindU.S6.sons->data[i_431340]);
						LOC219 = 0;
						LOC219 = newsyms_410904(((NU8) 0), LOC218, c);
						adddecl_250607(c, LOC219);
						res_431637 += ((NI) 1);
					} LA214: ;
				}
			}
		}
		LA205: ;
	}
	break;
	case ((NU8) 133):
	case ((NU8) 134):
	case ((NU8) 135):
	{
	}
	break;
	case ((NU8) 76):
	{
		checkminsonslen_246259(n, ((NI) 1));
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA224;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[((NI) 0)], (flags_427622 | 2), ctx));
		}
		LA224: ;
		{
			NI i_431384;
			NI HEX3Atmp_431650;
			NI LOC227;
			NI res_431653;
			i_431384 = 0;
			HEX3Atmp_431650 = 0;
			LOC227 = 0;
			LOC227 = sonslen_194403(n);
			HEX3Atmp_431650 = (NI)(LOC227 - ((NI) 1));
			res_431653 = ((NI) 1);
			{
				while (1) {
					Tnode191813* a;
					NI L;
					if (!(res_431653 <= HEX3Atmp_431650)) goto LA229;
					i_431384 = res_431653;
					a = (*n).kindU.S6.sons->data[i_431384];
					{
						if (!!(((*a).kind == ((NU8) 35)))) goto LA232;
						illformedast_246229(a);
					}
					LA232: ;
					checkminsonslen_246259(a, ((NI) 3));
					L = sonslen_194403(a);
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 2))]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 2))], (flags_427622 | 2), ctx));
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), semgenericstmt_427618(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))], flags_427622, ctx));
					{
						NI j_431426;
						NI HEX3Atmp_431643;
						NI res_431646;
						j_431426 = 0;
						HEX3Atmp_431643 = 0;
						HEX3Atmp_431643 = (NI)(L - ((NI) 3));
						res_431646 = ((NI) 0);
						{
							while (1) {
								Tnode191813* LOC237;
								if (!(res_431646 <= HEX3Atmp_431643)) goto LA236;
								j_431426 = res_431646;
								LOC237 = 0;
								LOC237 = getidentnode_427598((*a).kindU.S6.sons->data[j_431426]);
								addtempdecl_429491(c, LOC237, ((NU8) 3));
								res_431646 += ((NI) 1);
							} LA236: ;
						}
					}
					res_431653 += ((NI) 1);
				} LA229: ;
			}
		}
	}
	break;
	case ((NU8) 79):
	case ((NU8) 80):
	case ((NU8) 81):
	case ((NU8) 82):
	case ((NU8) 83):
	case ((NU8) 84):
	case ((NU8) 51):
	case ((NU8) 52):
	{
		Tscope191837* LOC244;
		Tnode191813* body;
		checksonslen_246249(n, ((NI) 7));
		{
			Tnode191813* LOC243;
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA241;
			LOC243 = 0;
			LOC243 = getidentnode_427598((*n).kindU.S6.sons->data[((NI) 0)]);
			addtempdecl_429491(c, LOC243, ((NU8) 12));
		}
		LA241: ;
		LOC244 = 0;
		LOC244 = openscope_250091(c);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[((NI) 2)], flags_427622, ctx));
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 3)]).kind == ((NU8) 1)))) goto LA247;
			{
				Tident168021* LOC253;
				Tsym191843* LOC254;
				if (!!(((*(*(*n).kindU.S6.sons->data[((NI) 3)]).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA251;
				LOC253 = 0;
				LOC253 = getident_168463(((NimStringDesc*) &TMP3013));
				LOC254 = 0;
				LOC254 = newsym_192655(((NU8) 0), LOC253, NIM_NIL, (*n).info);
				addprelimdecl_250619(c, LOC254);
			}
			LA251: ;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 3)]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[((NI) 3)], flags_427622, ctx));
		}
		LA247: ;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 4)]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[((NI) 4)], flags_427622, ctx));
		body = 0;
		{
			if (!((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3))) goto LA257;
			body = getbody_236647((*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym);
		}
		goto LA255;
		LA257: ;
		{
			body = (*n).kindU.S6.sons->data[((NI) 6)];
		}
		LA255: ;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), semgenericstmtscope_427625(c, body, flags_427622, ctx));
		closescope_250111(c);
	}
	break;
	case ((NU8) 90):
	case ((NU8) 43):
	{
	}
	break;
	case ((NU8) 34):
	case ((NU8) 33):
	{
		checkminsonslen_246259(n, ((NI) 2));
		asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[((NI) 1)], flags_427622, ctx));
	}
	break;
	default:
	{
		{
			NI i_431496;
			NI HEX3Atmp_431659;
			NI LOC264;
			NI res_431662;
			i_431496 = 0;
			HEX3Atmp_431659 = 0;
			LOC264 = 0;
			LOC264 = sonslen_194403(n);
			HEX3Atmp_431659 = (NI)(LOC264 - ((NI) 1));
			res_431662 = ((NI) 0);
			{
				while (1) {
					if (!(res_431662 <= HEX3Atmp_431659)) goto LA266;
					i_431496 = res_431662;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_431496]), semgenericstmt_427618(c, (*n).kindU.S6.sons->data[i_431496], flags_427622, ctx));
					res_431662 += ((NI) 1);
				} LA266: ;
			}
		}
	}
	break;
	}
	return result;
}

N_NIMCALL(Tnode191813*, semgenericstmt_416688)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Genericctx427608 ctx;
	result = 0;
	memset((void*)(&ctx), 0, sizeof(ctx));
	initintset_188927((&ctx.tomixin));
	result = semgenericstmt_427618(c, n, 0, (&ctx));
	return result;
}

static N_INLINE(Ttype191849*, skipgenericinvocation_419764)(Ttype191849* t) {
	Ttype191849* result;
	result = 0;
	result = t;
	{
		if (!((*result).kind == ((NU8) 9))) goto LA3;
		result = (*result).sons->data[((NI) 0)];
	}
	LA3: ;
	{
		while (1) {
			if (!((3072 &(IL64(1)<<(((*result).kind)&IL64(63))))!=0)) goto LA6;
			result = lastson_194442(result);
		} LA6: ;
	}
	return result;
}

N_NIMCALL(void, addinheritedfieldsaux_419668)(Tcontext245023* c, Intset188056* check, NI* pos, Tnode191813* n) {
	switch ((*n).kind) {
	case ((NU8) 139):
	{
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA4;
			internalerror_166199((*n).info, ((NimStringDesc*) &TMP3016));
		}
		LA4: ;
		addinheritedfieldsaux_419668(c, check, pos, (*n).kindU.S6.sons->data[((NI) 0)]);
		{
			NI i_419699;
			NI HEX3Atmp_419728;
			NI LOC7;
			NI res_419731;
			i_419699 = 0;
			HEX3Atmp_419728 = 0;
			LOC7 = 0;
			LOC7 = sonslen_194403(n);
			HEX3Atmp_419728 = (NI)(LOC7 - ((NI) 1));
			res_419731 = ((NI) 1);
			{
				while (1) {
					if (!(res_419731 <= HEX3Atmp_419728)) goto LA9;
					i_419699 = res_419731;
					switch ((*(*n).kindU.S6.sons->data[i_419699]).kind) {
					case ((NU8) 85):
					case ((NU8) 88):
					{
						Tnode191813* LOC11;
						LOC11 = 0;
						LOC11 = lastson_194431((*n).kindU.S6.sons->data[i_419699]);
						addinheritedfieldsaux_419668(c, check, pos, LOC11);
					}
					break;
					default:
					{
						internalerror_166199((*n).info, ((NimStringDesc*) &TMP3017));
					}
					break;
					}
					res_419731 += ((NI) 1);
				} LA9: ;
			}
		}
	}
	break;
	case ((NU8) 138):
	{
		{
			NI i_419714;
			NI HEX3Atmp_419736;
			NI LOC15;
			NI res_419739;
			i_419714 = 0;
			HEX3Atmp_419736 = 0;
			LOC15 = 0;
			LOC15 = sonslen_194403(n);
			HEX3Atmp_419736 = (NI)(LOC15 - ((NI) 1));
			res_419739 = ((NI) 0);
			{
				while (1) {
					if (!(res_419739 <= HEX3Atmp_419736)) goto LA17;
					i_419714 = res_419739;
					addinheritedfieldsaux_419668(c, check, pos, (*n).kindU.S6.sons->data[i_419714]);
					res_419739 += ((NI) 1);
				} LA17: ;
			}
		}
	}
	break;
	case ((NU8) 3):
	{
		incl_188856(check, (*(*(*n).kindU.S4.sym).name).Sup.id);
		(*pos) += ((NI) 1);
	}
	break;
	default:
	{
		internalerror_166199((*n).info, ((NimStringDesc*) &TMP3018));
	}
	break;
	}
}

N_NIMCALL(void, addinheritedfields_419798)(Tcontext245023* c, Intset188056* check, NI* pos, Ttype191849* obj) {
	{
		NIM_BOOL LOC3;
		NI LOC4;
		Ttype191849* LOC8;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = sonslen_194351(obj);
		LOC3 = (((NI) 0) < LOC4);
		if (!(LOC3)) goto LA5;
		LOC3 = !(((*obj).sons->data[((NI) 0)] == NIM_NIL));
		LA5: ;
		if (!LOC3) goto LA6;
		LOC8 = 0;
		LOC8 = skipgenericinvocation_419764((*obj).sons->data[((NI) 0)]);
		addinheritedfields_419798(c, check, pos, LOC8);
	}
	LA6: ;
	addinheritedfieldsaux_419668(c, check, pos, (*obj).n);
}

N_NIMCALL(void, instantiategenericparamlist_412213)(Tcontext245023* c, Tnode191813* n, Tidtable191861 pt, Tinstantiation191833* entry) {
	NI LOC5;
	{
		if (!!(((*n).kind == ((NU8) 75)))) goto LA3;
		internalerror_166199((*n).info, ((NimStringDesc*) &TMP3023));
	}
	LA3: ;
	LOC5 = 0;
	LOC5 = len_192097(n);
	unsureAsgnRef((void**) (&(*entry).concretetypes), (Ttypeseq191845*) newSeq((&NTI191845), ((NI) (LOC5))));
	{
		NI i_412241;
		Tnode191813* a_412242;
		i_412241 = 0;
		a_412242 = 0;
		{
			NI i_412369;
			NI HEX3Atmp_412371;
			NI LOC8;
			NI res_412373;
			i_412369 = 0;
			HEX3Atmp_412371 = 0;
			LOC8 = 0;
			LOC8 = len_192097(n);
			HEX3Atmp_412371 = (LOC8 - 1);
			res_412373 = ((NI) 0);
			{
				while (1) {
					if (!(res_412373 <= HEX3Atmp_412371)) goto LA10;
					i_412369 = res_412373;
					i_412241 = i_412369;
					a_412242 = (*n).kindU.S6.sons->data[i_412369];
					{
						Tsym191843* q;
						NU8 symkind;
						Tsym191843* s;
						Tsym191843* LOC25;
						Ttype191849* t;
						Tidobj168015* LOC26;
						TNimObject* LOC27;
						{
							if (!!(((*a_412242).kind == ((NU8) 3)))) goto LA14;
							internalerror_166199((*a_412242).info, ((NimStringDesc*) &TMP3024));
						}
						LA14: ;
						q = (*a_412242).kindU.S4.sym;
						{
							if (!!(((IL64(1151232654746587392) &(IL64(1)<<(((*(*q).typ).kind)&IL64(63))))!=0))) goto LA18;
							goto LA11;
						}
						LA18: ;
						{
							if (!((*(*q).typ).kind == ((NU8) 59))) goto LA22;
							symkind = ((NU8) 10);
						}
						goto LA20;
						LA22: ;
						{
							symkind = ((NU8) 7);
						}
						LA20: ;
						LOC25 = 0;
						LOC25 = getcurrowner_245255();
						s = newsym_192655(symkind, (*q).name, LOC25, (*q).info);
						(*s).flags = ((*s).flags | 5);
						LOC26 = 0;
						LOC26 = &(*q).typ->Sup;
						LOC27 = 0;
						LOC27 = idtableget_199182(pt, LOC26);
						t = ((Ttype191849*) (LOC27));
						{
							if (!(t == NIM_NIL)) goto LA30;
							{
								if (!(((*(*q).typ).flags &(1<<((((NU8) 10))&31)))!=0)) goto LA34;
								t = (*q).typ;
							}
							goto LA32;
							LA34: ;
							{
								localerror_166155((*a_412242).info, ((NU16) 124), (*(*s).name).s);
								t = errortype_246150(c);
							}
							LA32: ;
						}
						goto LA28;
						LA30: ;
						{
							if (!((*t).kind == ((NU8) 12))) goto LA38;
							localerror_166155((*a_412242).info, ((NU16) 124), (*(*q).name).s);
							t = errortype_246150(c);
						}
						goto LA28;
						LA38: ;
						{
							if (!((*t).kind == ((NU8) 9))) goto LA41;
							t = generatetypeinstance_268631(c, pt, (*a_412242).info, t);
						}
						goto LA28;
						LA41: ;
						LA28: ;
						asgnRefNoCycle((void**) (&(*s).typ), t);
						{
							if (!((*t).kind == ((NU8) 59))) goto LA45;
							asgnRefNoCycle((void**) (&(*s).ast), (*t).n);
						}
						LA45: ;
						adddecl_250607(c, s);
						asgnRefNoCycle((void**) (&(*entry).concretetypes->data[i_412241]), t);
					} LA11: ;
					res_412373 += ((NI) 1);
				} LA10: ;
			}
		}
	}
}

static N_INLINE(NIM_BOOL, canbecycleroot_49867)(Tcell46346* c) {
	NIM_BOOL result;
	result = 0;
	result = !((((*(*c).typ).flags &(1<<((((NU8) 1))&7)))!=0));
	return result;
}

static N_INLINE(void, rtladdcycleroot_50623)(Tcell46346* c) {
	{
		if (!!((((NI) ((NI)((*c).refcount & ((NI) 3)))) == ((NI) 3)))) goto LA3;
		(*c).refcount = (NI)((NI)((*c).refcount & ((NI) -4)) | ((NI) 3));
		incl_47065((&gch_48244.cycleroots), c);
	}
	LA3: ;
}

static N_INLINE(void, incref_52222)(Tcell46346* c) {
	(*c).refcount = (NI)((NU64)((*c).refcount) + (NU64)(((NI) 8)));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = canbecycleroot_49867(c);
		if (!LOC3) goto LA4;
		rtladdcycleroot_50623(c);
	}
	LA4: ;
}

static N_INLINE(void, decref_51804)(Tcell46346* c) {
	{
		(*c).refcount -= ((NI) 8);
		if (!((NU64)((*c).refcount) < (NU64)(((NI) 8)))) goto LA3;
		rtladdzct_51404(c);
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC6;
		LOC6 = 0;
		LOC6 = canbecycleroot_49867(c);
		if (!LOC6) goto LA7;
		rtladdcycleroot_50623(c);
	}
	goto LA1;
	LA7: ;
	LA1: ;
}

static N_INLINE(void, asgnRef)(void** dest, void* src) {
	{
		Tcell46346* LOC5;
		if (!!((src == NIM_NIL))) goto LA3;
		LOC5 = 0;
		LOC5 = usrtocell_49846(src);
		incref_52222(LOC5);
	}
	LA3: ;
	{
		Tcell46346* LOC10;
		if (!!(((*dest) == NIM_NIL))) goto LA8;
		LOC10 = 0;
		LOC10 = usrtocell_49846((*dest));
		decref_51804(LOC10);
	}
	LA8: ;
	(*dest) = src;
}

static N_INLINE(void, pushproccon_245358)(Tcontext245023* c, Tsym191843* owner) {
	Tproccon245011* x;
{	{
		if (!(owner == NIM_NIL)) goto LA3;
		internalerror_166218(((NimStringDesc*) &TMP3025));
		goto BeforeRet;
	}
	LA3: ;
	x = 0;
	x = (Tproccon245011*) newObj((&NTI245009), sizeof(Tproccon245011));
	asgnRefNoCycle((void**) (&(*x).owner), owner);
	asgnRef((void**) (&(*x).next), (*c).p);
	asgnRef((void**) (&(*c).p), x);
	}BeforeRet: ;
}

N_NIMCALL(Ttype191849*, findenforcedstatictype_420139)(Ttype191849* t_420141) {
	Ttype191849* result;
{	result = 0;
	{
		if (!((*t_420141).kind == ((NU8) 59))) goto LA3;
		result = t_420141;
		goto BeforeRet;
	}
	LA3: ;
	{
		if (!((*t_420141).kind == ((NU8) 55))) goto LA7;
		{
			Ttype191849* s_420170;
			Ttypeseq191845* HEX3Atmp_420185;
			NI i_420188;
			NI L_420190;
			s_420170 = 0;
			HEX3Atmp_420185 = 0;
			HEX3Atmp_420185 = (*t_420141).sons;
			i_420188 = ((NI) 0);
			L_420190 = (HEX3Atmp_420185 ? HEX3Atmp_420185->Sup.len : 0);
			{
				while (1) {
					Ttype191849* t;
					if (!(i_420188 < L_420190)) goto LA11;
					s_420170 = HEX3Atmp_420185->data[i_420188];
					t = findenforcedstatictype_420139(s_420170);
					{
						if (!!((t == NIM_NIL))) goto LA14;
						result = t;
						goto BeforeRet;
					}
					LA14: ;
					i_420188 += ((NI) 1);
				} LA11: ;
			}
		}
	}
	LA7: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, addparamorresult_412885)(Tcontext245023* c, Tsym191843* param, NU8 kind) {
	{
		Ttype191849* statictype;
		if (!(kind == ((NU8) 17))) goto LA3;
		statictype = findenforcedstatictype_420139((*param).typ);
		{
			Tsym191843* a;
			if (!!((statictype == NIM_NIL))) goto LA7;
			a = copysym_194607(param, NIM_FALSE);
			asgnRefNoCycle((void**) (&(*a).typ), base_221039(statictype));
			adddecl_250607(c, a);
		}
		goto LA5;
		LA7: ;
		{
			if (!((*(*param).typ).kind == ((NU8) 8))) goto LA10;
			adddecl_250607(c, param);
		}
		goto LA5;
		LA10: ;
		{
			Tsym191843* nn;
			Tsym191843* a;
			{
				Tsym191843* LOC15;
				LOC15 = 0;
				LOC15 = getcompilerproc_239036(((NimStringDesc*) &TMP3028));
				if (!!((LOC15 == NIM_NIL))) goto LA16;
				nn = getsyssym_239054(((NimStringDesc*) &TMP3029));
			}
			goto LA13;
			LA16: ;
			{
				nn = getsyssym_239054(((NimStringDesc*) &TMP3030));
			}
			LA13: ;
			a = copysym_194607(param, NIM_FALSE);
			asgnRefNoCycle((void**) (&(*a).typ), (*nn).typ);
			adddecl_250607(c, a);
		}
		LA5: ;
	}
	goto LA1;
	LA3: ;
	{
		{
			if (!!((((*param).flags &(1<<((((NU8) 31))&31)))!=0))) goto LA22;
			adddecl_250607(c, param);
		}
		LA22: ;
	}
	LA1: ;
}

N_NIMCALL(void, addresult_438997)(Tcontext245023* c, Ttype191849* t, Tlineinfo164338 info, NU8 owner) {
	{
		Tsym191843* s;
		Tident168021* LOC5;
		Tsym191843* LOC6;
		if (!!((t == NIM_NIL))) goto LA3;
		LOC5 = 0;
		LOC5 = getident_168463(((NimStringDesc*) &TMP3027));
		LOC6 = 0;
		LOC6 = getcurrowner_245255();
		s = newsym_192655(((NU8) 11), LOC5, LOC6, info);
		asgnRefNoCycle((void**) (&(*s).typ), t);
		(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
		addparamorresult_412885(c, s, owner);
		asgnRefNoCycle((void**) (&(*(*c).p).resultsym), s);
	}
	LA3: ;
}

N_NIMCALL(void, addresultnode_439031)(Tcontext245023* c, Tnode191813* n) {
	{
		Tnode191813* LOC5;
		if (!!(((*(*c).p).resultsym == NIM_NIL))) goto LA3;
		LOC5 = 0;
		LOC5 = newsymnode_193325((*(*c).p).resultsym);
		addson_193819(n, LOC5);
	}
	LA3: ;
}

N_NIMCALL(void, maybeaddresult_410301)(Tcontext245023* c, Tsym191843* s, Tnode191813* n) {
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = !(((*(*s).typ).sons->data[((NI) 0)] == NIM_NIL));
		if (!(LOC3)) goto LA4;
		LOC3 = !(((*s).kind == ((NU8) 14)));
		LA4: ;
		if (!LOC3) goto LA5;
		addresult_438997(c, (*(*s).typ).sons->data[((NI) 0)], (*n).info, (*s).kind);
		addresultnode_439031(c, n);
	}
	LA5: ;
}

N_NIMCALL(void, instantiateproctype_413176)(Tcontext245023* c, Tidtable191861 pt, Tsym191843* prc, Tlineinfo164338 info) {
	Trepltypevars266544 cl;
	Ttype191849* result;
	Tnode191813* originalparams;
	Tnode191813* LOC20;
	adddecl_250607(c, prc);
	pushinfocontext_165189(info);
	memset((void*)(&cl), 0, sizeof(cl));
	chckNil((void*)(&cl));
	memset((void*)(&cl), 0, sizeof(cl));
	inittypevars_268602(c, pt, info, (&cl));
	result = instcopytype_267470((&cl), (*prc).typ);
	originalparams = (*result).n;
	asgnRefNoCycle((void**) (&(*result).n), shallowcopy_195817(originalparams));
	{
		NI i_413206;
		NI HEX3Atmp_413431;
		NI LOC2;
		NI res_413434;
		i_413206 = 0;
		HEX3Atmp_413431 = 0;
		LOC2 = 0;
		LOC2 = len_194377(result);
		HEX3Atmp_413431 = (LOC2 - 1);
		res_413434 = ((NI) 1);
		{
			while (1) {
				Tsym191843* oldparam;
				Tnode191813* LOC15;
				Tsym191843* param;
				if (!(res_413434 <= HEX3Atmp_413431)) goto LA4;
				i_413206 = res_413434;
				{
					if (!(((NI) 1) < i_413206)) goto LA7;
					resetidtable_195077((&cl.symmap));
					resetidtable_195077((&cl.localcache));
				}
				LA7: ;
				asgnRefNoCycle((void**) (&(*result).sons->data[i_413206]), replacetypevarst_266592((&cl), (*result).sons->data[i_413206]));
				propagatetoowner_195274(result, (*result).sons->data[i_413206]);
				{
					Tnode191813* LOC11;
					NimStringDesc* LOC14;
					LOC11 = 0;
					LOC11 = HEX5BHEX5D_192244(originalparams, i_413206);
					if (!!(((*LOC11).kind == ((NU8) 3)))) goto LA12;
					LOC14 = 0;
					LOC14 = HEX24_166306(TMP3026);
					internalerror_166218(LOC14);
				}
				LA12: ;
				LOC15 = 0;
				LOC15 = HEX5BHEX5D_192244(originalparams, i_413206);
				oldparam = (*LOC15).kindU.S4.sym;
				param = copysym_194607(oldparam, NIM_FALSE);
				asgnRefNoCycle((void**) (&(*param).owner), prc);
				asgnRefNoCycle((void**) (&(*param).typ), (*result).sons->data[i_413206]);
				{
					if (!!(((*oldparam).ast == NIM_NIL))) goto LA18;
					asgnRefNoCycle((void**) (&(*param).ast), fitnode_410245(c, (*param).typ, (*oldparam).ast));
				}
				LA18: ;
				asgnRefNoCycle((void**) (&(*(*result).n).kindU.S6.sons->data[i_413206]), newsymnode_193325(param));
				adddecl_250607(c, param);
				res_413434 += ((NI) 1);
			} LA4: ;
		}
	}
	resetidtable_195077((&cl.symmap));
	resetidtable_195077((&cl.localcache));
	asgnRefNoCycle((void**) (&(*result).sons->data[((NI) 0)]), replacetypevarst_266592((&cl), (*result).sons->data[((NI) 0)]));
	LOC20 = 0;
	LOC20 = HEX5BHEX5D_192244(originalparams, ((NI) 0));
	asgnRefNoCycle((void**) (&(*(*result).n).kindU.S6.sons->data[((NI) 0)]), copytree_196028(LOC20));
	erasevoidparams_267982(result);
	skipintliteralparams_268136(result);
	asgnRefNoCycle((void**) (&(*prc).typ), result);
	maybeaddresult_410301(c, prc, (*prc).ast);
	popinfocontext_165208();
}

N_NIMCALL(NIM_BOOL, sameinstantiation_412394)(Tinstantiation191833* a, Tinstantiation191833* b) {
	NIM_BOOL result;
{	result = 0;
	{
		if (!(((*a).concretetypes ? (*a).concretetypes->Sup.len : 0) == ((*b).concretetypes ? (*b).concretetypes->Sup.len : 0))) goto LA3;
		{
			NI i_412425;
			NI HEX3Atmp_412428;
			NI res_412431;
			i_412425 = 0;
			HEX3Atmp_412428 = 0;
			HEX3Atmp_412428 = ((*a).concretetypes ? ((*a).concretetypes->Sup.len-1) : -1);
			res_412431 = ((NI) 0);
			{
				while (1) {
					if (!(res_412431 <= HEX3Atmp_412428)) goto LA7;
					i_412425 = res_412431;
					{
						NIM_BOOL LOC10;
						LOC10 = 0;
						LOC10 = comparetypes_228047((*a).concretetypes->data[i_412425], (*b).concretetypes->data[i_412425], ((NU8) 0), 4);
						if (!!(LOC10)) goto LA11;
						goto BeforeRet;
					}
					LA11: ;
					res_412431 += ((NI) 1);
				} LA7: ;
			}
		}
		result = NIM_TRUE;
	}
	LA3: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tsym191843*, genericcacheget_412447)(Tsym191843* genericsym, Tinstantiation191833* entry) {
	Tsym191843* result;
{	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = HEX3DHEX3D_194870((*genericsym).kindU.S2.procinstcache, NIM_NIL);
		if (!!(LOC3)) goto LA4;
		{
			Tinstantiation191833* inst_412611;
			TY191944* HEX3Atmp_412613;
			NI i_412616;
			NI L_412618;
			inst_412611 = 0;
			HEX3Atmp_412613 = 0;
			HEX3Atmp_412613 = (*genericsym).kindU.S2.procinstcache;
			i_412616 = ((NI) 0);
			L_412618 = (HEX3Atmp_412613 ? HEX3Atmp_412613->Sup.len : 0);
			{
				while (1) {
					if (!(i_412616 < L_412618)) goto LA8;
					inst_412611 = HEX3Atmp_412613->data[i_412616];
					{
						NIM_BOOL LOC11;
						LOC11 = 0;
						LOC11 = sameinstantiation_412394(entry, (&(*inst_412611)));
						if (!LOC11) goto LA12;
						result = (*inst_412611).sym;
						goto BeforeRet;
					}
					LA12: ;
					i_412616 += ((NI) 1);
				} LA8: ;
			}
		}
	}
	LA4: ;
	}BeforeRet: ;
	return result;
}

static N_INLINE(NI, safelen_192125)(Tnode191813* n) {
	NI result;
	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = ((*n).kind >= ((NU8) 0) && (*n).kind <= ((NU8) 23));
		if (LOC3) goto LA4;
		LOC3 = (*n).kindU.S6.sons == 0;
		LA4: ;
		if (!LOC3) goto LA5;
		result = ((NI) 0);
	}
	goto LA1;
	LA5: ;
	{
		result = ((*n).kindU.S6.sons ? (*n).kindU.S6.sons->Sup.len : 0);
	}
	LA1: ;
	return result;
}

N_NIMCALL(void, freshgensyms_412801)(Tnode191813* n, Tsym191843* owner, Tidtable191861* symmap) {
	{
		NIM_BOOL LOC3;
		Tsym191843* s;
		Tsym191843* x;
		Tidobj168015* LOC7;
		TNimObject* LOC8;
		LOC3 = 0;
		LOC3 = ((*n).kind == ((NU8) 3));
		if (!(LOC3)) goto LA4;
		LOC3 = (((*(*n).kindU.S4.sym).flags &(1<<((((NU8) 31))&31)))!=0);
		LA4: ;
		if (!LOC3) goto LA5;
		s = (*n).kindU.S4.sym;
		LOC7 = 0;
		LOC7 = &s->Sup;
		LOC8 = 0;
		LOC8 = idtableget_199182((*symmap), LOC7);
		x = ((Tsym191843*) (LOC8));
		{
			Tidobj168015* LOC13;
			TNimObject* LOC14;
			if (!(x == NIM_NIL)) goto LA11;
			x = copysym_194607(s, NIM_FALSE);
			asgnRefNoCycle((void**) (&(*x).owner), owner);
			LOC13 = 0;
			LOC13 = &s->Sup;
			LOC14 = 0;
			LOC14 = &x->Sup.Sup;
			idtableput_199196(symmap, LOC13, LOC14);
		}
		LA11: ;
		asgnRefNoCycle((void**) (&(*n).kindU.S4.sym), x);
	}
	goto LA1;
	LA5: ;
	{
		{
			NI i_412863;
			NI HEX3Atmp_412866;
			NI LOC17;
			NI res_412869;
			i_412863 = 0;
			HEX3Atmp_412866 = 0;
			LOC17 = 0;
			LOC17 = safelen_192125(n);
			HEX3Atmp_412866 = (LOC17 - 1);
			res_412869 = ((NI) 0);
			{
				while (1) {
					if (!(res_412869 <= HEX3Atmp_412866)) goto LA19;
					i_412863 = res_412869;
					freshgensyms_412801((*n).kindU.S6.sons->data[i_412863], owner, symmap);
					res_412869 += ((NI) 1);
				} LA19: ;
			}
		}
	}
	LA1: ;
}

static N_INLINE(NIM_BOOL, isemptytype_196934)(Ttype191849* t) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = (t == NIM_NIL);
	if (LOC1) goto LA2;
	LOC1 = ((136 &(IL64(1)<<(((*t).kind)&IL64(63))))!=0);
	LA2: ;
	result = LOC1;
	return result;
}

N_NIMCALL(NIM_BOOL, istypeexpr_446444)(Tnode191813* n) {
	NIM_BOOL result;
	result = 0;
	switch ((*n).kind) {
	case ((NU8) 4):
	case ((NU8) 132):
	{
		result = NIM_TRUE;
	}
	break;
	case ((NU8) 3):
	{
		result = ((*(*n).kindU.S4.sym).kind == ((NU8) 7));
	}
	break;
	default:
	{
		result = NIM_FALSE;
	}
	break;
	}
	return result;
}

N_NIMCALL(Tnode191813*, readtypeparameter_446877)(Tcontext245023* c, Ttype191849* typ, Tident168021* paramname, Tlineinfo164338 info) {
	Tnode191813* result;
	Ttype191849* ty;
	Ttype191849* tbody;
{	result = 0;
	{
		if (!((*typ).kind == ((NU8) 11))) goto LA3;
		ty = skipgenericalias_227119(typ);
	}
	goto LA1;
	LA3: ;
	{
		{
			NimStringDesc* LOC10;
			if (!!(((*typ).kind == ((NU8) 54)))) goto LA8;
			LOC10 = 0;
			LOC10 = HEX24_166306(TMP3102);
			internalerror_166218(LOC10);
		}
		LA8: ;
		ty = skipgenericalias_227119((*typ).sons->data[((NI) 1)]);
	}
	LA1: ;
	tbody = (*ty).sons->data[((NI) 0)];
	{
		NI s_446923;
		NI HEX3Atmp_446939;
		NI LOC12;
		NI res_446942;
		s_446923 = 0;
		HEX3Atmp_446939 = 0;
		LOC12 = 0;
		LOC12 = len_194377(tbody);
		HEX3Atmp_446939 = (NI)(LOC12 - ((NI) 2));
		res_446942 = ((NI) 0);
		{
			while (1) {
				Ttype191849* tparam;
				if (!(res_446942 <= HEX3Atmp_446939)) goto LA14;
				s_446923 = res_446942;
				tparam = (*tbody).sons->data[s_446923];
				{
					Ttype191849* rawtyp;
					if (!((*(*(*tparam).sym).name).Sup.id == (*paramname).Sup.id)) goto LA17;
					rawtyp = (*ty).sons->data[(NI)(s_446923 + ((NI) 1))];
					{
						if (!((*rawtyp).kind == ((NU8) 59))) goto LA21;
						result = (*rawtyp).n;
						goto BeforeRet;
					}
					goto LA19;
					LA21: ;
					{
						Ttype191849* foundtyp;
						Tsym191843* LOC24;
						Tsym191843* LOC25;
						foundtyp = maketypedesc_245681(c, rawtyp);
						LOC24 = 0;
						LOC24 = copysym_194607((*tparam).sym, NIM_FALSE);
						LOC25 = 0;
						LOC25 = linkto_192884(LOC24, foundtyp);
						result = newsymnode_193338(LOC25, info);
						goto BeforeRet;
					}
					LA19: ;
				}
				LA17: ;
				res_446942 += ((NI) 1);
			} LA14: ;
		}
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, createsettype_446461)(Tcontext245023* c, Ttype191849* basetype) {
	Ttype191849* result;
	result = 0;
	result = newtypes_245218(((NU8) 19), c);
	rawaddson_195478(result, basetype);
	return result;
}

N_NIMCALL(Tsym191843*, lookupinrecordandbuildcheck_446604)(Tcontext245023* c, Tnode191813* n, Tnode191813* r, Tident168021* field, Tnode191813** check) {
	Tsym191843* result;
{	result = 0;
	result = NIM_NIL;
	switch ((*r).kind) {
	case ((NU8) 138):
	{
		{
			NI i_446625;
			NI HEX3Atmp_446763;
			NI LOC3;
			NI res_446766;
			i_446625 = 0;
			HEX3Atmp_446763 = 0;
			LOC3 = 0;
			LOC3 = sonslen_194403(r);
			HEX3Atmp_446763 = (NI)(LOC3 - ((NI) 1));
			res_446766 = ((NI) 0);
			{
				while (1) {
					if (!(res_446766 <= HEX3Atmp_446763)) goto LA5;
					i_446625 = res_446766;
					result = lookupinrecordandbuildcheck_446604(c, n, (*r).kindU.S6.sons->data[i_446625], field, check);
					{
						if (!!((result == NIM_NIL))) goto LA8;
						goto BeforeRet;
					}
					LA8: ;
					res_446766 += ((NI) 1);
				} LA5: ;
			}
		}
	}
	break;
	case ((NU8) 139):
	{
		Ttype191849* settype;
		Tnode191813* s;
		checkminsonslen_246259(r, ((NI) 2));
		{
			if (!!(((*(*r).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA13;
			illformedast_246229(r);
		}
		LA13: ;
		result = lookupinrecordandbuildcheck_446604(c, n, (*r).kindU.S6.sons->data[((NI) 0)], field, check);
		{
			if (!!((result == NIM_NIL))) goto LA17;
			goto BeforeRet;
		}
		LA17: ;
		settype = createsettype_446461(c, (*(*r).kindU.S6.sons->data[((NI) 0)]).typ);
		s = newnodeit_193807(((NU8) 39), (*r).info, settype);
		{
			NI i_446677;
			NI HEX3Atmp_446787;
			NI LOC20;
			NI res_446790;
			i_446677 = 0;
			HEX3Atmp_446787 = 0;
			LOC20 = 0;
			LOC20 = sonslen_194403(r);
			HEX3Atmp_446787 = (NI)(LOC20 - ((NI) 1));
			res_446790 = ((NI) 1);
			{
				while (1) {
					Tnode191813* it;
					if (!(res_446790 <= HEX3Atmp_446787)) goto LA22;
					i_446677 = res_446790;
					it = (*r).kindU.S6.sons->data[i_446677];
					switch ((*it).kind) {
					case ((NU8) 85):
					{
						Tnode191813* LOC24;
						LOC24 = 0;
						LOC24 = lastson_194431(it);
						result = lookupinrecordandbuildcheck_446604(c, n, LOC24, field, check);
						{
							if (!(result == NIM_NIL)) goto LA27;
							{
								NI j_446702;
								NI HEX3Atmp_446772;
								NI LOC30;
								NI res_446775;
								j_446702 = 0;
								HEX3Atmp_446772 = 0;
								LOC30 = 0;
								LOC30 = sonslen_194403(it);
								HEX3Atmp_446772 = (NI)(LOC30 - ((NI) 2));
								res_446775 = ((NI) 0);
								{
									while (1) {
										Tnode191813* LOC33;
										if (!(res_446775 <= HEX3Atmp_446772)) goto LA32;
										j_446702 = res_446775;
										LOC33 = 0;
										LOC33 = copytree_196028((*it).kindU.S6.sons->data[j_446702]);
										addson_193819(s, LOC33);
										res_446775 += ((NI) 1);
									} LA32: ;
								}
							}
						}
						goto LA25;
						LA27: ;
						{
							Tnode191813* inexpr;
							Ttype191849* LOC44;
							Tnode191813* LOC45;
							Tnode191813* LOC46;
							{
								if (!((*check) == NIM_NIL)) goto LA37;
								unsureAsgnRef((void**) (&(*check)), newnodei_193351(((NU8) 46), (*n).info));
								addson_193819((*check), emptynode_192807);
							}
							LA37: ;
							s = newnodeit_193807(((NU8) 39), (*n).info, settype);
							{
								NI j_446728;
								NI HEX3Atmp_446780;
								NI LOC40;
								NI res_446783;
								j_446728 = 0;
								HEX3Atmp_446780 = 0;
								LOC40 = 0;
								LOC40 = sonslen_194403(it);
								HEX3Atmp_446780 = (NI)(LOC40 - ((NI) 2));
								res_446783 = ((NI) 0);
								{
									while (1) {
										Tnode191813* LOC43;
										if (!(res_446783 <= HEX3Atmp_446780)) goto LA42;
										j_446728 = res_446783;
										LOC43 = 0;
										LOC43 = copytree_196028((*it).kindU.S6.sons->data[j_446728]);
										addson_193819(s, LOC43);
										res_446783 += ((NI) 1);
									} LA42: ;
								}
							}
							LOC44 = 0;
							LOC44 = getsystype_239030(((NU8) 1));
							inexpr = newnodeit_193807(((NU8) 27), (*n).info, LOC44);
							LOC45 = 0;
							LOC45 = newsymnode_193338(opcontains_197000, (*n).info);
							addson_193819(inexpr, LOC45);
							addson_193819(inexpr, s);
							LOC46 = 0;
							LOC46 = copytree_196028((*r).kindU.S6.sons->data[((NI) 0)]);
							addson_193819(inexpr, LOC46);
							addson_193819((*check), inexpr);
							goto BeforeRet;
						}
						LA25: ;
					}
					break;
					case ((NU8) 88):
					{
						Tnode191813* LOC48;
						LOC48 = 0;
						LOC48 = lastson_194431(it);
						result = lookupinrecordandbuildcheck_446604(c, n, LOC48, field, check);
						{
							Tnode191813* inexpr;
							Ttype191849* LOC57;
							Tnode191813* LOC58;
							Tnode191813* LOC59;
							Tnode191813* notexpr;
							Ttype191849* LOC60;
							Tnode191813* LOC61;
							if (!!((result == NIM_NIL))) goto LA51;
							{
								if (!((*check) == NIM_NIL)) goto LA55;
								unsureAsgnRef((void**) (&(*check)), newnodei_193351(((NU8) 46), (*n).info));
								addson_193819((*check), emptynode_192807);
							}
							LA55: ;
							LOC57 = 0;
							LOC57 = getsystype_239030(((NU8) 1));
							inexpr = newnodeit_193807(((NU8) 27), (*n).info, LOC57);
							LOC58 = 0;
							LOC58 = newsymnode_193338(opcontains_197000, (*n).info);
							addson_193819(inexpr, LOC58);
							addson_193819(inexpr, s);
							LOC59 = 0;
							LOC59 = copytree_196028((*r).kindU.S6.sons->data[((NI) 0)]);
							addson_193819(inexpr, LOC59);
							LOC60 = 0;
							LOC60 = getsystype_239030(((NU8) 1));
							notexpr = newnodeit_193807(((NU8) 27), (*n).info, LOC60);
							LOC61 = 0;
							LOC61 = newsymnode_193338(opnot_196999, (*n).info);
							addson_193819(notexpr, LOC61);
							addson_193819(notexpr, inexpr);
							addson_193819((*check), notexpr);
							goto BeforeRet;
						}
						LA51: ;
					}
					break;
					default:
					{
						illformedast_246229(it);
					}
					break;
					}
					res_446790 += ((NI) 1);
				} LA22: ;
			}
		}
	}
	break;
	case ((NU8) 3):
	{
		{
			if (!((*(*(*r).kindU.S4.sym).name).Sup.id == (*field).Sup.id)) goto LA66;
			result = (*r).kindU.S4.sym;
		}
		LA66: ;
	}
	break;
	default:
	{
		illformedast_246229(n);
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

static N_INLINE(NIM_BOOL, fieldvisible_352059)(Tcontext245023* c, Tsym191843* f) {
	NIM_BOOL result;
	NI fmoduleid;
	Tsym191843* LOC1;
	NIM_BOOL LOC2;
	result = 0;
	LOC1 = 0;
	LOC1 = getmodule_199243(f);
	fmoduleid = (*LOC1).Sup.id;
	LOC2 = 0;
	LOC2 = (((*f).flags &(1<<((((NU8) 1))&31)))!=0);
	if (LOC2) goto LA3;
	LOC2 = (fmoduleid == (*(*c).module).Sup.id);
	LA3: ;
	result = LOC2;
	{
		Tsym191843* module_352211;
		Tsymseq191815* HEX3Atmp_352214;
		NI i_352217;
		NI L_352219;
		module_352211 = 0;
		HEX3Atmp_352214 = 0;
		HEX3Atmp_352214 = (*c).friendmodules;
		i_352217 = ((NI) 0);
		L_352219 = (HEX3Atmp_352214 ? HEX3Atmp_352214->Sup.len : 0);
		{
			while (1) {
				if (!(i_352217 < L_352219)) goto LA6;
				module_352211 = HEX3Atmp_352214->data[i_352217];
				{
					if (!(fmoduleid == (*module_352211).Sup.id)) goto LA9;
					result = NIM_TRUE;
					goto LA4;
				}
				LA9: ;
				i_352217 += ((NI) 1);
			} LA6: ;
		}
	} LA4: ;
	return result;
}

N_NIMCALL(Tnode191813*, makederef_446833)(Tnode191813* n) {
	Tnode191813* result;
	Ttype191849* t;
	result = 0;
	t = skiptypes_195167((*n).typ, 2048);
	result = n;
	{
		if (!((*t).kind == ((NU8) 23))) goto LA3;
		result = newnodeit_193807(((NU8) 65), (*n).info, (*t).sons->data[((NI) 0)]);
		addson_193819(result, n);
		t = skiptypes_195167((*t).sons->data[((NI) 0)], 2048);
	}
	LA3: ;
	{
		while (1) {
			Tnode191813* a;
			Ttype191849* basetyp;
			if (!((6291456 &(IL64(1)<<(((*t).kind)&IL64(63))))!=0)) goto LA6;
			a = result;
			basetyp = lastson_194442(t);
			result = newnodeit_193807(((NU8) 65), (*n).info, basetyp);
			addson_193819(result, a);
			t = skiptypes_195167(basetyp, 2048);
		} LA6: ;
	}
	return result;
}

N_NIMCALL(Tnode191813*, builtinfieldaccess_446958)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Tsym191843* s;
	Tident168021* i;
	Ttype191849* ty;
	Tsym191843* f;
	Tnode191813* check;
{	result = 0;
	checksonslen_246249(n, ((NI) 2));
	s = qualifiedlookup_250864(c, n, 3);
	{
		if (!!((s == NIM_NIL))) goto LA3;
		{
			if (!((520256 &(1<<(((*s).kind)&31)))!=0)) goto LA7;
			result = symchoice_423316(c, n, s, ((NU8) 0));
			{
				if (!((*result).kind == ((NU8) 3))) goto LA11;
				result = semsym_442038(c, n, s, flags);
			}
			LA11: ;
		}
		goto LA5;
		LA7: ;
		{
			markused_345251((*(*n).kindU.S6.sons->data[((NI) 1)]).info, s);
			result = semsym_442038(c, n, s, flags);
		}
		LA5: ;
		goto BeforeRet;
	}
	LA3: ;
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 0)], (flags | 32)));
	i = considerquotedident_250010((*n).kindU.S6.sons->data[((NI) 1)]);
	ty = (*(*n).kindU.S6.sons->data[((NI) 0)]).typ;
	f = NIM_NIL;
	result = NIM_NIL;
	{
		NIM_BOOL LOC16;
		NIM_BOOL LOC18;
		Ttype191849* LOC20;
		LOC16 = 0;
		LOC16 = istypeexpr_446444((*n).kindU.S6.sons->data[((NI) 0)]);
		if (LOC16) goto LA17;
		LOC18 = 0;
		LOC18 = ((*ty).kind == ((NU8) 8));
		if (!(LOC18)) goto LA19;
		LOC20 = 0;
		LOC20 = base_221039(ty);
		LOC18 = !(((*LOC20).kind == ((NU8) 0)));
		LA19: ;
		LOC16 = LOC18;
		LA17: ;
		if (!LOC16) goto LA21;
		{
			if (!((*ty).kind == ((NU8) 8))) goto LA25;
			ty = base_221039(ty);
		}
		LA25: ;
		ty = skiptypes_195167(ty, 14680064);
		switch ((*ty).kind) {
		case ((NU8) 14):
		{
			{
				while (1) {
					if (!!((ty == NIM_NIL))) goto LA29;
					f = getsymfromlist_199228((*ty).n, i, ((NI) 0));
					{
						if (!!((f == NIM_NIL))) goto LA32;
						goto LA28;
					}
					LA32: ;
					ty = (*ty).sons->data[((NI) 0)];
				} LA29: ;
			} LA28: ;
			{
				if (!!((f == NIM_NIL))) goto LA36;
				result = newsymnode_193325(f);
				(*result).info = (*n).info;
				asgnRefNoCycle((void**) (&(*result).typ), ty);
				markused_345251((*n).info, f);
				goto BeforeRet;
			}
			LA36: ;
		}
		break;
		case ((NU8) 11):
		case ((NU8) 54):
		{
			result = readtypeparameter_446877(c, ty, i, (*n).info);
			goto BeforeRet;
		}
		break;
		case ((NU8) 17):
		case ((NU8) 18):
		{
			{
				NIM_BOOL LOC42;
				LOC42 = 0;
				LOC42 = !(((*ty).n == NIM_NIL));
				if (!(LOC42)) goto LA43;
				LOC42 = ((*(*ty).n).kind == ((NU8) 138));
				LA43: ;
				if (!LOC42) goto LA44;
				{
					Tnode191813* field_447222;
					Tnode191813* HEX3Atmp_447632;
					field_447222 = 0;
					HEX3Atmp_447632 = 0;
					HEX3Atmp_447632 = (*ty).n;
					{
						NI i_447636;
						NI HEX3Atmp_447638;
						NI LOC48;
						NI res_447640;
						i_447636 = 0;
						HEX3Atmp_447638 = 0;
						LOC48 = 0;
						LOC48 = len_192097(HEX3Atmp_447632);
						HEX3Atmp_447638 = (LOC48 - 1);
						res_447640 = ((NI) 0);
						{
							while (1) {
								if (!(res_447640 <= HEX3Atmp_447638)) goto LA50;
								i_447636 = res_447640;
								field_447222 = (*HEX3Atmp_447632).kindU.S6.sons->data[i_447636];
								{
									Ttypeseq191845* LOC55;
									TY245864 LOC56;
									if (!((*(*field_447222).kindU.S4.sym).name == i)) goto LA53;
									LOC55 = 0;
									LOC55 = (Ttypeseq191845*) newSeq((&NTI191845), 2);
									memset((void*)LOC56, 0, sizeof(LOC56));
									LOC56[0] = ty;
									LOC56[1] = (*(*field_447222).kindU.S4.sym).typ;
									asgnRefNoCycle((void**) (&LOC55->data[0]), LOC56[0]);
									asgnRefNoCycle((void**) (&LOC55->data[1]), LOC56[1]);
									asgnRefNoCycle((void**) (&(*n).typ), newtypewithsons_245807(c, ((NU8) 61), LOC55));
									asgnRefNoCycle((void**) (&(*(*n).typ).n), copytree_196028(n));
									result = n;
									goto BeforeRet;
								}
								LA53: ;
								res_447640 += ((NI) 1);
							} LA50: ;
						}
					}
				}
			}
			LA44: ;
		}
		break;
		default:
		{
			goto BeforeRet;
		}
		break;
		}
		ty = (*(*n).kindU.S6.sons->data[((NI) 0)]).typ;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA21: ;
	ty = skiptypes_195167(ty, 14682112);
	{
		while (1) {
			if (!(((*ty).flags &(1<<((((NU8) 27))&31)))!=0)) goto LA59;
			ty = skiptypes_195167(ty, 8192);
		} LA59: ;
	}
	check = NIM_NIL;
	{
		if (!((*ty).kind == ((NU8) 17))) goto LA62;
		{
			while (1) {
				check = NIM_NIL;
				f = lookupinrecordandbuildcheck_446604(c, n, (*ty).n, i, &check);
				{
					if (!!((f == NIM_NIL))) goto LA68;
					goto LA64;
				}
				LA68: ;
				{
					if (!((*ty).sons->data[((NI) 0)] == NIM_NIL)) goto LA72;
					goto LA64;
				}
				LA72: ;
				ty = skiptypes_195167((*ty).sons->data[((NI) 0)], 2048);
			}
		} LA64: ;
		{
			if (!!((f == NIM_NIL))) goto LA76;
			{
				NIM_BOOL LOC80;
				LOC80 = 0;
				LOC80 = fieldvisible_352059(c, f);
				if (!LOC80) goto LA81;
				markused_345251((*(*n).kindU.S6.sons->data[((NI) 1)]).info, f);
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), makederef_446833((*n).kindU.S6.sons->data[((NI) 0)]));
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), newsymnode_193325(f));
				asgnRefNoCycle((void**) (&(*n).typ), (*f).typ);
				{
					if (!(check == NIM_NIL)) goto LA85;
					result = n;
				}
				goto LA83;
				LA85: ;
				{
					asgnRefNoCycle((void**) (&(*check).kindU.S6.sons->data[((NI) 0)]), n);
					asgnRefNoCycle((void**) (&(*check).typ), (*n).typ);
					result = check;
				}
				LA83: ;
			}
			LA81: ;
		}
		LA76: ;
	}
	goto LA60;
	LA62: ;
	{
		NIM_BOOL LOC89;
		LOC89 = 0;
		LOC89 = ((*ty).kind == ((NU8) 18));
		if (!(LOC89)) goto LA90;
		LOC89 = !(((*ty).n == NIM_NIL));
		LA90: ;
		if (!LOC89) goto LA91;
		f = getsymfromlist_199228((*ty).n, i, ((NI) 0));
		{
			if (!!((f == NIM_NIL))) goto LA95;
			markused_345251((*(*n).kindU.S6.sons->data[((NI) 1)]).info, f);
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), makederef_446833((*n).kindU.S6.sons->data[((NI) 0)]));
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), newsymnode_193325(f));
			asgnRefNoCycle((void**) (&(*n).typ), (*f).typ);
			result = n;
		}
		LA95: ;
	}
	goto LA60;
	LA91: ;
	LA60: ;
	{
		Ttype191849* t;
		if (!(result == NIM_NIL)) goto LA99;
		t = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 0)]).typ, 14680064);
		{
			if (!((IL64(18014398509484032) &(IL64(1)<<(((*t).kind)&IL64(63))))!=0)) goto LA103;
			result = readtypeparameter_446877(c, t, i, (*n).info);
		}
		LA103: ;
	}
	LA99: ;
	}BeforeRet: ;
	return result;
}

static N_INLINE(void, appendChar)(NimStringDesc* dest, NIM_CHAR c) {
	(*dest).data[((*dest).Sup.len)- 0] = c;
	(*dest).data[((NI)((*dest).Sup.len + ((NI) 1)))- 0] = 0;
	(*dest).Sup.len += ((NI) 1);
}

N_NIMCALL(void, gatherusedsyms_414249)(Tcontext245023* c, Tnodeseq191807** usedsyms) {
	{
		Tscope191837* scope_414255;
		Tscope191837* HEX3Atmp_414334;
		Tscope191837* current_414337;
		scope_414255 = 0;
		HEX3Atmp_414334 = 0;
		HEX3Atmp_414334 = (*c).currentscope;
		current_414337 = HEX3Atmp_414334;
		{
			while (1) {
				if (!!((current_414337 == NIM_NIL))) goto LA3;
				scope_414255 = current_414337;
				{
					NIM_BOOL LOC6;
					LOC6 = 0;
					LOC6 = HEX3DHEX3D_264718((*scope_414255).usingsyms, NIM_NIL);
					if (!!(LOC6)) goto LA7;
					{
						Tnode191813* s_414277;
						Tnodeseq191807* HEX3Atmp_414328;
						NI i_414331;
						NI L_414333;
						s_414277 = 0;
						HEX3Atmp_414328 = 0;
						HEX3Atmp_414328 = (*scope_414255).usingsyms;
						i_414331 = ((NI) 0);
						L_414333 = (HEX3Atmp_414328 ? HEX3Atmp_414328->Sup.len : 0);
						{
							while (1) {
								if (!(i_414331 < L_414333)) goto LA11;
								s_414277 = HEX3Atmp_414328->data[i_414331];
								safeadd_414279(usedsyms, s_414277);
								i_414331 += ((NI) 1);
							} LA11: ;
						}
					}
				}
				LA7: ;
				current_414337 = (*current_414337).parent;
			} LA3: ;
		}
	}
}
N_NIMCALL(void, TMP3105)(void* p, NI op) {
	TY413757* a;
	NI LOC1;
	a = (TY413757*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1].Field0, op);
	}
}

N_NIMCALL(Tsym191843*, lookupmacro_439097)(Tcontext245023* c, Tnode191813* n) {
	Tsym191843* result;
	result = 0;
	{
		if (!((*n).kind == ((NU8) 3))) goto LA3;
		result = (*n).kindU.S4.sym;
		{
			if (!!(((393216 &(1<<(((*result).kind)&31)))!=0))) goto LA7;
			result = NIM_NIL;
		}
		LA7: ;
	}
	goto LA1;
	LA3: ;
	{
		Tident168021* LOC10;
		LOC10 = 0;
		LOC10 = considerquotedident_250010(n);
		result = searchinscopes_250323(c, LOC10, 393216);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, copyexcept_439050)(Tnode191813* n, NI i) {
	Tnode191813* result;
	result = 0;
	result = copynode_195640(n);
	{
		NI j_439074;
		NI HEX3Atmp_439078;
		NI LOC2;
		NI res_439081;
		j_439074 = 0;
		HEX3Atmp_439078 = 0;
		LOC2 = 0;
		LOC2 = len_192097(n);
		HEX3Atmp_439078 = (LOC2 - 1);
		res_439081 = ((NI) 0);
		{
			while (1) {
				if (!(res_439081 <= HEX3Atmp_439078)) goto LA4;
				j_439074 = res_439081;
				{
					if (!!((j_439074 == i))) goto LA7;
					add_192164(result, (*n).kindU.S6.sons->data[j_439074]);
				}
				LA7: ;
				res_439081 += ((NI) 1);
			} LA4: ;
		}
	}
	return result;
}

N_NIMCALL(Tnode191813*, semprocannotation_439127)(Tcontext245023* c, Tnode191813* prc, Tspecialwords173012 validpragmas) {
	Tnode191813* result;
	Tnode191813* n;
{	result = 0;
	n = (*prc).kindU.S6.sons->data[((NI) 4)];
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = (n == NIM_NIL);
		if (LOC3) goto LA4;
		LOC3 = ((*n).kind == ((NU8) 1));
		LA4: ;
		if (!LOC3) goto LA5;
		goto BeforeRet;
	}
	LA5: ;
	{
		NI i_439177;
		NI HEX3Atmp_439272;
		NI LOC8;
		NI res_439275;
		i_439177 = 0;
		HEX3Atmp_439272 = 0;
		LOC8 = 0;
		LOC8 = len_192097(n);
		HEX3Atmp_439272 = (LOC8 - 1);
		res_439275 = ((NI) 0);
		{
			while (1) {
				if (!(res_439275 <= HEX3Atmp_439272)) goto LA10;
				i_439177 = res_439275;
				{
					Tnode191813* it;
					Tnode191813* key;
					Tsym191843* m;
					Tnode191813* x;
					Tnode191813* LOC33;
					it = (*n).kindU.S6.sons->data[i_439177];
					{
						if (!((*it).kind == ((NU8) 34))) goto LA14;
						key = (*it).kindU.S6.sons->data[((NI) 0)];
					}
					goto LA12;
					LA14: ;
					{
						key = it;
					}
					LA12: ;
					m = lookupmacro_439097(c, key);
					{
						if (!(m == NIM_NIL)) goto LA19;
						{
							NIM_BOOL LOC23;
							LOC23 = 0;
							LOC23 = ((*key).kind == ((NU8) 2));
							if (!(LOC23)) goto LA24;
							LOC23 = ((*(*key).kindU.S5.ident).Sup.id == ((NI) 87));
							LA24: ;
							if (!LOC23) goto LA25;
							{
								Tident168021* LOC29;
								LOC29 = 0;
								LOC29 = considerquotedident_250010((*prc).kindU.S6.sons->data[((NI) 0)]);
								if (!eqStrings((*LOC29).s, ((NimStringDesc*) &TMP3106))) goto LA30;
								asgnRefNoCycle((void**) (&(*prc).kindU.S6.sons->data[((NI) 0)]), newidentnode_193313(iddelegator_168550, (*prc).info));
								asgnRefNoCycle((void**) (&(*prc).kindU.S6.sons->data[((NI) 4)]), copyexcept_439050(n, i_439177));
							}
							goto LA27;
							LA30: ;
							{
								localerror_166155((*prc).info, ((NU16) 199), ((NimStringDesc*) &TMP2991));
							}
							LA27: ;
						}
						LA25: ;
						goto LA11;
					}
					LA19: ;
					x = newnodei_193351(((NU8) 27), (*n).info);
					LOC33 = 0;
					LOC33 = newsymnode_193325(m);
					add_192164(x, LOC33);
					asgnRefNoCycle((void**) (&(*prc).kindU.S6.sons->data[((NI) 4)]), copyexcept_439050(n, i_439177));
					{
						if (!((*it).kind == ((NU8) 34))) goto LA36;
						add_192164(x, (*it).kindU.S6.sons->data[((NI) 1)]);
					}
					LA36: ;
					add_192164(x, prc);
					result = semstmt_410277(c, x);
					{
						NIM_BOOL LOC40;
						NIM_BOOL LOC41;
						Tnode191813* LOC43;
						Tnode191813* LOC45;
						Tnode191813* LOC48;
						Tnode191813* LOC49;
						LOC40 = 0;
						LOC41 = 0;
						LOC41 = ((*result).kind >= ((NU8) 51) && (*result).kind <= ((NU8) 52) || (*result).kind >= ((NU8) 79) && (*result).kind <= ((NU8) 81) || (*result).kind == ((NU8) 84));
						if (!(LOC41)) goto LA42;
						LOC43 = 0;
						LOC43 = HEX5BHEX5D_192244(result, ((NI) 0));
						LOC41 = ((*LOC43).kind == ((NU8) 3));
						LA42: ;
						LOC40 = LOC41;
						if (!(LOC40)) goto LA44;
						LOC45 = 0;
						LOC45 = HEX5BHEX5D_192244(result, ((NI) 4));
						LOC40 = !(((*LOC45).kind == ((NU8) 1)));
						LA44: ;
						if (!LOC40) goto LA46;
						LOC48 = 0;
						LOC48 = HEX5BHEX5D_192244(result, ((NI) 0));
						LOC49 = 0;
						LOC49 = HEX5BHEX5D_192244(result, ((NI) 4));
						pragma_261069(c, (*LOC48).kindU.S4.sym, LOC49, validpragmas);
					}
					LA46: ;
					goto BeforeRet;
				} LA11: ;
				res_439275 += ((NI) 1);
			} LA10: ;
		}
	}
	}BeforeRet: ;
	return result;
}

static N_INLINE(NIM_BOOL, istoplevel_246269)(Tcontext245023* c) {
	NIM_BOOL result;
	result = 0;
	result = ((*(*c).currentscope).depthlevel <= ((NI) 2));
	return result;
}

N_NIMCALL(Tsym191843*, newsymg_410916)(NU8 kind, Tnode191813* n, Tcontext245023* c) {
	Tsym191843* result;
	result = 0;
	{
		if (!((*n).kind == ((NU8) 3))) goto LA3;
		result = (*n).kindU.S4.sym;
		{
			NimStringDesc* LOC9;
			if (!!(((*result).kind == kind))) goto LA7;
			LOC9 = 0;
			LOC9 = HEX24_166306(TMP3107);
			internalerror_166218(LOC9);
		}
		LA7: ;
		asgnRefNoCycle((void**) (&(*result).owner), getcurrowner_245255());
	}
	goto LA1;
	LA3: ;
	{
		Tident168021* LOC11;
		Tsym191843* LOC12;
		LOC11 = 0;
		LOC11 = considerquotedident_250010(n);
		LOC12 = 0;
		LOC12 = getcurrowner_245255();
		result = newsym_192655(kind, LOC11, LOC12, (*n).info);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tsym191843*, semidentvis_410955)(Tcontext245023* c, NU8 kind, Tnode191813* n, NU32 allowed) {
	Tsym191843* result;
	result = 0;
	{
		if (!((*n).kind == ((NU8) 31))) goto LA3;
		{
			NIM_BOOL LOC7;
			NI LOC8;
			Tident168021* v;
			LOC7 = 0;
			LOC8 = 0;
			LOC8 = sonslen_194403(n);
			LOC7 = (LOC8 == ((NI) 2));
			if (!(LOC7)) goto LA9;
			LOC7 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 2));
			LA9: ;
			if (!LOC7) goto LA10;
			result = newsymg_410916(kind, (*n).kindU.S6.sons->data[((NI) 1)], c);
			v = (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S5.ident;
			{
				NIM_BOOL LOC14;
				LOC14 = 0;
				LOC14 = ((allowed &(1<<((((NU8) 1))&31)))!=0);
				if (!(LOC14)) goto LA15;
				LOC14 = ((*v).Sup.id == ((NI) 76));
				LA15: ;
				if (!LOC14) goto LA16;
				(*result).flags |= ((NI32)1)<<((((NU8) 1))%(sizeof(NI32)*8));
			}
			goto LA12;
			LA16: ;
			{
				localerror_166155((*(*n).kindU.S6.sons->data[((NI) 0)]).info, ((NU16) 174), (*v).s);
			}
			LA12: ;
		}
		goto LA5;
		LA10: ;
		{
			illformedast_246229(n);
		}
		LA5: ;
	}
	goto LA1;
	LA3: ;
	{
		result = newsymg_410916(kind, n, c);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tsym191843*, semidentwithpragma_410964)(Tcontext245023* c, NU8 kind, Tnode191813* n, NU32 allowed) {
	Tsym191843* result;
	result = 0;
	{
		if (!((*n).kind == ((NU8) 43))) goto LA3;
		checksonslen_246249(n, ((NI) 2));
		result = semidentvis_410955(c, kind, (*n).kindU.S6.sons->data[((NI) 0)], allowed);
		switch (kind) {
		case ((NU8) 7):
		{
		}
		break;
		case ((NU8) 19):
		{
			pragma_261069(c, result, (*n).kindU.S6.sons->data[((NI) 1)], TMP3109);
		}
		break;
		case ((NU8) 8):
		{
			pragma_261069(c, result, (*n).kindU.S6.sons->data[((NI) 1)], TMP3110);
		}
		break;
		case ((NU8) 9):
		{
			pragma_261069(c, result, (*n).kindU.S6.sons->data[((NI) 1)], TMP3110);
		}
		break;
		case ((NU8) 10):
		{
			pragma_261069(c, result, (*n).kindU.S6.sons->data[((NI) 1)], TMP3111);
		}
		break;
		default:
		{
		}
		break;
		}
	}
	goto LA1;
	LA3: ;
	{
		result = semidentvis_410955(c, kind, n, allowed);
	}
	LA1: ;
	{
		if (!(gcmd_155130 == ((NU8) 7))) goto LA14;
	}
	LA14: ;
	return result;
}

static N_INLINE(void, suggestsym_354960)(Tlineinfo164338 info, Tsym191843* s) {
	{
		if (!(gidecmd_155115 == ((NU8) 4))) goto LA3;
		findusages_354892(info, s);
	}
	goto LA1;
	LA3: ;
	{
		if (!(gidecmd_155115 == ((NU8) 3))) goto LA6;
		finddefinition_354923(info, s);
	}
	goto LA1;
	LA6: ;
	LA1: ;
}

N_NIMCALL(Tsym191843*, semidentdef_435142)(Tcontext245023* c, Tnode191813* n, NU8 kind) {
	Tsym191843* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = istoplevel_246269(c);
		if (!LOC3) goto LA4;
		result = semidentwithpragma_410964(c, kind, n, 2);
		(*result).flags |= ((NI32)1)<<((((NU8) 3))%(sizeof(NI32)*8));
	}
	goto LA1;
	LA4: ;
	{
		result = semidentwithpragma_410964(c, kind, n, 0);
	}
	LA1: ;
	suggestsym_354960((*n).info, result);
	return result;
}

N_NIMCALL(Ttype191849*, semgenericconstraints_422930)(Tcontext245023* c, Ttype191849* x) {
	Ttype191849* result;
	Ttypeseq191845* LOC1;
	TY350187 LOC2;
	result = 0;
	LOC1 = 0;
	LOC1 = (Ttypeseq191845*) newSeq((&NTI191845), 1);
	memset((void*)LOC2, 0, sizeof(LOC2));
	LOC2[0] = x;
	asgnRefNoCycle((void**) (&LOC1->data[0]), LOC2[0]);
	result = newtypewithsons_245807(c, ((NU8) 12), LOC1);
	return result;
}

N_NIMCALL(Tnode191813*, semgenericparamlist_422951)(Tcontext245023* c, Tnode191813* n, Ttype191849* father) {
	Tnode191813* result;
{	result = 0;
	result = copynode_195640(n);
	{
		if (!!(((*n).kind == ((NU8) 75)))) goto LA3;
		illformedast_246229(n);
		goto BeforeRet;
	}
	LA3: ;
	{
		NI i_422978;
		NI HEX3Atmp_423218;
		NI LOC6;
		NI res_423221;
		i_422978 = 0;
		HEX3Atmp_423218 = 0;
		LOC6 = 0;
		LOC6 = sonslen_194403(n);
		HEX3Atmp_423218 = (NI)(LOC6 - ((NI) 1));
		res_423221 = ((NI) 0);
		{
			while (1) {
				Tnode191813* a;
				NI L;
				Tnode191813* def;
				NI LOC13;
				Tnode191813* constraint;
				NI LOC20;
				Ttype191849* typ;
				if (!(res_423221 <= HEX3Atmp_423218)) goto LA8;
				i_422978 = res_423221;
				a = (*n).kindU.S6.sons->data[i_422978];
				{
					if (!!(((*a).kind == ((NU8) 35)))) goto LA11;
					illformedast_246229(n);
				}
				LA11: ;
				L = len_192097(a);
				LOC13 = 0;
				{
					if (!NIM_FALSE) goto LA16;
					LOC13 = ((NI) -1);
				}
				goto LA14;
				LA16: ;
				{
					NI LOC19;
					LOC19 = 0;
					LOC19 = len_192097(a);
					LOC13 = (NI)(LOC19 + ((NI) -1));
				}
				LA14: ;
				def = HEX5BHEX5D_192244(a, LOC13);
				LOC20 = 0;
				{
					if (!NIM_FALSE) goto LA23;
					LOC20 = ((NI) -2);
				}
				goto LA21;
				LA23: ;
				{
					NI LOC26;
					LOC26 = 0;
					LOC26 = len_192097(a);
					LOC20 = (NI)(LOC26 + ((NI) -2));
				}
				LA21: ;
				constraint = HEX5BHEX5D_192244(a, LOC20);
				typ = 0;
				{
					if (!!(((*constraint).kind == ((NU8) 1)))) goto LA29;
					typ = semtypenode_410269(c, constraint, NIM_NIL);
					{
						NIM_BOOL LOC33;
						NI LOC35;
						LOC33 = 0;
						LOC33 = !(((*typ).kind == ((NU8) 59)));
						if (LOC33) goto LA34;
						LOC35 = 0;
						LOC35 = len_194377(typ);
						LOC33 = (LOC35 == ((NI) 0));
						LA34: ;
						if (!LOC33) goto LA36;
						{
							if (!((*typ).kind == ((NU8) 8))) goto LA40;
							{
								Ttypeseq191845* LOC46;
								TY350187 LOC47;
								if (!((*(*typ).sons->data[((NI) 0)]).kind == ((NU8) 0))) goto LA44;
								LOC46 = 0;
								LOC46 = (Ttypeseq191845*) newSeq((&NTI191845), 1);
								memset((void*)LOC47, 0, sizeof(LOC47));
								LOC47[0] = newtypes_245218(((NU8) 0), c);
								asgnRefNoCycle((void**) (&LOC46->data[0]), LOC47[0]);
								typ = newtypewithsons_245807(c, ((NU8) 8), LOC46);
							}
							LA44: ;
						}
						goto LA38;
						LA40: ;
						{
							typ = semgenericconstraints_422930(c, typ);
						}
						LA38: ;
					}
					LA36: ;
				}
				LA29: ;
				{
					if (!!(((*def).kind == ((NU8) 1)))) goto LA51;
					def = semconstexpr_411485(c, def);
					{
						if (!(typ == NIM_NIL)) goto LA55;
						{
							Ttypeseq191845* LOC61;
							TY350187 LOC62;
							if (!!(((*(*def).typ).kind == ((NU8) 8)))) goto LA59;
							LOC61 = 0;
							LOC61 = (Ttypeseq191845*) newSeq((&NTI191845), 1);
							memset((void*)LOC62, 0, sizeof(LOC62));
							LOC62[0] = (*def).typ;
							asgnRefNoCycle((void**) (&LOC61->data[0]), LOC62[0]);
							typ = newtypewithsons_245807(c, ((NU8) 59), LOC61);
						}
						LA59: ;
					}
					goto LA53;
					LA55: ;
					{
						asgnRefNoCycle((void**) (&(*def).typ), skiptypes_195167((*def).typ, 256));
						{
							NIM_BOOL LOC66;
							LOC66 = 0;
							LOC66 = containsgenerictype_230310((*def).typ);
							if (!!(LOC66)) goto LA67;
							def = fitnode_410245(c, typ, def);
						}
						LA67: ;
					}
					LA53: ;
				}
				LA51: ;
				{
					if (!(typ == NIM_NIL)) goto LA71;
					typ = newtypes_245218(((NU8) 12), c);
					{
						if (!(father == NIM_NIL)) goto LA75;
						(*typ).flags |= ((NI32)1)<<((((NU8) 25))%(sizeof(NI32)*8));
					}
					LA75: ;
				}
				LA71: ;
				(*typ).flags |= ((NI32)1)<<((((NU8) 23))%(sizeof(NI32)*8));
				{
					NI j_423146;
					NI HEX3Atmp_423211;
					NI res_423214;
					j_423146 = 0;
					HEX3Atmp_423211 = 0;
					HEX3Atmp_423211 = (NI)(L - ((NI) 3));
					res_423214 = ((NI) 0);
					{
						while (1) {
							Ttype191849* finaltype;
							Tsym191843* s;
							Tnode191813* LOC102;
							if (!(res_423214 <= HEX3Atmp_423211)) goto LA79;
							j_423146 = res_423214;
							{
								if (!(j_423146 == ((NI) 0))) goto LA82;
								finaltype = typ;
							}
							goto LA80;
							LA82: ;
							{
								finaltype = copytype_194549(typ, (*typ).owner, NIM_FALSE);
							}
							LA80: ;
							{
								NIM_BOOL LOC87;
								Tsym191843* LOC91;
								LOC87 = 0;
								LOC87 = ((*finaltype).kind == ((NU8) 59));
								if (LOC87) goto LA88;
								LOC87 = (((*typ).flags &(1<<((((NU8) 25))&31)))!=0);
								LA88: ;
								if (!LOC87) goto LA89;
								LOC91 = 0;
								LOC91 = newsymg_410916(((NU8) 4), (*a).kindU.S6.sons->data[j_423146], c);
								s = linkto_192884(LOC91, finaltype);
							}
							goto LA85;
							LA89: ;
							{
								Tsym191843* LOC93;
								LOC93 = 0;
								LOC93 = newsymg_410916(((NU8) 7), (*a).kindU.S6.sons->data[j_423146], c);
								s = linkto_192884(LOC93, finaltype);
							}
							LA85: ;
							{
								if (!!(((*def).kind == ((NU8) 1)))) goto LA96;
								asgnRefNoCycle((void**) (&(*s).ast), def);
							}
							LA96: ;
							{
								if (!!((father == NIM_NIL))) goto LA100;
								addsonskipintlit_239731(father, (*s).typ);
							}
							LA100: ;
							(*s).position = len_192097(result);
							LOC102 = 0;
							LOC102 = newsymnode_193325(s);
							addson_193819(result, LOC102);
							{
								if (!!((((*s).flags &(1<<((((NU8) 31))&31)))!=0))) goto LA105;
								adddecl_250607(c, s);
							}
							LA105: ;
							res_423214 += ((NI) 1);
						} LA79: ;
					}
				}
				res_423221 += ((NI) 1);
			} LA8: ;
		}
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, newproctype_421342)(Tcontext245023* c, Tlineinfo164338 info, Ttype191849* prev) {
	Ttype191849* result;
	Toptionentry245005* LOC1;
	Tnode191813* LOC2;
	result = 0;
	result = neworprevtype_416695(((NU8) 25), prev, c);
	LOC1 = 0;
	LOC1 = lastoptionentry_245187(c);
	(*result).callconv = (*LOC1).defaultcc;
	asgnRefNoCycle((void**) (&(*result).n), newnodei_193351(((NU8) 76), info));
	rawaddson_195478(result, NIM_NIL);
	LOC2 = 0;
	LOC2 = newnodei_193351(((NU8) 152), info);
	addson_193819((*result).n, LOC2);
	return result;
}

N_NIMCALL(Ttype191849*, semparamtype_421322)(Tcontext245023* c, Tnode191813* n, Tnode191813** constraint) {
	Ttype191849* result;
	result = 0;
	{
		if (!((*n).kind == ((NU8) 40))) goto LA3;
		result = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
		unsureAsgnRef((void**) (&(*constraint)), semnodekindconstraints_269679(n));
	}
	goto LA1;
	LA3: ;
	{
		result = semtypenode_410269(c, n, NIM_NIL);
	}
	LA1: ;
	return result;
}
N_NIMCALL(void, TMP3133)(void* p, NI op) {
	TY421253* a;
	a = (TY421253*)p;
	nimGCvisit((void*)(*a).paramname420285, op);
	nimGCvisit((void*)(*a).genericparams420283, op);
	nimGCvisit((void*)(*a).c420281, op);
}

N_CLOSURE(Ttype191849*, addimplicitgenericimpl_420301)(Ttype191849* typeclass, Tident168021* typid, void* ClEnv) {
	Ttype191849* result;
	TY421253* HEX3Aenvp_421268;
	Tident168021* finaltypid;
	Tsym191843* owner;
	Tsym191843* s;
	Tsym191843* LOC28;
	Tnode191813* LOC29;
{	result = 0;
	HEX3Aenvp_421268 = (TY421253*) ClEnv;
	{
		if (!!((typid == NIM_NIL))) goto LA3;
		finaltypid = typid;
	}
	goto LA1;
	LA3: ;
	{
		NimStringDesc* LOC6;
		LOC6 = 0;
		LOC6 = rawNewString((*HEX3Aenvp_421268).paramname420285->Sup.len + 5);
appendString(LOC6, (*HEX3Aenvp_421268).paramname420285);
appendString(LOC6, ((NimStringDesc*) &TMP3134));
		finaltypid = getident_168463(LOC6);
	}
	LA1: ;
	{
		if (!((*HEX3Aenvp_421268).genericparams420283 == NIM_NIL)) goto LA9;
		goto BeforeRet;
	}
	LA9: ;
	{
		NI i_420344;
		NI HEX3Atmp_420401;
		NI LOC12;
		NI res_420404;
		i_420344 = 0;
		HEX3Atmp_420401 = 0;
		LOC12 = 0;
		LOC12 = len_192097((*HEX3Aenvp_421268).genericparams420283);
		HEX3Atmp_420401 = (NI)(LOC12 - ((NI) 1));
		res_420404 = ((NI) 0);
		{
			while (1) {
				if (!(res_420404 <= HEX3Atmp_420401)) goto LA14;
				i_420344 = res_420404;
				{
					if (!((*(*(*(*(*HEX3Aenvp_421268).genericparams420283).kindU.S6.sons->data[i_420344]).kindU.S4.sym).name).Sup.id == (*finaltypid).Sup.id)) goto LA17;
					result = (*(*(*HEX3Aenvp_421268).genericparams420283).kindU.S6.sons->data[i_420344]).typ;
					goto BeforeRet;
				}
				LA17: ;
				res_420404 += ((NI) 1);
			} LA14: ;
		}
	}
	{
		if (!!(((*typeclass).sym == NIM_NIL))) goto LA21;
		owner = (*typeclass).sym;
	}
	goto LA19;
	LA21: ;
	{
		owner = getcurrowner_245255();
	}
	LA19: ;
	s = newsym_192655(((NU8) 7), finaltypid, owner, (*HEX3Aenvp_421268).info420286);
	{
		if (!(typid == NIM_NIL)) goto LA26;
		(*s).flags |= ((NI32)1)<<((((NU8) 29))%(sizeof(NI32)*8));
	}
	LA26: ;
	LOC28 = 0;
	LOC28 = linkto_192884(s, typeclass);
	(*typeclass).flags |= ((NI32)1)<<((((NU8) 24))%(sizeof(NI32)*8));
	(*s).position = len_192097((*HEX3Aenvp_421268).genericparams420283);
	LOC29 = 0;
	LOC29 = newsymnode_193325(s);
	addson_193819((*HEX3Aenvp_421268).genericparams420283, LOC29);
	result = typeclass;
	adddecl_250607((*HEX3Aenvp_421268).c420281, s);
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, liftparamtype_420279)(Tcontext245023* c, NU8 prockind, Tnode191813* genericparams, Ttype191849* paramtype, NimStringDesc* paramname, Tlineinfo164338 info, NIM_BOOL anon) {
	Ttype191849* result;
	TY421253* HEX3Aenv_421310;
	NimStringDesc* LOC1;
	Tident168021* paramtypid;
{	result = 0;
	HEX3Aenv_421310 = 0;
	HEX3Aenv_421310 = (TY421253*) newObj((&NTI421311), sizeof(TY421253));
	LOC1 = 0;
	LOC1 = (*HEX3Aenv_421310).paramname420285; (*HEX3Aenv_421310).paramname420285 = copyStringRC1(paramname);
	if (LOC1) nimGCunrefNoCycle(LOC1);
	asgnRefNoCycle((void**) (&(*HEX3Aenv_421310).genericparams420283), genericparams);
	(*HEX3Aenv_421310).info420286 = info;
	asgnRef((void**) (&(*HEX3Aenv_421310).c420281), c);
	{
		if (!(paramtype == NIM_NIL)) goto LA4;
		goto BeforeRet;
	}
	LA4: ;
	{
		NIM_BOOL LOC8;
		LOC8 = 0;
		LOC8 = !(anon);
		if (!(LOC8)) goto LA9;
		LOC8 = !(((*paramtype).sym == NIM_NIL));
		LA9: ;
		if (!LOC8) goto LA10;
		paramtypid = (*(*paramtype).sym).name;
	}
	goto LA6;
	LA10: ;
	{
		paramtypid = NIM_NIL;
	}
	LA6: ;
	switch ((*paramtype).kind) {
	case ((NU8) 58):
	{
		TY420302 LOC14;
		Ttype191849* LOC15;
		memset((void*)(&LOC14), 0, sizeof(LOC14));
		LOC14.ClPrc = addimplicitgenericimpl_420301; LOC14.ClEnv = HEX3Aenv_421310;
		LOC15 = 0;
		LOC15 = newtypes_245218(((NU8) 12), (*HEX3Aenv_421310).c420281);
		result = LOC14.ClEnv? LOC14.ClPrc(LOC15, paramtypid, LOC14.ClEnv):((TMP3135)(LOC14.ClPrc))(LOC15, paramtypid);
	}
	break;
	case ((NU8) 59):
	{
		Ttype191849* base;
		Ttype191849* lifted_420456;
		Ttype191849* LOC25;
		TY420302 LOC37;
		Ttypeseq191845* LOC38;
		TY350187 LOC39;
		Ttype191849* LOC40;
		{
			if (!!(((*paramtype).n == NIM_NIL))) goto LA19;
			goto BeforeRet;
		}
		LA19: ;
		{
			if (!(((*paramtype).flags &(1<<((((NU8) 9))&31)))!=0)) goto LA23;
			goto BeforeRet;
		}
		LA23: ;
		LOC25 = 0;
		LOC25 = base_221039(paramtype);
		lifted_420456 = liftparamtype_420279((*HEX3Aenv_421310).c420281, prockind, (*HEX3Aenv_421310).genericparams420283, LOC25, (*HEX3Aenv_421310).paramname420285, (*HEX3Aenv_421310).info420286, NIM_FALSE);
		{
			if (!!((lifted_420456 == NIM_NIL))) goto LA28;
			base = lifted_420456;
		}
		goto LA26;
		LA28: ;
		{
			base = base_221039(paramtype);
		}
		LA26: ;
		{
			NIM_BOOL LOC33;
			LOC33 = 0;
			LOC33 = ismetatype_192821(base);
			if (!(LOC33)) goto LA34;
			LOC33 = (prockind == ((NU8) 17));
			LA34: ;
			if (!LOC33) goto LA35;
			localerror_166155((*HEX3Aenv_421310).info420286, ((NU16) 201), (*HEX3Aenv_421310).paramname420285);
		}
		LA35: ;
		memset((void*)(&LOC37), 0, sizeof(LOC37));
		LOC37.ClPrc = addimplicitgenericimpl_420301; LOC37.ClEnv = HEX3Aenv_421310;
		LOC38 = 0;
		LOC38 = (Ttypeseq191845*) newSeq((&NTI191845), 1);
		memset((void*)LOC39, 0, sizeof(LOC39));
		LOC39[0] = base;
		asgnRefNoCycle((void**) (&LOC38->data[0]), LOC39[0]);
		LOC40 = 0;
		LOC40 = newtypewithsons_245807((*HEX3Aenv_421310).c420281, ((NU8) 59), LOC38);
		result = LOC37.ClEnv? LOC37.ClPrc(LOC40, paramtypid, LOC37.ClEnv):((TMP3136)(LOC37.ClPrc))(LOC40, paramtypid);
		(*result).flags = ((*result).flags | 4194816);
	}
	break;
	case ((NU8) 8):
	{
		{
			TY420302 LOC55;
			Ttypeseq191845* LOC56;
			TY350187 LOC57;
			Ttype191849* LOC58;
			if (!!((((*paramtype).flags &(1<<((((NU8) 9))&31)))!=0))) goto LA44;
			{
				NIM_BOOL LOC48;
				NIM_BOOL LOC49;
				Ttype191849* LOC50;
				LOC48 = 0;
				LOC49 = 0;
				LOC50 = 0;
				LOC50 = base_221039(paramtype);
				LOC49 = ((*LOC50).kind == ((NU8) 0));
				if (!(LOC49)) goto LA51;
				LOC49 = !((paramtypid == NIM_NIL));
				LA51: ;
				LOC48 = LOC49;
				if (!(LOC48)) goto LA52;
				LOC48 = ((*paramtypid).Sup.id == (*typedescid_420273).Sup.id);
				LA52: ;
				if (!LOC48) goto LA53;
				paramtypid = NIM_NIL;
			}
			LA53: ;
			memset((void*)(&LOC55), 0, sizeof(LOC55));
			LOC55.ClPrc = addimplicitgenericimpl_420301; LOC55.ClEnv = HEX3Aenv_421310;
			LOC56 = 0;
			LOC56 = (Ttypeseq191845*) newSeq((&NTI191845), 1);
			memset((void*)LOC57, 0, sizeof(LOC57));
			LOC57[0] = base_221039(paramtype);
			asgnRefNoCycle((void**) (&LOC56->data[0]), LOC57[0]);
			LOC58 = 0;
			LOC58 = newtypewithsons_245807((*HEX3Aenv_421310).c420281, ((NU8) 8), LOC56);
			result = LOC55.ClEnv? LOC55.ClPrc(LOC58, paramtypid, LOC55.ClEnv):((TMP3137)(LOC55.ClPrc))(LOC58, paramtypid);
		}
		LA44: ;
	}
	break;
	case ((NU8) 13):
	{
		{
			NI LOC62;
			LOC62 = 0;
			LOC62 = sonslen_194351(paramtype);
			if (!(LOC62 == ((NI) 1))) goto LA63;
			result = liftparamtype_420279((*HEX3Aenv_421310).c420281, prockind, (*HEX3Aenv_421310).genericparams420283, (*paramtype).sons->data[((NI) 0)], (*HEX3Aenv_421310).paramname420285, (*HEX3Aenv_421310).info420286, NIM_TRUE);
		}
		LA63: ;
	}
	break;
	case ((NU8) 24):
	case ((NU8) 19):
	case ((NU8) 16):
	case ((NU8) 27):
	case ((NU8) 23):
	case ((NU8) 21):
	case ((NU8) 22):
	case ((NU8) 25):
	{
		{
			NIM_BOOL LOC68;
			Ttype191849* LOC70;
			Ttype191849* typ;
			Ttypeseq191845* LOC73;
			TY350187 LOC74;
			TY420302 LOC75;
			LOC68 = 0;
			LOC68 = ((*paramtype).kind == ((NU8) 24));
			if (!(LOC68)) goto LA69;
			LOC70 = 0;
			LOC70 = lastson_194442(paramtype);
			LOC68 = ((*LOC70).kind == ((NU8) 0));
			LA69: ;
			if (!LOC68) goto LA71;
			LOC73 = 0;
			LOC73 = (Ttypeseq191845*) newSeq((&NTI191845), 1);
			memset((void*)LOC74, 0, sizeof(LOC74));
			LOC74[0] = newtypes_245218((*paramtype).kind, (*HEX3Aenv_421310).c420281);
			asgnRefNoCycle((void**) (&LOC73->data[0]), LOC74[0]);
			typ = newtypewithsons_245807((*HEX3Aenv_421310).c420281, ((NU8) 51), LOC73);
			memset((void*)(&LOC75), 0, sizeof(LOC75));
			LOC75.ClPrc = addimplicitgenericimpl_420301; LOC75.ClEnv = HEX3Aenv_421310;
			result = LOC75.ClEnv? LOC75.ClPrc(typ, paramtypid, LOC75.ClEnv):((TMP3138)(LOC75.ClPrc))(typ, paramtypid);
		}
		goto LA66;
		LA71: ;
		{
			{
				NI i_420599;
				NI HEX3Atmp_421222;
				NI LOC78;
				NI res_421225;
				i_420599 = 0;
				HEX3Atmp_421222 = 0;
				LOC78 = 0;
				LOC78 = len_194377(paramtype);
				HEX3Atmp_421222 = (LOC78 - 1);
				res_421225 = ((NI) 0);
				{
					while (1) {
						Ttype191849* lifted;
						if (!(res_421225 <= HEX3Atmp_421222)) goto LA80;
						i_420599 = res_421225;
						{
							NimStringDesc* LOC85;
							if (!((*paramtype).sons->data[i_420599] == paramtype)) goto LA83;
							LOC85 = 0;
							LOC85 = typetostring_221032(paramtype, ((NU8) 0));
							globalerror_166134((*HEX3Aenv_421310).info420286, ((NU16) 123), LOC85);
						}
						LA83: ;
						lifted = liftparamtype_420279((*HEX3Aenv_421310).c420281, prockind, (*HEX3Aenv_421310).genericparams420283, (*paramtype).sons->data[i_420599], (*HEX3Aenv_421310).paramname420285, (*HEX3Aenv_421310).info420286, NIM_FALSE);
						{
							if (!!((lifted == NIM_NIL))) goto LA88;
							asgnRefNoCycle((void**) (&(*paramtype).sons->data[i_420599]), lifted);
							result = paramtype;
						}
						LA88: ;
						res_421225 += ((NI) 1);
					} LA80: ;
				}
			}
		}
		LA66: ;
	}
	break;
	case ((NU8) 10):
	{
		Ttypeseq191845* LOC109;
		TY245864 LOC110;
		TY420302 LOC111;
		result = newtypes_245218(((NU8) 9), (*HEX3Aenv_421310).c420281);
		rawaddson_195478(result, paramtype);
		{
			NI i_420634;
			NI HEX3Atmp_421230;
			NI LOC92;
			NI res_421233;
			i_420634 = 0;
			HEX3Atmp_421230 = 0;
			LOC92 = 0;
			LOC92 = sonslen_194351(paramtype);
			HEX3Atmp_421230 = (NI)(LOC92 - ((NI) 2));
			res_421233 = ((NI) 0);
			{
				while (1) {
					if (!(res_421233 <= HEX3Atmp_421230)) goto LA94;
					i_420634 = res_421233;
					{
						Tnode191813* x;
						Ttype191849* LOC99;
						if (!((*(*paramtype).sons->data[i_420634]).kind == ((NU8) 59))) goto LA97;
						x = copynode_195640(emptynode_192807);
						asgnRefNoCycle((void**) (&(*x).typ), (*paramtype).sons->data[i_420634]);
						LOC99 = 0;
						LOC99 = maketypefromexpr_245726((*HEX3Aenv_421310).c420281, x);
						rawaddson_195478(result, LOC99);
					}
					goto LA95;
					LA97: ;
					{
						Ttype191849* LOC101;
						LOC101 = 0;
						LOC101 = newtypes_245218(((NU8) 58), (*HEX3Aenv_421310).c420281);
						rawaddson_195478(result, LOC101);
					}
					LA95: ;
					res_421233 += ((NI) 1);
				} LA94: ;
			}
		}
		{
			Ttype191849* LOC104;
			Ttype191849* LOC107;
			TY420302 LOC108;
			LOC104 = 0;
			LOC104 = lastson_194442(paramtype);
			if (!((*LOC104).kind == ((NU8) 52))) goto LA105;
			(*result).kind = ((NU8) 53);
			LOC107 = 0;
			LOC107 = lastson_194442(paramtype);
			rawaddson_195478(result, LOC107);
			memset((void*)(&LOC108), 0, sizeof(LOC108));
			LOC108.ClPrc = addimplicitgenericimpl_420301; LOC108.ClEnv = HEX3Aenv_421310;
			result = LOC108.ClEnv? LOC108.ClPrc(result, paramtypid, LOC108.ClEnv):((TMP3139)(LOC108.ClPrc))(result, paramtypid);
			goto BeforeRet;
		}
		LA105: ;
		result = instgenericcontainer_413151((*HEX3Aenv_421310).c420281, (*(*paramtype).sym).info, result, NIM_TRUE);
		LOC109 = 0;
		LOC109 = (Ttypeseq191845*) newSeq((&NTI191845), 2);
		memset((void*)LOC110, 0, sizeof(LOC110));
		LOC110[0] = paramtype;
		LOC110[1] = result;
		asgnRefNoCycle((void**) (&LOC109->data[0]), LOC110[0]);
		asgnRefNoCycle((void**) (&LOC109->data[1]), LOC110[1]);
		result = newtypewithsons_245807((*HEX3Aenv_421310).c420281, ((NU8) 54), LOC109);
		memset((void*)(&LOC111), 0, sizeof(LOC111));
		LOC111.ClPrc = addimplicitgenericimpl_420301; LOC111.ClEnv = HEX3Aenv_421310;
		result = LOC111.ClEnv? LOC111.ClPrc(result, paramtypid, LOC111.ClEnv):((TMP3140)(LOC111.ClPrc))(result, paramtypid);
	}
	break;
	case ((NU8) 49):
	{
		{
			TY420302 LOC131;
			if (!((*paramtype).callconv == ((NU8) 5))) goto LA115;
			{
				if (!!(((409600 &(1<<((prockind)&31)))!=0))) goto LA119;
				localerror_166155((*HEX3Aenv_421310).info420286, ((NU16) 203), ((NimStringDesc*) &TMP2991));
			}
			LA119: ;
			{
				NI LOC123;
				Ttype191849* lifted;
				Ttype191849* LOC126;
				LOC123 = 0;
				LOC123 = len_194377(paramtype);
				if (!(LOC123 == ((NI) 1))) goto LA124;
				LOC126 = 0;
				LOC126 = base_221039(paramtype);
				lifted = liftparamtype_420279((*HEX3Aenv_421310).c420281, prockind, (*HEX3Aenv_421310).genericparams420283, LOC126, (*HEX3Aenv_421310).paramname420285, (*HEX3Aenv_421310).info420286, NIM_FALSE);
				{
					if (!!((lifted == NIM_NIL))) goto LA129;
					asgnRefNoCycle((void**) (&(*paramtype).sons->data[((NI) 0)]), lifted);
				}
				LA129: ;
			}
			LA124: ;
			memset((void*)(&LOC131), 0, sizeof(LOC131));
			LOC131.ClPrc = addimplicitgenericimpl_420301; LOC131.ClEnv = HEX3Aenv_421310;
			result = LOC131.ClEnv? LOC131.ClPrc(paramtype, paramtypid, LOC131.ClEnv):((TMP3141)(LOC131.ClPrc))(paramtype, paramtypid);
		}
		LA115: ;
	}
	break;
	case ((NU8) 11):
	{
		Ttype191849* liftbody;
		Ttype191849* LOC154;
		{
			Ttype191849* LOC135;
			Ttype191849* cp;
			Tsym191843* LOC138;
			TY420302 LOC139;
			LOC135 = 0;
			LOC135 = lastson_194442(paramtype);
			if (!((*LOC135).kind == ((NU8) 52))) goto LA136;
			LOC138 = 0;
			LOC138 = getcurrowner_245255();
			cp = copytype_194549(paramtype, LOC138, NIM_FALSE);
			(*cp).kind = ((NU8) 53);
			memset((void*)(&LOC139), 0, sizeof(LOC139));
			LOC139.ClPrc = addimplicitgenericimpl_420301; LOC139.ClEnv = HEX3Aenv_421310;
			result = LOC139.ClEnv? LOC139.ClPrc(cp, paramtypid, LOC139.ClEnv):((TMP3142)(LOC139.ClPrc))(cp, paramtypid);
			goto BeforeRet;
		}
		LA136: ;
		{
			NI i_420721;
			NI HEX3Atmp_421238;
			NI LOC141;
			NI res_421241;
			i_420721 = 0;
			HEX3Atmp_421238 = 0;
			LOC141 = 0;
			LOC141 = len_194377(paramtype);
			HEX3Atmp_421238 = (NI)(LOC141 - ((NI) 2));
			res_421241 = ((NI) 1);
			{
				while (1) {
					Ttype191849* lifted;
					if (!(res_421241 <= HEX3Atmp_421238)) goto LA143;
					i_420721 = res_421241;
					lifted = liftparamtype_420279((*HEX3Aenv_421310).c420281, prockind, (*HEX3Aenv_421310).genericparams420283, (*paramtype).sons->data[i_420721], (*HEX3Aenv_421310).paramname420285, (*HEX3Aenv_421310).info420286, NIM_FALSE);
					{
						if (!!((lifted == NIM_NIL))) goto LA146;
						asgnRefNoCycle((void**) (&(*paramtype).sons->data[i_420721]), lifted);
						result = paramtype;
						{
							Ttype191849* LOC150;
							NimStringDesc* LOC153;
							LOC150 = 0;
							LOC150 = lastson_194442(result);
							if (!!((((*LOC150).flags &(1<<((((NU8) 19))&31)))!=0))) goto LA151;
							LOC153 = 0;
							LOC153 = HEX24_166306(TMP3143);
							internalerror_166218(LOC153);
						}
						LA151: ;
					}
					LA146: ;
					res_421241 += ((NI) 1);
				} LA143: ;
			}
		}
		LOC154 = 0;
		LOC154 = lastson_194442(paramtype);
		liftbody = liftparamtype_420279((*HEX3Aenv_421310).c420281, prockind, (*HEX3Aenv_421310).genericparams420283, LOC154, (*HEX3Aenv_421310).paramname420285, (*HEX3Aenv_421310).info420286, NIM_TRUE);
		{
			if (!!((liftbody == NIM_NIL))) goto LA157;
			result = liftbody;
			{
				NimStringDesc* LOC163;
				if (!!((((*result).flags &(1<<((((NU8) 19))&31)))!=0))) goto LA161;
				LOC163 = 0;
				LOC163 = HEX24_166306(TMP3143);
				internalerror_166218(LOC163);
			}
			LA161: ;
		}
		LA157: ;
	}
	break;
	case ((NU8) 9):
	{
		{
			NI i_420800;
			NI HEX3Atmp_421246;
			NI LOC166;
			NI res_421249;
			i_420800 = 0;
			HEX3Atmp_421246 = 0;
			LOC166 = 0;
			LOC166 = len_194377(paramtype);
			HEX3Atmp_421246 = (LOC166 - 1);
			res_421249 = ((NI) 1);
			{
				while (1) {
					Ttype191849* lifted;
					if (!(res_421249 <= HEX3Atmp_421246)) goto LA168;
					i_420800 = res_421249;
					lifted = liftparamtype_420279((*HEX3Aenv_421310).c420281, prockind, (*HEX3Aenv_421310).genericparams420283, (*paramtype).sons->data[i_420800], (*HEX3Aenv_421310).paramname420285, (*HEX3Aenv_421310).info420286, NIM_FALSE);
					{
						if (!!((lifted == NIM_NIL))) goto LA171;
						asgnRefNoCycle((void**) (&(*paramtype).sons->data[i_420800]), lifted);
					}
					LA171: ;
					res_421249 += ((NI) 1);
				} LA168: ;
			}
		}
	}
	break;
	case ((NU8) 52):
	case ((NU8) 51):
	case ((NU8) 55):
	case ((NU8) 56):
	case ((NU8) 57):
	{
		TY420302 LOC174;
		Tsym191843* LOC175;
		Ttype191849* LOC176;
		memset((void*)(&LOC174), 0, sizeof(LOC174));
		LOC174.ClPrc = addimplicitgenericimpl_420301; LOC174.ClEnv = HEX3Aenv_421310;
		LOC175 = 0;
		LOC175 = getcurrowner_245255();
		LOC176 = 0;
		LOC176 = copytype_194549(paramtype, LOC175, NIM_TRUE);
		result = LOC174.ClEnv? LOC174.ClPrc(LOC176, paramtypid, LOC174.ClEnv):((TMP3144)(LOC174.ClPrc))(LOC176, paramtypid);
	}
	break;
	case ((NU8) 6):
	{
		{
			TY420302 LOC182;
			Ttype191849* LOC183;
			if (!!(((393216 &(1<<((prockind)&31)))!=0))) goto LA180;
			memset((void*)(&LOC182), 0, sizeof(LOC182));
			LOC182.ClPrc = addimplicitgenericimpl_420301; LOC182.ClEnv = HEX3Aenv_421310;
			LOC183 = 0;
			LOC183 = newtypes_245218(((NU8) 58), (*HEX3Aenv_421310).c420281);
			result = LOC182.ClEnv? LOC182.ClPrc(LOC183, paramtypid, LOC182.ClEnv):((TMP3145)(LOC182.ClPrc))(LOC183, paramtypid);
		}
		LA180: ;
	}
	break;
	case ((NU8) 12):
	{
		markused_345251((*HEX3Aenv_421310).info420286, (*paramtype).sym);
		{
			if (!(((*paramtype).flags &(1<<((((NU8) 25))&31)))!=0)) goto LA187;
			(*paramtype).flags &= ~(((NI32)1) << ((((NU8) 25)) % (sizeof(NI32)*8)));
			(*(*paramtype).sym).kind = ((NU8) 7);
		}
		LA187: ;
	}
	break;
	default:
	{
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, semproctypenode_421351)(Tcontext245023* c, Tnode191813* n, Tnode191813* genericparams, Ttype191849* prev, NU8 kind, NIM_BOOL istype) {
	Ttype191849* result;
	Intset188056 cl;
	Intset188056 check;
	NI counter;
	Ttype191849* r;
	result = 0;
	memset((void*)(&cl), 0, sizeof(cl));
	checkminsonslen_246259(n, ((NI) 1));
	result = newproctype_421342(c, (*n).info, prev);
	{
		NIM_BOOL LOC3;
		NI LOC5;
		LOC3 = 0;
		LOC3 = !((genericparams == NIM_NIL));
		if (!(LOC3)) goto LA4;
		LOC5 = 0;
		LOC5 = sonslen_194403(genericparams);
		LOC3 = (LOC5 == ((NI) 0));
		LA4: ;
		if (!LOC3) goto LA6;
		chckNil((void*)(&cl));
		memset((void*)(&cl), 0, sizeof(cl));
		initintset_188927((&cl));
	}
	LA6: ;
	memset((void*)(&check), 0, sizeof(check));
	chckNil((void*)(&check));
	memset((void*)(&check), 0, sizeof(check));
	initintset_188927((&check));
	counter = ((NI) 0);
	{
		NI i_421388;
		NI HEX3Atmp_421774;
		NI LOC9;
		NI res_421777;
		i_421388 = 0;
		HEX3Atmp_421774 = 0;
		LOC9 = 0;
		LOC9 = len_192097(n);
		HEX3Atmp_421774 = (NI)(LOC9 - ((NI) 1));
		res_421777 = ((NI) 1);
		{
			while (1) {
				if (!(res_421777 <= HEX3Atmp_421774)) goto LA11;
				i_421388 = res_421777;
				{
					Tnode191813* a;
					Ttype191849* typ;
					Tnode191813* def;
					Tnode191813* constraint;
					NI length;
					NIM_BOOL hastype;
					NIM_BOOL hasdefault;
					a = (*n).kindU.S6.sons->data[i_421388];
					{
						if (!!(((*a).kind == ((NU8) 35)))) goto LA15;
						{
							NIM_BOOL LOC19;
							LOC19 = 0;
							LOC19 = ((*a).kind == ((NU8) 3));
							if (!(LOC19)) goto LA20;
							LOC19 = (((*(*a).kindU.S4.sym).flags &(1<<((((NU8) 2))&31)))!=0);
							LA20: ;
							if (!LOC19) goto LA21;
							goto LA12;
						}
						LA21: ;
						illformedast_246229(a);
					}
					LA15: ;
					checkminsonslen_246259(a, ((NI) 3));
					typ = NIM_NIL;
					def = NIM_NIL;
					constraint = NIM_NIL;
					length = sonslen_194403(a);
					hastype = !(((*(*a).kindU.S6.sons->data[(NI)(length - ((NI) 2))]).kind == ((NU8) 1)));
					hasdefault = !(((*(*a).kindU.S6.sons->data[(NI)(length - ((NI) 1))]).kind == ((NU8) 1)));
					{
						if (!hastype) goto LA25;
						typ = semparamtype_421322(c, (*a).kindU.S6.sons->data[(NI)(length - ((NI) 2))], &constraint);
					}
					LA25: ;
					{
						if (!hasdefault) goto LA29;
						def = semexprwithtype_410211(c, (*a).kindU.S6.sons->data[(NI)(length - ((NI) 1))], 0);
						{
							if (!(typ == NIM_NIL)) goto LA33;
							typ = (*def).typ;
						}
						goto LA31;
						LA33: ;
						{
							if (!!((def == NIM_NIL))) goto LA36;
							{
								NIM_BOOL LOC40;
								LOC40 = 0;
								LOC40 = containsgenerictype_230310(typ);
								if (!!(LOC40)) goto LA41;
								def = fitnode_410245(c, typ, def);
							}
							LA41: ;
						}
						goto LA31;
						LA36: ;
						LA31: ;
					}
					LA29: ;
					{
						NIM_BOOL LOC45;
						NU8 tdef;
						LOC45 = 0;
						LOC45 = !(hastype);
						if (!(LOC45)) goto LA46;
						LOC45 = !(hasdefault);
						LA46: ;
						if (!LOC45) goto LA47;
						{
							if (!istype) goto LA51;
							localerror_166166((*a).info, ((NimStringDesc*) &TMP3131));
						}
						LA51: ;
						{
							if (!((393216 &(1<<((kind)&31)))!=0)) goto LA55;
							tdef = ((NU8) 6);
						}
						goto LA53;
						LA55: ;
						{
							tdef = ((NU8) 58);
						}
						LA53: ;
						{
							NimStringDesc* LOC62;
							if (!(tdef == ((NU8) 58))) goto LA60;
							LOC62 = 0;
							LOC62 = rendertree_213058(n, 0);
							message_166188((*a).info, ((NU16) 244), LOC62);
						}
						LA60: ;
						typ = newtypes_245218(tdef, c);
					}
					LA47: ;
					{
						Ttype191849* LOC65;
						LOC65 = 0;
						LOC65 = skiptypes_195167(typ, 2048);
						if (!((*LOC65).kind == ((NU8) 3))) goto LA66;
						goto LA12;
					}
					LA66: ;
					{
						NI j_421517;
						NI HEX3Atmp_421767;
						NI res_421770;
						j_421517 = 0;
						HEX3Atmp_421767 = 0;
						HEX3Atmp_421767 = (NI)(length - ((NI) 3));
						res_421770 = ((NI) 0);
						{
							while (1) {
								Tsym191843* arg;
								Ttype191849* lifted;
								Ttype191849* finaltype;
								Tnode191813* LOC87;
								if (!(res_421770 <= HEX3Atmp_421767)) goto LA70;
								j_421517 = res_421770;
								arg = newsymg_410916(((NU8) 3), (*a).kindU.S6.sons->data[j_421517], c);
								lifted = liftparamtype_420279(c, kind, genericparams, typ, (*(*arg).name).s, (*arg).info, NIM_FALSE);
								{
									if (!!((lifted == NIM_NIL))) goto LA73;
									finaltype = lifted;
								}
								goto LA71;
								LA73: ;
								{
									finaltype = skipintlit_239698(typ);
								}
								LA71: ;
								asgnRefNoCycle((void**) (&(*arg).typ), finaltype);
								(*arg).position = counter;
								asgnRefNoCycle((void**) (&(*arg).constraint), constraint);
								counter += ((NI) 1);
								{
									NIM_BOOL LOC78;
									LOC78 = 0;
									LOC78 = !((def == NIM_NIL));
									if (!(LOC78)) goto LA79;
									LOC78 = !(((*def).kind == ((NU8) 1)));
									LA79: ;
									if (!LOC78) goto LA80;
									asgnRefNoCycle((void**) (&(*arg).ast), copytree_196028(def));
								}
								LA80: ;
								{
									NIM_BOOL LOC84;
									LOC84 = 0;
									LOC84 = containsorincl_188898((&check), (*(*arg).name).Sup.id);
									if (!LOC84) goto LA85;
									localerror_166155((*(*a).kindU.S6.sons->data[j_421517]).info, ((NU16) 40), (*(*arg).name).s);
								}
								LA85: ;
								LOC87 = 0;
								LOC87 = newsymnode_193325(arg);
								addson_193819((*result).n, LOC87);
								rawaddson_195478(result, finaltype);
								addparamorresult_412885(c, arg, kind);
								{
									if (!(gcmd_155130 == ((NU8) 7))) goto LA90;
								}
								LA90: ;
								res_421770 += ((NI) 1);
							} LA70: ;
						}
					}
				} LA12: ;
				res_421777 += ((NI) 1);
			} LA11: ;
		}
	}
	r = 0;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA94;
		r = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
	}
	goto LA92;
	LA94: ;
	{
		if (!(kind == ((NU8) 14))) goto LA97;
		r = newtypes_245218(((NU8) 6), c);
	}
	goto LA92;
	LA97: ;
	LA92: ;
	{
		if (!!((r == NIM_NIL))) goto LA101;
		{
			Ttype191849* LOC105;
			LOC105 = 0;
			LOC105 = skiptypes_195167(r, 2048);
			if (!!(((*LOC105).kind == ((NU8) 3)))) goto LA106;
			{
				if (!!(((*r).kind == ((NU8) 6)))) goto LA110;
				{
					NIM_BOOL LOC114;
					Ttype191849* lifted;
					LOC114 = 0;
					LOC114 = ((*r).sym == NIM_NIL);
					if (LOC114) goto LA115;
					LOC114 = !((((*(*r).sym).flags &(1<<((((NU8) 29))&31)))!=0));
					LA115: ;
					if (!LOC114) goto LA116;
					lifted = liftparamtype_420279(c, kind, genericparams, r, ((NimStringDesc*) &TMP3013), (*(*n).kindU.S6.sons->data[((NI) 0)]).info, NIM_FALSE);
					{
						if (!!((lifted == NIM_NIL))) goto LA120;
						r = lifted;
					}
					LA120: ;
					(*r).flags |= ((NI32)1)<<((((NU8) 10))%(sizeof(NI32)*8));
				}
				LA116: ;
				r = skipintlit_239698(r);
				{
					if (!(kind == ((NU8) 14))) goto LA124;
					{
						NIM_BOOL LOC128;
						Ttypeseq191845* LOC131;
						TY350187 LOC132;
						LOC128 = 0;
						LOC128 = isinlineiterator_349999(r);
						if (!!(LOC128)) goto LA129;
						LOC131 = 0;
						LOC131 = (Ttypeseq191845*) newSeq((&NTI191845), 1);
						memset((void*)LOC132, 0, sizeof(LOC132));
						LOC132[0] = r;
						asgnRefNoCycle((void**) (&LOC131->data[0]), LOC132[0]);
						r = newtypewithsons_245807(c, ((NU8) 49), LOC131);
					}
					LA129: ;
				}
				LA124: ;
			}
			LA110: ;
			asgnRefNoCycle((void**) (&(*result).sons->data[((NI) 0)]), r);
			asgnRefNoCycle((void**) (&(*(*result).n).typ), r);
		}
		LA106: ;
	}
	LA101: ;
	{
		if (!!((genericparams == NIM_NIL))) goto LA135;
		{
			Tnode191813* n_421734;
			n_421734 = 0;
			{
				NI i_421786;
				NI HEX3Atmp_421788;
				NI LOC139;
				NI res_421790;
				i_421786 = 0;
				HEX3Atmp_421788 = 0;
				LOC139 = 0;
				LOC139 = len_192097(genericparams);
				HEX3Atmp_421788 = (LOC139 - 1);
				res_421790 = ((NI) 0);
				{
					while (1) {
						if (!(res_421790 <= HEX3Atmp_421788)) goto LA141;
						i_421786 = res_421790;
						n_421734 = (*genericparams).kindU.S6.sons->data[i_421786];
						{
							if (!(((*(*(*n_421734).kindU.S4.sym).typ).flags &(1<<((((NU8) 25))&31)))!=0)) goto LA144;
							(*(*n_421734).kindU.S4.sym).kind = ((NU8) 7);
							(*(*(*n_421734).kindU.S4.sym).typ).flags &= ~(((NI32)1) << ((((NU8) 25)) % (sizeof(NI32)*8)));
						}
						LA144: ;
						res_421790 += ((NI) 1);
					} LA141: ;
				}
			}
		}
	}
	LA135: ;
	return result;
}

N_NIMCALL(void, semparamlist_410284)(Tcontext245023* c, Tnode191813* n, Tnode191813* genericparams, Tsym191843* s) {
	asgnRefNoCycle((void**) (&(*s).typ), semproctypenode_421351(c, n, genericparams, NIM_NIL, (*s).kind, NIM_FALSE));
	{
		if (!!(((393216 &(1<<(((*s).kind)&31)))!=0))) goto LA3;
		{
			NIM_BOOL LOC7;
			LOC7 = 0;
			LOC7 = !(((*(*s).typ).sons->data[((NI) 0)] == NIM_NIL));
			if (!(LOC7)) goto LA8;
			LOC7 = ((*(*(*s).typ).sons->data[((NI) 0)]).kind == ((NU8) 7));
			LA8: ;
			if (!LOC7) goto LA9;
			localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3146));
		}
		LA9: ;
	}
	LA3: ;
}

N_NIMCALL(Tnode191813*, newparam_426884)(Templctx423582* c, Tnode191813* n, Tsym191843* s) {
	Tnode191813* result;
	Tsym191843* x;
	result = 0;
	(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
	x = (*(*(*(*(*c).owner).typ).n).kindU.S6.sons->data[(NI)((*s).position + ((NI) 1))]).kindU.S4.sym;
	result = newsymnode_193338(x, (*n).info);
	return result;
}

N_NIMCALL(Tnode191813*, handlesym_427201)(Templctx423582* c, Tnode191813* n, Tsym191843* s) {
	Tnode191813* result;
	result = 0;
	result = n;
	{
		if (!!((s == NIM_NIL))) goto LA3;
		{
			NIM_BOOL LOC7;
			LOC7 = 0;
			LOC7 = ((*s).owner == (*c).owner);
			if (!(LOC7)) goto LA8;
			LOC7 = ((*s).kind == ((NU8) 3));
			LA8: ;
			if (!LOC7) goto LA9;
			result = newparam_426884(c, n, s);
		}
		goto LA5;
		LA9: ;
		{
			NIM_BOOL LOC12;
			LOC12 = 0;
			LOC12 = contains_188829((&(*c).tobind), (*s).Sup.id);
			if (!LOC12) goto LA13;
			result = symchoice_423316((*c).c, n, s, ((NU8) 0));
		}
		goto LA5;
		LA13: ;
		{
			NIM_BOOL LOC16;
			NIM_BOOL LOC18;
			NI LOC19;
			Tnode191813* LOC23;
			LOC16 = 0;
			LOC16 = ((*s).kind == ((NU8) 18));
			if (!(LOC16)) goto LA17;
			LOC18 = 0;
			LOC19 = 0;
			LOC19 = len_194377((*s).typ);
			LOC18 = (LOC19 == ((NI) 1));
			if (LOC18) goto LA20;
			LOC18 = (((*s).flags &(1<<((((NU8) 25))&31)))!=0);
			LA20: ;
			LOC16 = LOC18;
			LA17: ;
			if (!LOC16) goto LA21;
			LOC23 = 0;
			LOC23 = semtemplateexpr_411055((*c).c, n, s, 512);
			result = sempatternbody_426870(c, LOC23);
		}
		goto LA5;
		LA21: ;
		{
		}
		LA5: ;
	}
	LA3: ;
	return result;
}

N_NIMCALL(Tnode191813*, sembindstmt_423421)(Tcontext245023* c, Tnode191813* n, Intset188056* tobind) {
	Tnode191813* result;
	result = 0;
	{
		NI i_423447;
		NI HEX3Atmp_423490;
		NI LOC2;
		NI res_423493;
		i_423447 = 0;
		HEX3Atmp_423490 = 0;
		LOC2 = 0;
		LOC2 = len_192097(n);
		HEX3Atmp_423490 = (LOC2 - 1);
		res_423493 = ((NI) 0);
		{
			while (1) {
				Tnode191813* a;
				Tsym191843* s;
				if (!(res_423493 <= HEX3Atmp_423490)) goto LA4;
				i_423447 = res_423493;
				a = (*n).kindU.S6.sons->data[i_423447];
				s = qualifiedlookup_250864(c, a, 2);
				{
					Tnode191813* sc;
					if (!!((s == NIM_NIL))) goto LA7;
					sc = symchoice_423316(c, n, s, ((NU8) 0));
					{
						if (!((*sc).kind == ((NU8) 3))) goto LA11;
						incl_188856(tobind, (*(*sc).kindU.S4.sym).Sup.id);
					}
					goto LA9;
					LA11: ;
					{
						{
							Tnode191813* x_423475;
							x_423475 = 0;
							{
								NI i_423483;
								NI HEX3Atmp_423485;
								NI LOC16;
								NI res_423487;
								i_423483 = 0;
								HEX3Atmp_423485 = 0;
								LOC16 = 0;
								LOC16 = len_192097(sc);
								HEX3Atmp_423485 = (LOC16 - 1);
								res_423487 = ((NI) 0);
								{
									while (1) {
										if (!(res_423487 <= HEX3Atmp_423485)) goto LA18;
										i_423483 = res_423487;
										x_423475 = (*sc).kindU.S6.sons->data[i_423483];
										incl_188856(tobind, (*(*x_423475).kindU.S4.sym).Sup.id);
										res_423487 += ((NI) 1);
									} LA18: ;
								}
							}
						}
					}
					LA9: ;
				}
				goto LA5;
				LA7: ;
				{
					illformedast_246229(a);
				}
				LA5: ;
				res_423493 += ((NI) 1);
			} LA4: ;
		}
	}
	result = newnodei_193351(((NU8) 1), (*n).info);
	return result;
}

N_NIMCALL(Tnode191813*, expectparam_427264)(Templctx423582* c, Tnode191813* n) {
	Tnode191813* result;
	Tsym191843* s;
	result = 0;
	s = qualifiedlookup_250864((*c).c, n, 0);
	{
		NIM_BOOL LOC3;
		NIM_BOOL LOC4;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = !((s == NIM_NIL));
		if (!(LOC4)) goto LA5;
		LOC4 = ((*s).owner == (*c).owner);
		LA5: ;
		LOC3 = LOC4;
		if (!(LOC3)) goto LA6;
		LOC3 = ((*s).kind == ((NU8) 3));
		LA6: ;
		if (!LOC3) goto LA7;
		result = newparam_426884(c, n, s);
	}
	goto LA1;
	LA7: ;
	{
		localerror_166155((*n).info, ((NU16) 167), ((NimStringDesc*) &TMP2991));
		result = n;
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, sempatternbody_426870)(Templctx423582* c, Tnode191813* n) {
	Tnode191813* result;
{	result = 0;
	result = n;
	switch ((*n).kind) {
	case ((NU8) 2):
	{
		Tsym191843* s;
		s = qualifiedlookup_250864((*c).c, n, 0);
		result = handlesym_427201(c, n, s);
	}
	break;
	case ((NU8) 122):
	{
		result = sembindstmt_423421((*c).c, n, (&(*c).tobind));
	}
	break;
	case ((NU8) 1):
	case ((NU8) 3) ... ((NU8) 23):
	{
	}
	break;
	case ((NU8) 40):
	{
		{
			NI LOC7;
			LOC7 = 0;
			LOC7 = len_192097(n);
			if (!!((LOC7 == ((NI) 2)))) goto LA8;
			localerror_166155((*n).info, ((NU16) 167), ((NimStringDesc*) &TMP2991));
		}
		goto LA5;
		LA8: ;
		{
			if (!((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 2))) goto LA11;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), sempatternbody_426870(c, (*n).kindU.S6.sons->data[((NI) 0)]));
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), expectparam_427264(c, (*n).kindU.S6.sons->data[((NI) 1)]));
		}
		goto LA5;
		LA11: ;
		{
			NIM_BOOL LOC14;
			Tnode191813* opr;
			LOC14 = 0;
			LOC14 = ((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 30));
			if (!(LOC14)) goto LA15;
			LOC14 = ((*(*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 2));
			LA15: ;
			if (!LOC14) goto LA16;
			opr = (*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S6.sons->data[((NI) 0)];
			{
				if (!eqStrings((*(*opr).kindU.S5.ident).s, ((NimStringDesc*) &TMP2993))) goto LA20;
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), sempatternbody_426870(c, (*n).kindU.S6.sons->data[((NI) 0)]));
				asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S6.sons->data[((NI) 1)]), expectparam_427264(c, (*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S6.sons->data[((NI) 1)]));
			}
			goto LA18;
			LA20: ;
			{
				localerror_166155((*n).info, ((NU16) 167), ((NimStringDesc*) &TMP2991));
			}
			LA18: ;
		}
		goto LA5;
		LA16: ;
		{
			localerror_166155((*n).info, ((NU16) 167), ((NimStringDesc*) &TMP2991));
		}
		LA5: ;
	}
	break;
	case ((NU8) 27):
	case ((NU8) 29):
	case ((NU8) 30):
	case ((NU8) 31):
	case ((NU8) 26):
	case ((NU8) 28):
	case ((NU8) 32):
	{
		Tsym191843* s;
		s = qualifiedlookup_250864((*c).c, (*n).kindU.S6.sons->data[((NI) 0)], 0);
		{
			if (!!((s == NIM_NIL))) goto LA27;
			{
				NIM_BOOL LOC31;
				LOC31 = 0;
				LOC31 = ((*s).owner == (*c).owner);
				if (!(LOC31)) goto LA32;
				LOC31 = ((*s).kind == ((NU8) 3));
				LA32: ;
				if (!LOC31) goto LA33;
			}
			goto LA29;
			LA33: ;
			{
				NIM_BOOL LOC36;
				LOC36 = 0;
				LOC36 = contains_188829((&(*c).tobind), (*s).Sup.id);
				if (!LOC36) goto LA37;
			}
			goto LA29;
			LA37: ;
			{
				NIM_BOOL LOC40;
				NIM_BOOL LOC42;
				NI LOC43;
				Tnode191813* LOC47;
				LOC40 = 0;
				LOC40 = ((*s).kind == ((NU8) 18));
				if (!(LOC40)) goto LA41;
				LOC42 = 0;
				LOC43 = 0;
				LOC43 = len_194377((*s).typ);
				LOC42 = (LOC43 == ((NI) 1));
				if (LOC42) goto LA44;
				LOC42 = (((*s).flags &(1<<((((NU8) 25))&31)))!=0);
				LA44: ;
				LOC40 = LOC42;
				LA41: ;
				if (!LOC40) goto LA45;
				LOC47 = 0;
				LOC47 = semtemplateexpr_411055((*c).c, n, s, 512);
				result = sempatternbody_426870(c, LOC47);
				goto BeforeRet;
			}
			goto LA29;
			LA45: ;
			LA29: ;
		}
		LA27: ;
		{
			NIM_BOOL LOC50;
			Tnode191813* opr;
			LOC50 = 0;
			LOC50 = ((*n).kind == ((NU8) 29));
			if (!(LOC50)) goto LA51;
			LOC50 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 2));
			LA51: ;
			if (!LOC50) goto LA52;
			opr = (*n).kindU.S6.sons->data[((NI) 0)];
			{
				NIM_BOOL LOC56;
				NI LOC60;
				LOC56 = 0;
				LOC56 = eqStrings((*(*opr).kindU.S5.ident).s, ((NimStringDesc*) &TMP3147));
				if (LOC56) goto LA57;
				LOC56 = eqStrings((*(*opr).kindU.S5.ident).s, ((NimStringDesc*) &TMP3148));
				LA57: ;
				if (!LOC56) goto LA58;
				LOC60 = 0;
				LOC60 = len_192097(n);
				result = newnodei_193407(((NU8) 153), (*n).info, LOC60);
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), opr);
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), sempatternbody_426870(c, (*n).kindU.S6.sons->data[((NI) 1)]));
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 2)]), expectparam_427264(c, (*n).kindU.S6.sons->data[((NI) 2)]));
				goto BeforeRet;
			}
			goto LA54;
			LA58: ;
			{
				NI LOC64;
				if (!eqStrings((*(*opr).kindU.S5.ident).s, ((NimStringDesc*) &TMP2993))) goto LA62;
				LOC64 = 0;
				LOC64 = len_192097(n);
				result = newnodei_193407(((NU8) 153), (*n).info, LOC64);
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), opr);
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), sempatternbody_426870(c, (*n).kindU.S6.sons->data[((NI) 1)]));
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 2)]), sempatternbody_426870(c, (*n).kindU.S6.sons->data[((NI) 2)]));
				goto BeforeRet;
			}
			goto LA54;
			LA62: ;
			LA54: ;
		}
		LA52: ;
		{
			NIM_BOOL LOC67;
			Tnode191813* opr;
			LOC67 = 0;
			LOC67 = ((*n).kind == ((NU8) 30));
			if (!(LOC67)) goto LA68;
			LOC67 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 2));
			LA68: ;
			if (!LOC67) goto LA69;
			opr = (*n).kindU.S6.sons->data[((NI) 0)];
			{
				NI LOC75;
				if (!eqStrings((*(*opr).kindU.S5.ident).s, ((NimStringDesc*) &TMP3149))) goto LA73;
				LOC75 = 0;
				LOC75 = len_192097(n);
				result = newnodei_193407(((NU8) 153), (*n).info, LOC75);
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), opr);
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), sempatternbody_426870(c, (*n).kindU.S6.sons->data[((NI) 1)]));
				goto BeforeRet;
			}
			LA73: ;
		}
		LA69: ;
		{
			NI i_427490;
			NI HEX3Atmp_427528;
			NI LOC77;
			NI res_427531;
			i_427490 = 0;
			HEX3Atmp_427528 = 0;
			LOC77 = 0;
			LOC77 = sonslen_194403(n);
			HEX3Atmp_427528 = (NI)(LOC77 - ((NI) 1));
			res_427531 = ((NI) 0);
			{
				while (1) {
					if (!(res_427531 <= HEX3Atmp_427528)) goto LA79;
					i_427490 = res_427531;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_427490]), sempatternbody_426870(c, (*n).kindU.S6.sons->data[i_427490]));
					res_427531 += ((NI) 1);
				} LA79: ;
			}
		}
	}
	break;
	default:
	{
		switch ((*n).kind) {
		case ((NU8) 45):
		case ((NU8) 53):
		{
			Tsym191843* s;
			s = qualifiedlookup_250864((*c).c, n, 0);
			{
				if (!!((s == NIM_NIL))) goto LA84;
				{
					NIM_BOOL LOC88;
					LOC88 = 0;
					LOC88 = contains_188829((&(*c).tobind), (*s).Sup.id);
					if (!LOC88) goto LA89;
					result = symchoice_423316((*c).c, n, s, ((NU8) 0));
					goto BeforeRet;
				}
				goto LA86;
				LA89: ;
				{
					result = newidentnode_193313((*s).name, (*n).info);
					goto BeforeRet;
				}
				LA86: ;
			}
			LA84: ;
		}
		break;
		case ((NU8) 37):
		{
			{
				NI LOC95;
				LOC95 = 0;
				LOC95 = len_192097(n);
				if (!(LOC95 == ((NI) 1))) goto LA96;
				result = sempatternbody_426870(c, (*n).kindU.S6.sons->data[((NI) 0)]);
				goto BeforeRet;
			}
			LA96: ;
		}
		break;
		default:
		{
		}
		break;
		}
		{
			NI i_427524;
			NI HEX3Atmp_427536;
			NI LOC100;
			NI res_427539;
			i_427524 = 0;
			HEX3Atmp_427536 = 0;
			LOC100 = 0;
			LOC100 = sonslen_194403(n);
			HEX3Atmp_427536 = (NI)(LOC100 - ((NI) 1));
			res_427539 = ((NI) 0);
			{
				while (1) {
					if (!(res_427539 <= HEX3Atmp_427536)) goto LA102;
					i_427524 = res_427539;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_427524]), sempatternbody_426870(c, (*n).kindU.S6.sons->data[i_427524]));
					res_427539 += ((NI) 1);
				} LA102: ;
			}
		}
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, sempattern_424548)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tscope191837* LOC1;
	Templctx423582 ctx;
	Tnode191813* LOC2;
	result = 0;
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	memset((void*)(&ctx), 0, sizeof(ctx));
	initintset_188927((&ctx.tobind));
	initintset_188927((&ctx.tomixin));
	initintset_188927((&ctx.toinject));
	ctx.c = c;
	ctx.owner = getcurrowner_245255();
	LOC2 = 0;
	LOC2 = sempatternbody_426870((&ctx), n);
	result = flattenstmts_220759(LOC2);
	{
		if (!((*result).kind == ((NU8) 115) || (*result).kind == ((NU8) 126))) goto LA5;
		{
			NI LOC9;
			LOC9 = 0;
			LOC9 = len_192097(result);
			if (!(LOC9 == ((NI) 1))) goto LA10;
			result = (*result).kindU.S6.sons->data[((NI) 0)];
		}
		goto LA7;
		LA10: ;
		{
			NI LOC13;
			LOC13 = 0;
			LOC13 = len_192097(result);
			if (!(LOC13 == ((NI) 0))) goto LA14;
			localerror_166155((*n).info, ((NU16) 167), ((NimStringDesc*) &TMP2991));
		}
		goto LA7;
		LA14: ;
		LA7: ;
	}
	LA5: ;
	closescope_250111(c);
	return result;
}

N_NIMCALL(void, addgenericparamlisttoscope_438141)(Tcontext245023* c, Tnode191813* n) {
	{
		if (!!(((*n).kind == ((NU8) 75)))) goto LA3;
		illformedast_246229(n);
	}
	LA3: ;
	{
		NI i_438166;
		NI HEX3Atmp_438180;
		NI LOC6;
		NI res_438183;
		i_438166 = 0;
		HEX3Atmp_438180 = 0;
		LOC6 = 0;
		LOC6 = sonslen_194403(n);
		HEX3Atmp_438180 = (NI)(LOC6 - ((NI) 1));
		res_438183 = ((NI) 0);
		{
			while (1) {
				Tnode191813* a;
				if (!(res_438183 <= HEX3Atmp_438180)) goto LA8;
				i_438166 = res_438183;
				a = (*n).kindU.S6.sons->data[i_438166];
				{
					if (!((*a).kind == ((NU8) 3))) goto LA11;
					adddecl_250607(c, (*a).kindU.S4.sym);
				}
				goto LA9;
				LA11: ;
				{
					illformedast_246229(a);
				}
				LA9: ;
				res_438183 += ((NI) 1);
			} LA8: ;
		}
	}
}

N_NIMCALL(void, addparams_410293)(Tcontext245023* c, Tnode191813* n, NU8 kind) {
	{
		NI i_438942;
		NI HEX3Atmp_438956;
		NI LOC2;
		NI res_438959;
		i_438942 = 0;
		HEX3Atmp_438956 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_438956 = (NI)(LOC2 - ((NI) 1));
		res_438959 = ((NI) 1);
		{
			while (1) {
				if (!(res_438959 <= HEX3Atmp_438956)) goto LA4;
				i_438942 = res_438959;
				{
					if (!((*(*n).kindU.S6.sons->data[i_438942]).kind == ((NU8) 3))) goto LA7;
					addparamorresult_412885(c, (*(*n).kindU.S6.sons->data[i_438942]).kindU.S4.sym, kind);
				}
				goto LA5;
				LA7: ;
				{
					illformedast_246229(n);
				}
				LA5: ;
				res_438959 += ((NI) 1);
			} LA4: ;
		}
	}
}

static N_INLINE(NIM_BOOL, importantcomments_155164)(void) {
	NIM_BOOL result;
	result = 0;
	result = ((16640 &(1<<((gcmd_155130)&31)))!=0);
	return result;
}

static N_INLINE(NI, find_433063)(Tsym191843** a, NI aLen0, Tsym191843* item) {
	NI result;
{	result = 0;
	{
		Tsym191843* i_433107;
		NI i_433131;
		i_433107 = 0;
		i_433131 = ((NI) 0);
		{
			while (1) {
				if (!(i_433131 < aLen0)) goto LA3;
				i_433107 = a[i_433131];
				{
					if (!(i_433107 == item)) goto LA6;
					goto BeforeRet;
				}
				LA6: ;
				result += ((NI) 1);
				i_433131 += ((NI) 1);
			} LA3: ;
		}
	}
	result = ((NI) -1);
	}BeforeRet: ;
	return result;
}

static N_INLINE(NIM_BOOL, contains_433053)(Tsym191843** a, NI aLen0, Tsym191843* item) {
	NIM_BOOL result;
	NI LOC1;
{	result = 0;
	LOC1 = 0;
	LOC1 = find_433063(a, aLen0, item);
	result = (((NI) 0) <= LOC1);
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

static N_INLINE(Slice85773, HEX2EHEX2E_105273)(NI a, NI b) {
	Slice85773 result;
	memset((void*)(&result), 0, sizeof(result));
	result.a = a;
	result.b = b;
	return result;
}

N_NIMCALL(Tnode191813*, destroycase_432652)(Tcontext245023* c, Tnode191813* n, Tnode191813* holder) {
	Tnode191813* result;
	NI nontrivialfields;
	Tnodeseq191807* LOC1;
	Tnodeseq191807* LOC2;
	TY246103 LOC3;
	Tnode191813* LOC4;
	result = 0;
	nontrivialfields = ((NI) 0);
	LOC1 = 0;
	LOC1 = (Tnodeseq191807*) newSeq((&NTI191807), 0);
	result = newnode_193607(((NU8) 97), (*n).info, LOC1, NIM_NIL);
	LOC2 = 0;
	LOC2 = (Tnodeseq191807*) newSeq((&NTI191807), 2);
	memset((void*)LOC3, 0, sizeof(LOC3));
	LOC3[0] = holder;
	LOC3[1] = (*n).kindU.S6.sons->data[((NI) 0)];
	asgnRefNoCycle((void**) (&LOC2->data[0]), LOC3[0]);
	asgnRefNoCycle((void**) (&LOC2->data[1]), LOC3[1]);
	LOC4 = 0;
	LOC4 = newnode_193607(((NU8) 45), (*n).info, LOC2, NIM_NIL);
	addson_193819(result, LOC4);
	{
		NI i_432702;
		NI HEX3Atmp_432823;
		NI LOC6;
		NI res_432826;
		i_432702 = 0;
		HEX3Atmp_432823 = 0;
		LOC6 = 0;
		LOC6 = len_192097(n);
		HEX3Atmp_432823 = (NI)(LOC6 - ((NI) 1));
		res_432826 = ((NI) 1);
		{
			while (1) {
				Tnode191813* ni;
				Tnode191813* casebranch;
				NI LOC9;
				Slice85773 LOC10;
				Tnodeseq191807* LOC11;
				Tnode191813* stmt;
				Tnode191813* LOC12;
				if (!(res_432826 <= HEX3Atmp_432823)) goto LA8;
				i_432702 = res_432826;
				ni = HEX5BHEX5D_192244(n, i_432702);
				LOC9 = 0;
				LOC9 = len_192097(ni);
				LOC10 = HEX2EHEX2E_105273(((NI) 0), (NI)(LOC9 - ((NI) 2)));
				LOC11 = 0;
				LOC11 = HEX5BHEX5D_432717((*ni).kindU.S6.sons, LOC10);
				casebranch = newnode_193607((*ni).kind, (*ni).info, LOC11, NIM_NIL);
				LOC12 = 0;
				LOC12 = lastson_194431(ni);
				stmt = destroyfieldorfields_432596(c, LOC12, holder);
				{
					Tnodeseq191807* LOC17;
					Tnode191813* LOC18;
					if (!(stmt == NIM_NIL)) goto LA15;
					LOC17 = 0;
					LOC17 = (Tnodeseq191807*) newSeq((&NTI191807), 0);
					LOC18 = 0;
					LOC18 = newnode_193607(((NU8) 115), (*ni).info, LOC17, NIM_NIL);
					addson_193819(casebranch, LOC18);
				}
				goto LA13;
				LA15: ;
				{
					NI LOC20;
					addson_193819(casebranch, stmt);
					LOC20 = 0;
					LOC20 = len_192097(stmt);
					nontrivialfields += LOC20;
				}
				LA13: ;
				addson_193819(result, casebranch);
				res_432826 += ((NI) 1);
			} LA8: ;
		}
	}
	{
		if (!(nontrivialfields == ((NI) 0))) goto LA23;
		result = NIM_NIL;
	}
	LA23: ;
	return result;
}

N_NIMCALL(Tnode191813*, destroysym_432601)(Tcontext245023* c, Tsym191843* field, Tnode191813* holder) {
	Tnode191813* result;
	Ttype191849* destructablet;
	result = 0;
	destructablet = instantiatedestructor_432423(c, (*field).typ);
	{
		Tnodeseq191807* LOC5;
		TY246103 LOC6;
		Tnodeseq191807* LOC7;
		TY246103 LOC8;
		if (!!((destructablet == NIM_NIL))) goto LA3;
		LOC5 = 0;
		LOC5 = (Tnodeseq191807*) newSeq((&NTI191807), 2);
		memset((void*)LOC6, 0, sizeof(LOC6));
		LOC6[0] = usesym_355055((*destructablet).destructor);
		LOC7 = 0;
		LOC7 = (Tnodeseq191807*) newSeq((&NTI191807), 2);
		memset((void*)LOC8, 0, sizeof(LOC8));
		LOC8[0] = holder;
		LOC8[1] = usesym_355055(field);
		asgnRefNoCycle((void**) (&LOC7->data[0]), LOC8[0]);
		asgnRefNoCycle((void**) (&LOC7->data[1]), LOC8[1]);
		LOC6[1] = newnode_193607(((NU8) 45), (*field).info, LOC7, NIM_NIL);
		asgnRefNoCycle((void**) (&LOC5->data[0]), LOC6[0]);
		asgnRefNoCycle((void**) (&LOC5->data[1]), LOC6[1]);
		result = newnode_193607(((NU8) 27), (*field).info, LOC5, NIM_NIL);
	}
	LA3: ;
	return result;
}

N_NIMCALL(Tnode191813*, destroyfieldorfields_432596)(Tcontext245023* c, Tnode191813* field, Tnode191813* holder) {
	Tnode191813* result;
	result = 0;
	switch ((*field).kind) {
	case ((NU8) 139):
	{
		Tnode191813* stmt_432855;
		stmt_432855 = destroycase_432652(c, field, holder);
		{
			if (!!((stmt_432855 == NIM_NIL))) goto LA4;
			{
				if (!(result == NIM_NIL)) goto LA8;
				result = newnode_192401(((NU8) 115));
			}
			LA8: ;
			addson_193819(result, stmt_432855);
		}
		LA4: ;
	}
	break;
	case ((NU8) 3):
	{
		Tnode191813* stmt_432882;
		stmt_432882 = destroysym_432601(c, (*field).kindU.S4.sym, holder);
		{
			if (!!((stmt_432882 == NIM_NIL))) goto LA13;
			{
				if (!(result == NIM_NIL)) goto LA17;
				result = newnode_192401(((NU8) 115));
			}
			LA17: ;
			addson_193819(result, stmt_432882);
		}
		LA13: ;
	}
	break;
	case ((NU8) 138):
	{
		{
			Tnode191813* son_432909;
			son_432909 = 0;
			{
				NI i_432948;
				NI HEX3Atmp_432950;
				NI LOC22;
				NI res_432952;
				i_432948 = 0;
				HEX3Atmp_432950 = 0;
				LOC22 = 0;
				LOC22 = len_192097(field);
				HEX3Atmp_432950 = (LOC22 - 1);
				res_432952 = ((NI) 0);
				{
					while (1) {
						Tnode191813* stmt_432911;
						if (!(res_432952 <= HEX3Atmp_432950)) goto LA24;
						i_432948 = res_432952;
						son_432909 = (*field).kindU.S6.sons->data[i_432948];
						stmt_432911 = destroyfieldorfields_432596(c, son_432909, holder);
						{
							if (!!((stmt_432911 == NIM_NIL))) goto LA27;
							{
								if (!(result == NIM_NIL)) goto LA31;
								result = newnode_192401(((NU8) 115));
							}
							LA31: ;
							addson_193819(result, stmt_432911);
						}
						LA27: ;
						res_432952 += ((NI) 1);
					} LA24: ;
				}
			}
		}
	}
	break;
	default:
	{
		{
			NimStringDesc* LOC38;
			if (!NIM_TRUE) goto LA36;
			LOC38 = 0;
			LOC38 = HEX24_166306(TMP3164);
			internalerror_166218(LOC38);
		}
		LA36: ;
	}
	break;
	}
	return result;
}

N_NIMCALL(Tnode191813*, generatedestructor_432970)(Tcontext245023* c, Ttype191849* t) {
	Tnode191813* result;
	Tnode191813* destructedobj;
	Tlineinfo164338 LOC12;
{	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = ((*t).n == NIM_NIL);
		if (LOC3) goto LA4;
		LOC3 = HEX3DHEX3D_264718((*(*t).n).kindU.S6.sons, NIM_NIL);
		LA4: ;
		if (!LOC3) goto LA5;
		goto BeforeRet;
	}
	LA5: ;
	{
		NimStringDesc* LOC11;
		if (!!(((*(*t).n).kind == ((NU8) 138)))) goto LA9;
		LOC11 = 0;
		LOC11 = HEX24_166306(TMP3162);
		internalerror_166218(LOC11);
	}
	LA9: ;
	LOC12 = unknownlineinfo_165024();
	destructedobj = newidentnode_193313(destructorparam_432420, LOC12);
	result = destroyfieldorfields_432596(c, (*t).n, destructedobj);
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tsym191843*, symfromtype_411078)(Ttype191849* t, Tlineinfo164338 info) {
	Tsym191843* result;
	Tident168021* LOC5;
{	result = 0;
	{
		if (!!(((*t).sym == NIM_NIL))) goto LA3;
		result = (*t).sym;
		goto BeforeRet;
	}
	LA3: ;
	LOC5 = 0;
	LOC5 = getident_168463(((NimStringDesc*) &TMP3166));
	result = newsym_192655(((NU8) 7), LOC5, (*t).owner, info);
	(*result).flags |= ((NI32)1)<<((((NU8) 29))%(sizeof(NI32)*8));
	asgnRefNoCycle((void**) (&(*result).typ), t);
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, symnodefromtype_411113)(Tcontext245023* c, Ttype191849* t, Tlineinfo164338 info) {
	Tnode191813* result;
	Tsym191843* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = symfromtype_411078(t, info);
	result = newsymnode_193338(LOC1, info);
	asgnRefNoCycle((void**) (&(*result).typ), maketypedesc_245681(c, t));
	return result;
}

N_NIMCALL(Tnode191813*, semproc_432397)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = semprocaux_439890(c, n, ((NU8) 12), TMP3167, ((NU8) 0));
	return result;
}

N_NIMCALL(Ttype191849*, instantiatedestructor_432423)(Tcontext245023* c, Ttype191849* typ) {
	Ttype191849* result;
	Ttype191849* t;
	Ttype191849* LOC1;
	Ttype191849* typeholdinguserdefinition;
{	result = 0;
	LOC1 = 0;
	LOC1 = skiptypes_195167(typ, IL64(211106232532992));
	t = skipgenericalias_227119(LOC1);
	{
		if (!((*t).kind == ((NU8) 11))) goto LA4;
		typeholdinguserdefinition = base_221039(t);
	}
	goto LA2;
	LA4: ;
	{
		typeholdinguserdefinition = t;
	}
	LA2: ;
	{
		if (!!(((*typeholdinguserdefinition).destructor == NIM_NIL))) goto LA9;
		{
			TY433049 LOC13;
			NIM_BOOL LOC14;
			memset((void*)LOC13, 0, sizeof(LOC13));
			LOC13[0] = analyzingdestructor_432401;
			LOC13[1] = destructoristrivial_432402;
			LOC14 = 0;
			LOC14 = contains_433053(LOC13, 2, (*typeholdinguserdefinition).destructor);
			if (!!(LOC14)) goto LA15;
			result = typeholdinguserdefinition;
			goto BeforeRet;
		}
		goto LA11;
		LA15: ;
		{
			result = NIM_NIL;
			goto BeforeRet;
		}
		LA11: ;
	}
	LA9: ;
	t = skiptypes_195167(t, 2048);
	switch ((*t).kind) {
	case ((NU8) 24):
	case ((NU8) 16):
	case ((NU8) 4):
	case ((NU8) 27):
	case ((NU8) 48):
	{
		{
			Ttype191849* LOC21;
			LOC21 = 0;
			LOC21 = instantiatedestructor_432423(c, (*t).sons->data[((NI) 0)]);
			if (!!((LOC21 == NIM_NIL))) goto LA22;
			{
				Tident168021* LOC28;
				if (!(rangedestructorproc_432422 == NIM_NIL)) goto LA26;
				LOC28 = 0;
				LOC28 = getident_168463(((NimStringDesc*) &TMP3161));
				asgnRefNoCycle((void**) (&rangedestructorproc_432422), searchinscopes_250205(c, LOC28));
			}
			LA26: ;
			asgnRefNoCycle((void**) (&(*t).destructor), rangedestructorproc_432422);
			result = t;
			goto BeforeRet;
		}
		goto LA19;
		LA22: ;
		{
			result = NIM_NIL;
			goto BeforeRet;
		}
		LA19: ;
	}
	break;
	case ((NU8) 18):
	case ((NU8) 17):
	{
		Tnode191813* generated;
		asgnRefNoCycle((void**) (&(*t).destructor), analyzingdestructor_432401);
		generated = generatedestructor_432970(c, t);
		{
			Tlineinfo164338 i;
			Tnode191813* fulldef;
			Tnodeseq191807* LOC40;
			TY194071 LOC41;
			Tnodeseq191807* LOC42;
			TY246103 LOC43;
			Tnodeseq191807* LOC44;
			TY447930 LOC45;
			Ttype191849* LOC46;
			Tnodeseq191807* LOC47;
			TY209680 LOC48;
			Tnode191813* semantizeddef;
			Tnode191813* LOC49;
			if (!!((generated == NIM_NIL))) goto LA33;
			{
				NimStringDesc* LOC39;
				if (!!(!(((*t).sym == NIM_NIL)))) goto LA37;
				LOC39 = 0;
				LOC39 = HEX24_166306(TMP3165);
				internalerror_166218(LOC39);
			}
			LA37: ;
			i = (*(*t).sym).info;
			LOC40 = 0;
			LOC40 = (Tnodeseq191807*) newSeq((&NTI191807), 7);
			memset((void*)LOC41, 0, sizeof(LOC41));
			LOC41[0] = newidentnode_193313(destructorname_432419, i);
			LOC41[1] = emptynode_192807;
			LOC41[2] = emptynode_192807;
			LOC42 = 0;
			LOC42 = (Tnodeseq191807*) newSeq((&NTI191807), 2);
			memset((void*)LOC43, 0, sizeof(LOC43));
			LOC43[0] = emptynode_192807;
			LOC44 = 0;
			LOC44 = (Tnodeseq191807*) newSeq((&NTI191807), 3);
			memset((void*)LOC45, 0, sizeof(LOC45));
			LOC45[0] = newidentnode_193313(destructorparam_432420, i);
			LOC46 = 0;
			LOC46 = makevartype_245642(c, t);
			LOC45[1] = symnodefromtype_411113(c, LOC46, (*(*t).sym).info);
			LOC45[2] = emptynode_192807;
			asgnRefNoCycle((void**) (&LOC44->data[0]), LOC45[0]);
			asgnRefNoCycle((void**) (&LOC44->data[1]), LOC45[1]);
			asgnRefNoCycle((void**) (&LOC44->data[2]), LOC45[2]);
			LOC43[1] = newnode_193607(((NU8) 35), i, LOC44, NIM_NIL);
			asgnRefNoCycle((void**) (&LOC42->data[0]), LOC43[0]);
			asgnRefNoCycle((void**) (&LOC42->data[1]), LOC43[1]);
			LOC41[3] = newnode_193607(((NU8) 76), i, LOC42, NIM_NIL);
			LOC47 = 0;
			LOC47 = (Tnodeseq191807*) newSeq((&NTI191807), 1);
			memset((void*)LOC48, 0, sizeof(LOC48));
			LOC48[0] = destructorpragma_432421;
			asgnRefNoCycle((void**) (&LOC47->data[0]), LOC48[0]);
			LOC41[4] = newnode_193607(((NU8) 90), i, LOC47, NIM_NIL);
			LOC41[5] = emptynode_192807;
			LOC41[6] = generated;
			asgnRefNoCycle((void**) (&LOC40->data[0]), LOC41[0]);
			asgnRefNoCycle((void**) (&LOC40->data[1]), LOC41[1]);
			asgnRefNoCycle((void**) (&LOC40->data[2]), LOC41[2]);
			asgnRefNoCycle((void**) (&LOC40->data[3]), LOC41[3]);
			asgnRefNoCycle((void**) (&LOC40->data[4]), LOC41[4]);
			asgnRefNoCycle((void**) (&LOC40->data[5]), LOC41[5]);
			asgnRefNoCycle((void**) (&LOC40->data[6]), LOC41[6]);
			fulldef = newnode_193607(((NU8) 79), i, LOC40, NIM_NIL);
			semantizeddef = semproc_432397(c, fulldef);
			LOC49 = 0;
			LOC49 = HEX5BHEX5D_192244(semantizeddef, ((NI) 0));
			asgnRefNoCycle((void**) (&(*t).destructor), (*LOC49).kindU.S4.sym);
			result = t;
			goto BeforeRet;
		}
		goto LA31;
		LA33: ;
		{
			asgnRefNoCycle((void**) (&(*t).destructor), destructoristrivial_432402);
			result = NIM_NIL;
			goto BeforeRet;
		}
		LA31: ;
	}
	break;
	default:
	{
		result = NIM_NIL;
		goto BeforeRet;
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, dodestructorstuff_432427)(Tcontext245023* c, Tsym191843* s, Tnode191813* n) {
	Ttype191849* t;
{	t = skiptypes_195167((*(*s).typ).sons->data[((NI) 1)], 8388608);
	{
		if (!((*t).kind == ((NU8) 9))) goto LA3;
		{
			NI i_432462;
			NI HEX3Atmp_432556;
			NI LOC6;
			NI res_432559;
			i_432462 = 0;
			HEX3Atmp_432556 = 0;
			LOC6 = 0;
			LOC6 = sonslen_194351(t);
			HEX3Atmp_432556 = (LOC6 - 1);
			res_432559 = ((NI) 1);
			{
				while (1) {
					if (!(res_432559 <= HEX3Atmp_432556)) goto LA8;
					i_432462 = res_432559;
					{
						if (!!(((*(*t).sons->data[i_432462]).kind == ((NU8) 12)))) goto LA11;
						localerror_166155((*n).info, ((NU16) 202), ((NimStringDesc*) &TMP2991));
						goto BeforeRet;
					}
					LA11: ;
					res_432559 += ((NI) 1);
				} LA8: ;
			}
		}
		t = base_221039(t);
	}
	goto LA1;
	LA3: ;
	{
		if (!((*t).kind == ((NU8) 54))) goto LA14;
		t = base_221039(t);
		{
			if (!!(((*t).kind == ((NU8) 10)))) goto LA18;
			localerror_166155((*n).info, ((NU16) 202), ((NimStringDesc*) &TMP2991));
			goto BeforeRet;
		}
		LA18: ;
	}
	goto LA1;
	LA14: ;
	LA1: ;
	asgnRefNoCycle((void**) (&(*t).destructor), s);
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 6)]).kind == ((NU8) 1)))) goto LA22;
		{
			NI i_432512;
			NI HEX3Atmp_432565;
			NI LOC25;
			NI res_432568;
			i_432512 = 0;
			HEX3Atmp_432565 = 0;
			LOC25 = 0;
			LOC25 = sonslen_194351(t);
			HEX3Atmp_432565 = (NI)(LOC25 - ((NI) 1));
			res_432568 = ((NI) 0);
			{
				while (1) {
					if (!(res_432568 <= HEX3Atmp_432565)) goto LA27;
					i_432512 = res_432568;
					{
						Ttype191849* destructablet;
						{
							if (!((*t).sons->data[i_432512] == NIM_NIL)) goto LA31;
							goto LA28;
						}
						LA31: ;
						destructablet = instantiatedestructor_432423(c, (*t).sons->data[i_432512]);
						{
							Tnodeseq191807* LOC37;
							TY246103 LOC38;
							Tnode191813* LOC39;
							Tnode191813* LOC40;
							if (!!((destructablet == NIM_NIL))) goto LA35;
							LOC37 = 0;
							LOC37 = (Tnodeseq191807*) newSeq((&NTI191807), 2);
							memset((void*)LOC38, 0, sizeof(LOC38));
							LOC38[0] = usesym_355055((*destructablet).destructor);
							LOC39 = 0;
							LOC39 = HEX5BHEX5D_192244((*n).kindU.S6.sons->data[((NI) 3)], ((NI) 1));
							LOC38[1] = HEX5BHEX5D_192244(LOC39, ((NI) 0));
							asgnRefNoCycle((void**) (&LOC37->data[0]), LOC38[0]);
							asgnRefNoCycle((void**) (&LOC37->data[1]), LOC38[1]);
							LOC40 = 0;
							LOC40 = newnode_193607(((NU8) 27), (*(*t).sym).info, LOC37, NIM_NIL);
							addson_193819((*n).kindU.S6.sons->data[((NI) 6)], LOC40);
						}
						LA35: ;
					} LA28: ;
					res_432568 += ((NI) 1);
				} LA27: ;
			}
		}
	}
	LA22: ;
	}BeforeRet: ;
}

static N_INLINE(NIM_BOOL, experimentalmode_246279)(Tcontext245023* c) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = gexperimentalmode_155145;
	if (LOC1) goto LA2;
	LOC1 = (((*(*c).module).flags &(1<<((((NU8) 30))&31)))!=0);
	LA2: ;
	result = LOC1;
	return result;
}

N_NIMCALL(void, semoverride_439632)(Tcontext245023* c, Tsym191843* s, Tnode191813* n) {
	NimStringDesc* LOC1;
{	LOC1 = 0;
	LOC1 = nsuNormalize((*(*s).name).s);
	if (eqStrings(LOC1, ((NimStringDesc*) &TMP3156))) goto LA2;
	if (eqStrings(LOC1, ((NimStringDesc*) &TMP3157))) goto LA2;
	if (eqStrings(LOC1, ((NimStringDesc*) &TMP3158))) goto LA3;
	if (eqStrings(LOC1, ((NimStringDesc*) &TMP3159))) goto LA3;
	if (eqStrings(LOC1, ((NimStringDesc*) &TMP3160))) goto LA4;
	goto LA5;
	LA2: ;
	{
		dodestructorstuff_432427(c, s, n);
		{
			NIM_BOOL LOC10;
			LOC10 = 0;
			LOC10 = experimentalmode_246279(c);
			if (!!(LOC10)) goto LA11;
			localerror_166166((*n).info, ((NimStringDesc*) &TMP3168));
		}
		LA11: ;
		(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
	}
	goto LA6;
	LA3: ;
	{
		{
			NIM_BOOL LOC16;
			NIM_BOOL LOC17;
			NI LOC18;
			Ttype191849* LOC20;
			Ttype191849* t;
			Ttype191849* LOC24;
			Ttype191849* LOC25;
			LOC16 = 0;
			LOC17 = 0;
			LOC18 = 0;
			LOC18 = len_194377((*s).typ);
			LOC17 = (LOC18 == ((NI) 2));
			if (!(LOC17)) goto LA19;
			LOC20 = 0;
			LOC20 = skiptypes_195167((*(*s).typ).sons->data[((NI) 1)], IL64(211106232576256));
			LOC17 = ((6291456 &(IL64(1)<<(((*LOC20).kind)&IL64(63))))!=0);
			LA19: ;
			LOC16 = LOC17;
			if (!(LOC16)) goto LA21;
			LOC16 = sametype_226092((*(*s).typ).sons->data[((NI) 1)], (*(*s).typ).sons->data[((NI) 0)], 0);
			LA21: ;
			if (!LOC16) goto LA22;
			LOC24 = 0;
			LOC24 = skiptypes_195167((*(*s).typ).sons->data[((NI) 1)], IL64(211106232576256));
			LOC25 = 0;
			LOC25 = lastson_194442(LOC24);
			t = skiptypes_195167(LOC25, IL64(211106232576256));
			{
				while (1) {
					{
						if (!((*t).kind == ((NU8) 10))) goto LA30;
						t = lastson_194442(t);
					}
					goto LA28;
					LA30: ;
					{
						if (!((*t).kind == ((NU8) 9))) goto LA33;
						t = (*t).sons->data[((NI) 0)];
					}
					goto LA28;
					LA33: ;
					{
						goto LA26;
					}
					LA28: ;
				}
			} LA26: ;
			{
				if (!((155648 &(IL64(1)<<(((*t).kind)&IL64(63))))!=0)) goto LA38;
				{
					if (!(*t).deepcopy == 0) goto LA42;
					asgnRefNoCycle((void**) (&(*t).deepcopy), s);
				}
				goto LA40;
				LA42: ;
				{
					NimStringDesc* LOC45;
					NimStringDesc* LOC46;
					LOC45 = 0;
					LOC46 = 0;
					LOC46 = typetostring_221032(t, ((NU8) 0));
					LOC45 = rawNewString(LOC46->Sup.len + 35);
appendString(LOC45, ((NimStringDesc*) &TMP3169));
appendString(LOC45, LOC46);
					localerror_166155((*n).info, ((NU16) 4), LOC45);
				}
				LA40: ;
			}
			goto LA36;
			LA38: ;
			{
				NimStringDesc* LOC48;
				NimStringDesc* LOC49;
				LOC48 = 0;
				LOC49 = 0;
				LOC49 = typetostring_221032(t, ((NU8) 0));
				LOC48 = rawNewString(LOC49->Sup.len + 27);
appendString(LOC48, ((NimStringDesc*) &TMP3170));
appendString(LOC48, LOC49);
				localerror_166155((*n).info, ((NU16) 4), LOC48);
			}
			LA36: ;
		}
		goto LA14;
		LA22: ;
		{
			localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3171));
		}
		LA14: ;
		(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
	}
	goto LA6;
	LA4: ;
	{
		Ttype191849* t;
		(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
		t = (*s).typ;
		{
			NIM_BOOL LOC54;
			NIM_BOOL LOC55;
			NI LOC56;
			Ttype191849* obj;
			Ttype191849* objb;
			LOC54 = 0;
			LOC55 = 0;
			LOC56 = 0;
			LOC56 = len_194377(t);
			LOC55 = (LOC56 == ((NI) 3));
			if (!(LOC55)) goto LA57;
			LOC55 = ((*t).sons->data[((NI) 0)] == NIM_NIL);
			LA57: ;
			LOC54 = LOC55;
			if (!(LOC54)) goto LA58;
			LOC54 = ((*(*t).sons->data[((NI) 1)]).kind == ((NU8) 23));
			LA58: ;
			if (!LOC54) goto LA59;
			obj = (*(*t).sons->data[((NI) 1)]).sons->data[((NI) 0)];
			{
				while (1) {
					(*obj).flags |= ((NI32)1)<<((((NU8) 26))%(sizeof(NI32)*8));
					{
						if (!((*obj).kind == ((NU8) 10))) goto LA65;
						obj = lastson_194442(obj);
					}
					goto LA63;
					LA65: ;
					{
						if (!((*obj).kind == ((NU8) 9))) goto LA68;
						obj = (*obj).sons->data[((NI) 0)];
					}
					goto LA63;
					LA68: ;
					{
						goto LA61;
					}
					LA63: ;
				}
			} LA61: ;
			objb = (*t).sons->data[((NI) 2)];
			{
				while (1) {
					{
						if (!((*objb).kind == ((NU8) 10))) goto LA75;
						objb = lastson_194442(objb);
					}
					goto LA73;
					LA75: ;
					{
						if (!((*objb).kind == ((NU8) 9))) goto LA78;
						objb = (*objb).sons->data[((NI) 0)];
					}
					goto LA73;
					LA78: ;
					{
						goto LA71;
					}
					LA73: ;
				}
			} LA71: ;
			{
				NIM_BOOL LOC83;
				LOC83 = 0;
				LOC83 = ((139264 &(IL64(1)<<(((*obj).kind)&IL64(63))))!=0);
				if (!(LOC83)) goto LA84;
				LOC83 = sametype_226092(obj, objb, 0);
				LA84: ;
				if (!LOC83) goto LA85;
				{
					if (!(*obj).assignment == 0) goto LA89;
					asgnRefNoCycle((void**) (&(*obj).assignment), s);
				}
				goto LA87;
				LA89: ;
				{
					NimStringDesc* LOC92;
					NimStringDesc* LOC93;
					LOC92 = 0;
					LOC93 = 0;
					LOC93 = typetostring_221032(obj, ((NU8) 0));
					LOC92 = rawNewString(LOC93->Sup.len + 28);
appendString(LOC92, ((NimStringDesc*) &TMP3172));
appendString(LOC92, LOC93);
					localerror_166155((*n).info, ((NU16) 4), LOC92);
				}
				LA87: ;
				goto BeforeRet;
			}
			LA85: ;
		}
		LA59: ;
		localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3173));
	}
	goto LA6;
	LA5: ;
	{
		{
			if (!(((*s).flags &(1<<((((NU8) 30))&31)))!=0)) goto LA97;
			localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3174));
		}
		LA97: ;
	}
	LA6: ;
	}BeforeRet: ;
}

N_NIMCALL(void, typeallowedcheck_410980)(Tlineinfo164338 info, Ttype191849* typ, NU8 kind) {
	Ttype191849* t;
	t = typeallowed_229654(typ, kind);
	{
		if (!!((t == NIM_NIL))) goto LA3;
		{
			NimStringDesc* LOC9;
			NimStringDesc* LOC10;
			if (!(t == typ)) goto LA7;
			LOC9 = 0;
			LOC10 = 0;
			LOC10 = typetostring_221032(typ, ((NU8) 0));
			LOC9 = rawNewString(LOC10->Sup.len + 16);
appendString(LOC9, ((NimStringDesc*) &TMP3175));
appendString(LOC9, LOC10);
appendString(LOC9, ((NimStringDesc*) &TMP3176));
			localerror_166166(info, LOC9);
		}
		goto LA5;
		LA7: ;
		{
			NimStringDesc* LOC12;
			NimStringDesc* LOC13;
			NimStringDesc* LOC14;
			LOC12 = 0;
			LOC13 = 0;
			LOC13 = typetostring_221032(t, ((NU8) 0));
			LOC14 = 0;
			LOC14 = typetostring_221032(typ, ((NU8) 0));
			LOC12 = rawNewString(LOC13->Sup.len + LOC14->Sup.len + 36);
appendString(LOC12, ((NimStringDesc*) &TMP3175));
appendString(LOC12, LOC13);
appendString(LOC12, ((NimStringDesc*) &TMP3177));
appendString(LOC12, LOC14);
appendString(LOC12, ((NimStringDesc*) &TMP3176));
			localerror_166166(info, LOC12);
		}
		LA5: ;
	}
	LA3: ;
}

static N_INLINE(void, paramstypecheck_411015)(Tcontext245023* c, Ttype191849* typ) {
	typeallowedcheck_410980((*(*typ).n).info, typ, ((NU8) 10));
}

N_NIMCALL(void, activate_410327)(Tcontext245023* c, Tnode191813* n) {
}

N_NIMCALL(void, changetype_410253)(Tnode191813* n, Ttype191849* newtype, NIM_BOOL check) {
{	switch ((*n).kind) {
	case ((NU8) 39):
	case ((NU8) 41):
	{
		{
			NI i_444088;
			NI HEX3Atmp_444204;
			NI LOC3;
			NI res_444207;
			i_444088 = 0;
			HEX3Atmp_444204 = 0;
			LOC3 = 0;
			LOC3 = sonslen_194403(n);
			HEX3Atmp_444204 = (NI)(LOC3 - ((NI) 1));
			res_444207 = ((NI) 0);
			{
				while (1) {
					Ttype191849* LOC6;
					if (!(res_444207 <= HEX3Atmp_444204)) goto LA5;
					i_444088 = res_444207;
					LOC6 = 0;
					LOC6 = elemtype_221522(newtype);
					changetype_410253((*n).kindU.S6.sons->data[i_444088], LOC6, check);
					res_444207 += ((NI) 1);
				} LA5: ;
			}
		}
	}
	break;
	case ((NU8) 37):
	{
		Ttype191849* tup;
		tup = skiptypes_195167(newtype, 2048);
		{
			if (!!(((*tup).kind == ((NU8) 18)))) goto LA10;
			{
				if (!((*tup).kind == ((NU8) 17))) goto LA14;
				goto BeforeRet;
			}
			LA14: ;
			internalerror_166199((*n).info, ((NimStringDesc*) &TMP3192));
		}
		goto LA8;
		LA10: ;
		{
			NIM_BOOL LOC17;
			NI LOC18;
			LOC17 = 0;
			LOC18 = 0;
			LOC18 = sonslen_194403(n);
			LOC17 = (((NI) 0) < LOC18);
			if (!(LOC17)) goto LA19;
			LOC17 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 34));
			LA19: ;
			if (!LOC17) goto LA20;
			{
				NI i_444132;
				NI HEX3Atmp_444212;
				NI LOC23;
				NI res_444215;
				i_444132 = 0;
				HEX3Atmp_444212 = 0;
				LOC23 = 0;
				LOC23 = sonslen_194403(n);
				HEX3Atmp_444212 = (NI)(LOC23 - ((NI) 1));
				res_444215 = ((NI) 0);
				{
					while (1) {
						Tnode191813* m;
						if (!(res_444215 <= HEX3Atmp_444212)) goto LA25;
						i_444132 = res_444215;
						m = (*(*n).kindU.S6.sons->data[i_444132]).kindU.S6.sons->data[((NI) 0)];
						{
							if (!!(((*m).kind == ((NU8) 3)))) goto LA28;
							internalerror_166199((*m).info, ((NimStringDesc*) &TMP3193));
							goto BeforeRet;
						}
						LA28: ;
						{
							Tsym191843* f;
							if (!!(((*tup).n == NIM_NIL))) goto LA32;
							f = getsymfromlist_199228((*tup).n, (*(*m).kindU.S4.sym).name, ((NI) 0));
							{
								if (!(f == NIM_NIL)) goto LA36;
								internalerror_166199((*m).info, ((NimStringDesc*) &TMP3194));
								goto BeforeRet;
							}
							LA36: ;
							changetype_410253((*(*n).kindU.S6.sons->data[i_444132]).kindU.S6.sons->data[((NI) 1)], (*f).typ, check);
						}
						goto LA30;
						LA32: ;
						{
							changetype_410253((*(*n).kindU.S6.sons->data[i_444132]).kindU.S6.sons->data[((NI) 1)], (*tup).sons->data[i_444132], check);
						}
						LA30: ;
						res_444215 += ((NI) 1);
					} LA25: ;
				}
			}
		}
		goto LA8;
		LA20: ;
		{
			{
				NI i_444189;
				NI HEX3Atmp_444220;
				NI LOC41;
				NI res_444223;
				i_444189 = 0;
				HEX3Atmp_444220 = 0;
				LOC41 = 0;
				LOC41 = sonslen_194403(n);
				HEX3Atmp_444220 = (NI)(LOC41 - ((NI) 1));
				res_444223 = ((NI) 0);
				{
					while (1) {
						if (!(res_444223 <= HEX3Atmp_444220)) goto LA43;
						i_444189 = res_444223;
						changetype_410253((*n).kindU.S6.sons->data[i_444189], (*tup).sons->data[i_444189], check);
						res_444223 += ((NI) 1);
					} LA43: ;
				}
			}
		}
		LA8: ;
	}
	break;
	case ((NU8) 5) ... ((NU8) 15):
	{
		{
			NI64 value;
			if (!check) goto LA47;
			value = (*n).kindU.S1.intval;
			{
				NIM_BOOL LOC51;
				NI64 LOC52;
				NI64 LOC54;
				NimStringDesc* LOC57;
				NimStringDesc* LOC58;
				NimStringDesc* LOC59;
				LOC51 = 0;
				LOC52 = 0;
				LOC52 = firstord_221004(newtype);
				LOC51 = (value < LOC52);
				if (LOC51) goto LA53;
				LOC54 = 0;
				LOC54 = lastord_221010(newtype);
				LOC51 = (LOC54 < value);
				LA53: ;
				if (!LOC51) goto LA55;
				LOC57 = 0;
				LOC58 = 0;
				LOC58 = nimInt64ToStr(value);
				LOC59 = 0;
				LOC59 = typetostring_221032(newtype, ((NU8) 0));
				LOC57 = rawNewString(LOC58->Sup.len + LOC59->Sup.len + 19);
appendString(LOC57, ((NimStringDesc*) &TMP3195));
appendString(LOC57, LOC58);
appendString(LOC57, ((NimStringDesc*) &TMP3196));
appendString(LOC57, LOC59);
				localerror_166155((*n).info, ((NU16) 4), LOC57);
			}
			LA55: ;
		}
		LA47: ;
	}
	break;
	default:
	{
	}
	break;
	}
	asgnRefNoCycle((void**) (&(*n).typ), newtype);
	}BeforeRet: ;
}

N_NIMCALL(void, fixabstracttype_444407)(Tcontext245023* c, Tnode191813* n) {
	{
		NI i_444430;
		NI HEX3Atmp_444602;
		NI LOC2;
		NI res_444605;
		i_444430 = 0;
		HEX3Atmp_444602 = 0;
		LOC2 = 0;
		LOC2 = len_192097(n);
		HEX3Atmp_444602 = (LOC2 - 1);
		res_444605 = ((NI) 1);
		{
			while (1) {
				Tnode191813* it;
				if (!(res_444605 <= HEX3Atmp_444602)) goto LA4;
				i_444430 = res_444605;
				it = (*n).kindU.S6.sons->data[i_444430];
				{
					NIM_BOOL LOC7;
					Ttype191849* LOC9;
					LOC7 = 0;
					LOC7 = ((*it).kind == ((NU8) 59));
					if (!(LOC7)) goto LA8;
					LOC9 = 0;
					LOC9 = skiptypes_195167((*it).typ, IL64(211106240964864));
					LOC7 = !(((IL64(281475110928384) &(IL64(1)<<(((*LOC9).kind)&IL64(63))))!=0));
					LA8: ;
					if (!LOC7) goto LA10;
					{
						Ttype191849* LOC14;
						Ttype191849* s;
						LOC14 = 0;
						LOC14 = skiptypes_195167((*(*it).kindU.S6.sons->data[((NI) 1)]).typ, IL64(211106240964864));
						if (!((786480 &(IL64(1)<<(((*LOC14).kind)&IL64(63))))!=0)) goto LA15;
						s = skiptypes_195167((*it).typ, IL64(211106240964864));
						{
							if (!!(((*s).kind == ((NU8) 6)))) goto LA19;
							changetype_410253((*it).kindU.S6.sons->data[((NI) 1)], s, NIM_TRUE);
						}
						LA19: ;
						asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_444430]), (*it).kindU.S6.sons->data[((NI) 1)]);
					}
					LA15: ;
				}
				LA10: ;
				res_444605 += ((NI) 1);
			} LA4: ;
		}
	}
}

N_NIMCALL(NU8, isassignable_444642)(Tcontext245023* c, Tnode191813* n) {
	NU8 result;
	result = 0;
	result = isassignable_270056((*(*c).p).owner, n);
	return result;
}

N_NIMCALL(void, performprocvarcheck_432302)(Tcontext245023* c, Tnode191813* n, Tsym191843* s) {
	NI smoduleid;
	Tsym191843* LOC1;
	LOC1 = 0;
	LOC1 = getmodule_199243(s);
	smoduleid = (*LOC1).Sup.id;
	{
		NIM_BOOL LOC4;
		NIM_BOOL LOC5;
		LOC4 = 0;
		LOC5 = 0;
		LOC5 = !((((*s).flags &(1<<((((NU8) 17))&31)))!=0));
		if (!(LOC5)) goto LA6;
		LOC5 = ((*(*s).typ).callconv == ((NU8) 0));
		LA6: ;
		LOC4 = LOC5;
		if (!(LOC4)) goto LA7;
		LOC4 = !((smoduleid == (*(*c).module).Sup.id));
		LA7: ;
		if (!LOC4) goto LA8;
		{
			{
				Tsym191843* module_432341;
				Tsymseq191815* HEX3Atmp_432345;
				NI i_432348;
				NI L_432350;
				module_432341 = 0;
				HEX3Atmp_432345 = 0;
				HEX3Atmp_432345 = (*c).friendmodules;
				i_432348 = ((NI) 0);
				L_432350 = (HEX3Atmp_432345 ? HEX3Atmp_432345->Sup.len : 0);
				{
					while (1) {
						if (!(i_432348 < L_432350)) goto LA13;
						module_432341 = HEX3Atmp_432345->data[i_432348];
						{
							if (!(smoduleid == (*module_432341).Sup.id)) goto LA16;
							goto LA10;
						}
						LA16: ;
						i_432348 += ((NI) 1);
					} LA13: ;
				}
			}
			localerror_166155((*n).info, ((NU16) 134), (*(*s).name).s);
		} LA10: ;
	}
	LA8: ;
}

N_NIMCALL(void, semprocvarcheck_432366)(Tcontext245023* c, Tnode191813* n_432369) {
	Tnode191813* n;
	n = skipconv_230935(n_432369);
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = ((*n).kind == ((NU8) 3));
		if (!(LOC3)) goto LA4;
		LOC3 = ((126976 &(1<<(((*(*n).kindU.S4.sym).kind)&31)))!=0);
		LA4: ;
		if (!LOC3) goto LA5;
		performprocvarcheck_432302(c, n, (*n).kindU.S4.sym);
	}
	LA5: ;
}

N_NIMCALL(Tnode191813*, newhiddenaddrtaken_444650)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		NIM_BOOL LOC5;
		LOC3 = 0;
		LOC3 = ((*n).kind == ((NU8) 65));
		if (!(LOC3)) goto LA4;
		LOC5 = 0;
		LOC5 = (gcmd_155130 == ((NU8) 2));
		if (LOC5) goto LA6;
		LOC5 = (((*(*c).module).flags &(1<<((((NU8) 27))&31)))!=0);
		LA6: ;
		LOC3 = !(LOC5);
		LA4: ;
		if (!LOC3) goto LA7;
		checksonslen_246249(n, ((NI) 1));
		result = (*n).kindU.S6.sons->data[((NI) 0)];
	}
	goto LA1;
	LA7: ;
	{
		Ttype191849* LOC10;
		LOC10 = 0;
		LOC10 = makevartype_245642(c, (*n).typ);
		result = newnodeit_193807(((NU8) 64), (*n).info, LOC10);
		addson_193819(result, n);
		{
			NU8 LOC13;
			LOC13 = 0;
			LOC13 = isassignable_444642(c, n);
			if (!!(((6 &(1<<((LOC13)&7)))!=0))) goto LA14;
			localerror_166155((*n).info, ((NU16) 127), ((NimStringDesc*) &TMP2991));
		}
		LA14: ;
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, analyseifaddresstaken_444699)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
{	result = 0;
	result = n;
	switch ((*n).kind) {
	case ((NU8) 3):
	{
		{
			NIM_BOOL LOC4;
			Ttype191849* LOC6;
			LOC4 = 0;
			LOC4 = !(((*(*n).kindU.S4.sym).typ == NIM_NIL));
			if (!(LOC4)) goto LA5;
			LOC6 = 0;
			LOC6 = skiptypes_195167((*(*n).kindU.S4.sym).typ, IL64(211106232576000));
			LOC4 = !(((*LOC6).kind == ((NU8) 23)));
			LA5: ;
			if (!LOC4) goto LA7;
			(*(*n).kindU.S4.sym).flags |= ((NI32)1)<<((((NU8) 15))%(sizeof(NI32)*8));
			result = newhiddenaddrtaken_444650(c, n);
		}
		LA7: ;
	}
	break;
	case ((NU8) 45):
	{
		checksonslen_246249(n, ((NI) 2));
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 3)))) goto LA12;
			internalerror_166199((*n).info, ((NimStringDesc*) &TMP3198));
			goto BeforeRet;
		}
		LA12: ;
		{
			Ttype191849* LOC16;
			LOC16 = 0;
			LOC16 = skiptypes_195167((*(*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S4.sym).typ, IL64(211106232576000));
			if (!!(((*LOC16).kind == ((NU8) 23)))) goto LA17;
			(*(*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S4.sym).flags |= ((NI32)1)<<((((NU8) 15))%(sizeof(NI32)*8));
			result = newhiddenaddrtaken_444650(c, n);
		}
		LA17: ;
	}
	break;
	case ((NU8) 42):
	{
		checkminsonslen_246259(n, ((NI) 1));
		{
			Ttype191849* LOC22;
			LOC22 = 0;
			LOC22 = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 0)]).typ, IL64(211106232576000));
			if (!!(((*LOC22).kind == ((NU8) 23)))) goto LA23;
			{
				if (!((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3))) goto LA27;
				(*(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).flags |= ((NI32)1)<<((((NU8) 15))%(sizeof(NI32)*8));
			}
			LA27: ;
			result = newhiddenaddrtaken_444650(c, n);
		}
		LA23: ;
	}
	break;
	default:
	{
		result = newhiddenaddrtaken_444650(c, n);
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, analyseifaddresstakenincall_444851)(Tcontext245023* c, Tnode191813* n) {
	Ttype191849* t;
{	checkminsonslen_246259(n, ((NI) 1));
	t = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 0)]).typ, 2048);
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3));
		if (!(LOC3)) goto LA4;
		LOC3 = ((TMP3197[(*(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).magic/8] &(1<<((*(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).magic%8)))!=0);
		LA4: ;
		if (!LOC3) goto LA5;
		{
			NI i_444895;
			NI HEX3Atmp_445013;
			NI LOC8;
			NI res_445016;
			i_444895 = 0;
			HEX3Atmp_445013 = 0;
			LOC8 = 0;
			LOC8 = sonslen_194403(n);
			HEX3Atmp_445013 = (NI)(LOC8 - ((NI) 1));
			res_445016 = ((NI) 1);
			{
				while (1) {
					if (!(res_445016 <= HEX3Atmp_445013)) goto LA10;
					i_444895 = res_445016;
					{
						NIM_BOOL LOC13;
						NIM_BOOL LOC14;
						NI LOC15;
						Ttype191849* LOC18;
						LOC13 = 0;
						LOC14 = 0;
						LOC15 = 0;
						LOC15 = sonslen_194351(t);
						LOC14 = (i_444895 < LOC15);
						if (!(LOC14)) goto LA16;
						LOC14 = !(((*t).sons->data[i_444895] == NIM_NIL));
						LA16: ;
						LOC13 = LOC14;
						if (!(LOC13)) goto LA17;
						LOC18 = 0;
						LOC18 = skiptypes_195167((*t).sons->data[i_444895], IL64(211106232576000));
						LOC13 = ((*LOC18).kind == ((NU8) 23));
						LA17: ;
						if (!LOC13) goto LA19;
						{
							NU8 LOC23;
							LOC23 = 0;
							LOC23 = isassignable_444642(c, (*n).kindU.S6.sons->data[i_444895]);
							if (!!(((6 &(1<<((LOC23)&7)))!=0))) goto LA24;
							{
								if (!!(((*(*n).kindU.S6.sons->data[i_444895]).kind == ((NU8) 64)))) goto LA28;
								localerror_166155((*(*n).kindU.S6.sons->data[i_444895]).info, ((NU16) 127), ((NimStringDesc*) &TMP2991));
							}
							LA28: ;
						}
						LA24: ;
					}
					LA19: ;
					res_445016 += ((NI) 1);
				} LA10: ;
			}
		}
		goto BeforeRet;
	}
	LA5: ;
	{
		NI i_444965;
		NI HEX3Atmp_445021;
		NI LOC31;
		NI res_445024;
		i_444965 = 0;
		HEX3Atmp_445021 = 0;
		LOC31 = 0;
		LOC31 = sonslen_194403(n);
		HEX3Atmp_445021 = (NI)(LOC31 - ((NI) 1));
		res_445024 = ((NI) 1);
		{
			while (1) {
				if (!(res_445024 <= HEX3Atmp_445021)) goto LA33;
				i_444965 = res_445024;
				{
					if (!((*(*n).kindU.S6.sons->data[i_444965]).kind == ((NU8) 32))) goto LA36;
					analyseifaddresstakenincall_444851(c, (*n).kindU.S6.sons->data[i_444965]);
				}
				LA36: ;
				semprocvarcheck_432366(c, (*n).kindU.S6.sons->data[i_444965]);
				{
					NIM_BOOL LOC40;
					NI LOC41;
					Ttype191849* LOC43;
					LOC40 = 0;
					LOC41 = 0;
					LOC41 = sonslen_194351(t);
					LOC40 = (i_444965 < LOC41);
					if (!(LOC40)) goto LA42;
					LOC43 = 0;
					LOC43 = skiptypes_195167((*t).sons->data[i_444965], IL64(211106232576000));
					LOC40 = ((*LOC43).kind == ((NU8) 23));
					LA42: ;
					if (!LOC40) goto LA44;
					{
						if (!!(((*(*n).kindU.S6.sons->data[i_444965]).kind == ((NU8) 64)))) goto LA48;
						asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_444965]), analyseifaddresstaken_444699(c, (*n).kindU.S6.sons->data[i_444965]));
					}
					LA48: ;
				}
				LA44: ;
				res_445024 += ((NI) 1);
			} LA33: ;
		}
	}
	}BeforeRet: ;
}

N_NIMCALL(Tnode191813*, semaddr_445049)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* x;
	result = 0;
	result = newnodei_193351(((NU8) 63), (*n).info);
	x = semexprwithtype_410211(c, n, 0);
	{
		NU8 LOC3;
		LOC3 = 0;
		LOC3 = isassignable_444642(c, x);
		if (!!(((6 &(1<<((LOC3)&7)))!=0))) goto LA4;
		localerror_166155((*n).info, ((NU16) 125), ((NimStringDesc*) &TMP2991));
	}
	LA4: ;
	add_192164(result, x);
	asgnRefNoCycle((void**) (&(*result).typ), makeptrtype_245211(c, (*x).typ));
	return result;
}

N_NIMCALL(Tnode191813*, semtypeof_445070)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* typexpr;
	Ttype191849* LOC1;
	result = 0;
	result = newnodei_193351(((NU8) 132), (*n).info);
	typexpr = semexprwithtype_410211(c, n, 4);
	add_192164(result, typexpr);
	LOC1 = 0;
	LOC1 = skiptypes_195167((*typexpr).typ, IL64(562949953421568));
	asgnRefNoCycle((void**) (&(*result).typ), maketypedesc_245681(c, LOC1));
	return result;
}

N_NIMCALL(Tnode191813*, semispartof_445082)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	NU8 r;
	Tnode191813* LOC1;
	Tnode191813* LOC2;
	result = 0;
	LOC1 = 0;
	LOC1 = HEX5BHEX5D_192244(n, ((NI) 1));
	LOC2 = 0;
	LOC2 = HEX5BHEX5D_192244(n, ((NI) 2));
	r = ispartof_400375(LOC1, LOC2);
	result = newintnodet_257028(((NI64) (r)), n);
	return result;
}

N_NIMCALL(Tnode191813*, evaltypetrait_445130)(Tnode191813* trait, Ttype191849* operand, Tsym191843* context) {
	Tnode191813* result;
	Ttype191849* typ;
	NimStringDesc* LOC1;
	result = 0;
	typ = skiptypes_195167(operand, 256);
	LOC1 = 0;
	LOC1 = nsuNormalize((*(*(*trait).kindU.S4.sym).name).s);
	if (eqStrings(LOC1, ((NimStringDesc*) &TMP3202))) goto LA2;
	if (eqStrings(LOC1, ((NimStringDesc*) &TMP3203))) goto LA3;
	goto LA4;
	LA2: ;
	{
		NimStringDesc* LOC7;
		LOC7 = 0;
		LOC7 = typetostring_221032(typ, ((NU8) 0));
		result = newstrnode_192643(((NU8) 20), LOC7);
		asgnRefNoCycle((void**) (&(*result).typ), newtype_194140(((NU8) 28), context));
		(*result).info = (*trait).info;
	}
	goto LA5;
	LA3: ;
	{
		NI LOC9;
		LOC9 = 0;
		LOC9 = len_194377(typ);
		result = newintnode_192607(((NU8) 6), ((NI64) ((NI)(LOC9 - ((NI) (((*typ).kind == ((NU8) 25))))))));
		asgnRefNoCycle((void**) (&(*result).typ), newtype_194140(((NU8) 31), context));
		(*result).info = (*trait).info;
	}
	goto LA5;
	LA4: ;
	{
		{
			NimStringDesc* LOC15;
			if (!NIM_TRUE) goto LA13;
			LOC15 = 0;
			LOC15 = HEX24_166306(TMP3204);
			internalerror_166218(LOC15);
		}
		LA13: ;
	}
	LA5: ;
	return result;
}

N_NIMCALL(Tnode191813*, semtypetraits_445167)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Ttype191849* t;
	result = 0;
	checkminsonslen_246259(n, ((NI) 2));
	t = (*(*n).kindU.S6.sons->data[((NI) 1)]).typ;
	{
		NIM_BOOL LOC3;
		NimStringDesc* LOC7;
		LOC3 = 0;
		LOC3 = !((t == NIM_NIL));
		if (!(LOC3)) goto LA4;
		LOC3 = ((*t).kind == ((NU8) 8));
		LA4: ;
		if (!!(LOC3)) goto LA5;
		LOC7 = 0;
		LOC7 = HEX24_166306(TMP3200);
		internalerror_166218(LOC7);
	}
	LA5: ;
	{
		NI LOC10;
		Tnode191813* LOC13;
		Tsym191843* LOC14;
		LOC10 = 0;
		LOC10 = sonslen_194351(t);
		if (!(((NI) 0) < LOC10)) goto LA11;
		LOC13 = 0;
		LOC13 = HEX5BHEX5D_192244(n, ((NI) 0));
		LOC14 = 0;
		LOC14 = getcurrowner_245255();
		result = evaltypetrait_445130(LOC13, t, LOC14);
	}
	goto LA8;
	LA11: ;
	{
		result = n;
	}
	LA8: ;
	return result;
}

N_NIMCALL(NI, expectintlit_445100)(Tcontext245023* c, Tnode191813* n) {
	NI result;
	Tnode191813* x;
	result = 0;
	x = (*c).semconstexpr(c, n);
	switch ((*x).kind) {
	case ((NU8) 6) ... ((NU8) 10):
	{
		result = ((NI) ((*x).kindU.S1.intval));
	}
	break;
	default:
	{
		localerror_166155((*n).info, ((NU16) 7), ((NimStringDesc*) &TMP2991));
	}
	break;
	}
	return result;
}

static N_INLINE(NI, tolinenumber_165439)(Tlineinfo164338 info) {
	NI result;
	result = 0;
	result = ((NI) (info.line));
	return result;
}

N_NIMCALL(Tnode191813*, seminstantiationinfo_445111)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	NI idx;
	NI usefullpaths;
	Tlineinfo164338 info;
	Tnode191813* filename;
	Ttype191849* LOC1;
	Tnode191813* line;
	Ttype191849* LOC7;
	NI LOC8;
	result = 0;
	result = newnodeit_193807(((NU8) 37), (*n).info, (*n).typ);
	idx = expectintlit_445100(c, (*n).kindU.S6.sons->data[((NI) 1)]);
	usefullpaths = expectintlit_445100(c, (*n).kindU.S6.sons->data[((NI) 2)]);
	info = getinfocontext_165234(idx);
	LOC1 = 0;
	LOC1 = getsystype_239030(((NU8) 28));
	filename = newnodeit_193807(((NU8) 20), (*n).info, LOC1);
	{
		if (!!((usefullpaths == ((NI) 0)))) goto LA4;
		asgnRefNoCycle((void**) (&(*filename).kindU.S3.strval), tofullpath_165273(info.fileindex));
	}
	goto LA2;
	LA4: ;
	{
		asgnRefNoCycle((void**) (&(*filename).kindU.S3.strval), tofilename_165263(info.fileindex));
	}
	LA2: ;
	LOC7 = 0;
	LOC7 = getsystype_239030(((NU8) 31));
	line = newnodeit_193807(((NU8) 6), (*n).info, LOC7);
	LOC8 = 0;
	LOC8 = tolinenumber_165439(info);
	(*line).kindU.S1.intval = ((NI64) (LOC8));
	add_192164(result, filename);
	add_192164(result, line);
	return result;
}

N_NIMCALL(Tnode191813*, semord_445205)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	NI64 LOC1;
	NI64 LOC2;
	Ttype191849* LOC3;
	result = 0;
	result = n;
	LOC1 = 0;
	LOC1 = firstord_221004((*(*n).kindU.S6.sons->data[((NI) 1)]).typ);
	LOC2 = 0;
	LOC2 = lastord_221010((*(*n).kindU.S6.sons->data[((NI) 1)]).typ);
	LOC3 = 0;
	LOC3 = getsystype_239030(((NU8) 31));
	asgnRefNoCycle((void**) (&(*result).typ), makerangetype_246182(c, LOC1, LOC2, (*n).info, LOC3));
	return result;
}

N_NIMCALL(Tnode191813*, semlowhigh_443647)(Tcontext245023* c, Tnode191813* n, NU16 m) {
	Tnode191813* result;
	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!!((LOC3 == ((NI) 2)))) goto LA4;
		localerror_166155((*n).info, ((NU16) 69), optostr_443653[(m)- 4]);
	}
	goto LA1;
	LA4: ;
	{
		Ttype191849* typ;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 1)], 32));
		typ = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 1)]).typ, IL64(2306054115455707392));
		switch ((*typ).kind) {
		case ((NU8) 24):
		case ((NU8) 28):
		case ((NU8) 29):
		case ((NU8) 27):
		case ((NU8) 48):
		{
			asgnRefNoCycle((void**) (&(*n).typ), getsystype_239030(((NU8) 31)));
		}
		break;
		case ((NU8) 4):
		case ((NU8) 16):
		{
			asgnRefNoCycle((void**) (&(*n).typ), (*typ).sons->data[((NI) 0)]);
		}
		break;
		case ((NU8) 31) ... ((NU8) 35):
		case ((NU8) 2):
		case ((NU8) 1):
		case ((NU8) 14):
		case ((NU8) 41):
		case ((NU8) 42):
		case ((NU8) 43):
		{
			asgnRefNoCycle((void**) (&(*n).typ), skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 1)]).typ, IL64(2306054115454658816)));
		}
		break;
		case ((NU8) 12):
		{
			Tnode191813* LOC11;
			LOC11 = 0;
			LOC11 = copytree_196028(n);
			asgnRefNoCycle((void**) (&(*n).typ), maketypefromexpr_245726(c, LOC11));
		}
		break;
		default:
		{
			localerror_166155((*n).info, ((NU16) 67), optostr_443653[(m)- 4]);
		}
		break;
		}
	}
	LA1: ;
	result = n;
	return result;
}

N_NIMCALL(Tnode191813*, semshallowcopy_445277)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	result = 0;
	{
		NI LOC3;
		Tnode191813* LOC6;
		Tnode191813* LOC7;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 3))) goto LA4;
		result = newnodei_193351(((NU8) 74), (*n).info);
		LOC6 = 0;
		LOC6 = HEX5BHEX5D_192244(n, ((NI) 1));
		add_192164(result, LOC6);
		LOC7 = 0;
		LOC7 = HEX5BHEX5D_192244(n, ((NI) 2));
		add_192164(result, LOC7);
		result = semasgn_448081(c, result);
	}
	goto LA1;
	LA4: ;
	{
		result = semdirectop_411032(c, n, flags);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, sembindsym_445215)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* sl;
	Tnode191813* ismixin;
	Tnode191813* id;
	Tident168021* LOC13;
	Tsym191843* s;
{	result = 0;
	result = copynode_195640(n);
	add_192164(result, (*n).kindU.S6.sons->data[((NI) 0)]);
	sl = semconstexpr_411485(c, (*n).kindU.S6.sons->data[((NI) 1)]);
	{
		if (!!(((*sl).kind == ((NU8) 20) || (*sl).kind == ((NU8) 21) || (*sl).kind == ((NU8) 22)))) goto LA3;
		localerror_166155((*(*n).kindU.S6.sons->data[((NI) 1)]).info, ((NU16) 6), ((NimStringDesc*) &TMP2991));
		result = errornode_246160(c, n);
		goto BeforeRet;
	}
	LA3: ;
	ismixin = semconstexpr_411485(c, (*n).kindU.S6.sons->data[((NI) 2)]);
	{
		NIM_BOOL LOC7;
		NIM_BOOL LOC8;
		LOC7 = 0;
		LOC8 = 0;
		LOC8 = !(((*ismixin).kind == ((NU8) 6)));
		if (LOC8) goto LA9;
		LOC8 = ((*ismixin).kindU.S1.intval < IL64(0));
		LA9: ;
		LOC7 = LOC8;
		if (LOC7) goto LA10;
		LOC7 = (IL64(2) < (*ismixin).kindU.S1.intval);
		LA10: ;
		if (!LOC7) goto LA11;
		localerror_166155((*(*n).kindU.S6.sons->data[((NI) 2)]).info, ((NU16) 104), ((NimStringDesc*) &TMP2991));
		result = errornode_246160(c, n);
		goto BeforeRet;
	}
	LA11: ;
	LOC13 = 0;
	LOC13 = getident_168463((*sl).kindU.S3.strval);
	id = newidentnode_193313(LOC13, (*n).info);
	s = qualifiedlookup_250864(c, id, 2);
	{
		Tnode191813* sc;
		if (!!((s == NIM_NIL))) goto LA16;
		sc = symchoice_423316(c, id, s, ((NU8) ((*ismixin).kindU.S1.intval)));
		add_192164(result, sc);
	}
	goto LA14;
	LA16: ;
	{
		localerror_166155((*(*n).kindU.S6.sons->data[((NI) 1)]).info, ((NU16) 61), (*sl).kindU.S3.strval);
	}
	LA14: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, isnegative_445299)(Tnode191813* n_445301) {
	NIM_BOOL result;
	Tnode191813* n;
	result = 0;
	n = skipconv_230935(n_445301);
	{
		if (!((*n).kind >= ((NU8) 5) && (*n).kind <= ((NU8) 15))) goto LA3;
		result = ((*n).kindU.S1.intval < IL64(0));
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC6;
		LOC6 = 0;
		LOC6 = ((*n).kind == ((NU8) 27) || (*n).kind == ((NU8) 29) || (*n).kind == ((NU8) 30) || (*n).kind == ((NU8) 31) || (*n).kind == ((NU8) 26) || (*n).kind == ((NU8) 28) || (*n).kind == ((NU8) 32));
		if (!(LOC6)) goto LA7;
		LOC6 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3));
		LA7: ;
		if (!LOC6) goto LA8;
		result = ((*(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).magic == ((NU16) 105) || (*(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).magic == ((NU16) 106));
	}
	goto LA1;
	LA8: ;
	LA1: ;
	return result;
}

N_NIMCALL(NIM_BOOL, isstrangearray_445282)(Ttype191849* t_445284) {
	NIM_BOOL result;
	Ttype191849* t;
	NIM_BOOL LOC1;
	NI64 LOC3;
	result = 0;
	t = skiptypes_195167(t_445284, IL64(211106232576256));
	LOC1 = 0;
	LOC1 = ((*t).kind == ((NU8) 16));
	if (!(LOC1)) goto LA2;
	LOC3 = 0;
	LOC3 = firstord_221004(t);
	LOC1 = !((LOC3 == IL64(0)));
	LA2: ;
	result = LOC1;
	return result;
}

N_NIMCALL(Tnode191813*, magicsafteroverloadresolution_445354)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Tnode191813* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = HEX5BHEX5D_192244(n, ((NI) 0));
	switch ((*(*LOC1).kindU.S4.sym).magic) {
	case ((NU16) 10):
	{
		checksonslen_246249(n, ((NI) 2));
		result = semaddr_445049(c, (*n).kindU.S6.sons->data[((NI) 1)]);
	}
	break;
	case ((NU16) 11):
	{
		checksonslen_246249(n, ((NI) 2));
		result = semtypeof_445070(c, (*n).kindU.S6.sons->data[((NI) 1)]);
	}
	break;
	case ((NU16) 164):
	{
		result = semispartof_445082(c, n, flags);
	}
	break;
	case ((NU16) 7):
	{
		result = semtypetraits_445167(c, n);
	}
	break;
	case ((NU16) 165):
	{
		Tnode191813* LOC7;
		NimStringDesc* LOC8;
		LOC7 = 0;
		LOC7 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC8 = 0;
		LOC8 = rendertree_213058(LOC7, 4);
		result = newstrnodet_257042(LOC8, n);
		asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 28)));
	}
	break;
	case ((NU16) 261):
	{
		result = seminstantiationinfo_445111(c, n);
	}
	break;
	case ((NU16) 25):
	{
		result = semord_445205(c, n);
	}
	break;
	case ((NU16) 5):
	case ((NU16) 4):
	{
		Tnode191813* LOC12;
		LOC12 = 0;
		LOC12 = HEX5BHEX5D_192244(n, ((NI) 0));
		result = semlowhigh_443647(c, n, (*(*LOC12).kindU.S4.sym).magic);
	}
	break;
	case ((NU16) 15):
	{
		result = semshallowcopy_445277(c, n, flags);
	}
	break;
	case ((NU16) 253):
	{
		result = sembindsym_445215(c, n);
	}
	break;
	case ((NU16) 218):
	{
		Tnode191813* LOC16;
		result = n;
		LOC16 = 0;
		LOC16 = HEX5BHEX5D_192244(n, ((NI) 1));
		asgnRefNoCycle((void**) (&(*result).typ), (*LOC16).typ);
	}
	break;
	case ((NU16) 151):
	{
		result = n;
		{
			if (!!((*(*c).p).bracketexpr == 0)) goto LA20;
			{
				NIM_BOOL LOC24;
				NIM_BOOL LOC26;
				NI LOC27;
				LOC24 = 0;
				LOC24 = isnegative_445299((*n).kindU.S6.sons->data[((NI) 1)]);
				if (LOC24) goto LA25;
				LOC26 = 0;
				LOC27 = 0;
				LOC27 = len_192097(n);
				LOC26 = (((NI) 2) < LOC27);
				if (!(LOC26)) goto LA28;
				LOC26 = isnegative_445299((*n).kindU.S6.sons->data[((NI) 2)]);
				LA28: ;
				LOC24 = LOC26;
				LA25: ;
				if (!LOC24) goto LA29;
				localerror_166166((*n).info, ((NimStringDesc*) &TMP3207));
			}
			LA29: ;
		}
		LA20: ;
	}
	break;
	case ((NU16) 12):
	{
		result = (*n).kindU.S6.sons->data[((NI) 1)];
		{
			if (!(*(*c).p).bracketexpr == 0) goto LA34;
			localerror_166166((*n).info, ((NimStringDesc*) &TMP3208));
		}
		goto LA32;
		LA34: ;
		{
			NU8 LOC37;
			NimStringDesc* LOC40;
			NimStringDesc* LOC41;
			LOC37 = 0;
			LOC37 = checkforsideeffects_269869((*(*c).p).bracketexpr);
			if (!!((LOC37 == ((NU8) 2)))) goto LA38;
			LOC40 = 0;
			LOC40 = rendertree_213058((*(*c).p).bracketexpr, 0);
			LOC41 = 0;
			LOC41 = nsuFormatSingleElem(((NimStringDesc*) &TMP3209), LOC40);
			localerror_166166((*n).info, LOC41);
		}
		goto LA32;
		LA38: ;
		{
			NIM_BOOL LOC43;
			NimStringDesc* LOC46;
			NimStringDesc* LOC47;
			LOC43 = 0;
			LOC43 = isstrangearray_445282((*(*(*c).p).bracketexpr).typ);
			if (!LOC43) goto LA44;
			LOC46 = 0;
			LOC46 = rendertree_213058((*(*c).p).bracketexpr, 0);
			LOC47 = 0;
			LOC47 = nsuFormatSingleElem(((NimStringDesc*) &TMP3210), LOC46);
			localerror_166166((*n).info, LOC47);
		}
		goto LA32;
		LA44: ;
		{
			Tnode191813* lenexpr;
			Tident168021* LOC49;
			Tnode191813* LOC50;
			Tnode191813* lenexprb;
			lenexpr = newnodei_193351(((NU8) 27), (*n).info);
			LOC49 = 0;
			LOC49 = getident_168463(((NimStringDesc*) &TMP3211));
			LOC50 = 0;
			LOC50 = newidentnode_193313(LOC49, (*n).info);
			add_192164(lenexpr, LOC50);
			add_192164(lenexpr, (*(*c).p).bracketexpr);
			lenexprb = semexprwithtype_410211(c, lenexpr, 0);
			{
				NIM_BOOL LOC53;
				NIM_BOOL LOC55;
				NimStringDesc* LOC58;
				NimStringDesc* LOC59;
				LOC53 = 0;
				LOC53 = (*lenexprb).typ == 0;
				if (LOC53) goto LA54;
				LOC55 = 0;
				LOC55 = isordinaltype_221093((*lenexprb).typ);
				LOC53 = !(LOC55);
				LA54: ;
				if (!LOC53) goto LA56;
				LOC58 = 0;
				LOC58 = rendertree_213058(lenexpr, 0);
				LOC59 = 0;
				LOC59 = nsuFormatSingleElem(((NimStringDesc*) &TMP3212), LOC58);
				localerror_166166((*n).info, LOC59);
			}
			goto LA51;
			LA56: ;
			{
				Ttype191849* LOC61;
				Tsym191843* LOC62;
				Tnode191813* LOC63;
				LOC61 = 0;
				LOC61 = getsystype_239030(((NU8) 31));
				result = newnodeit_193807(((NU8) 27), (*n).info, LOC61);
				LOC62 = 0;
				LOC62 = createmagic_196987(((NimStringDesc*) &TMP3213), ((NU16) 42));
				LOC63 = 0;
				LOC63 = newsymnode_193338(LOC62, (*n).info);
				add_192164(result, LOC63);
				add_192164(result, lenexprb);
				add_192164(result, (*n).kindU.S6.sons->data[((NI) 1)]);
			}
			LA51: ;
		}
		LA32: ;
	}
	break;
	case ((NU16) 13):
	{
		Transformation407013 plugin;
		Tnode191813* LOC65;
		LOC65 = 0;
		LOC65 = HEX5BHEX5D_192244(n, ((NI) 0));
		plugin = getplugin_407094((*LOC65).kindU.S4.sym);
		{
			NimStringDesc* LOC70;
			Tnode191813* LOC71;
			if (!plugin == 0) goto LA68;
			LOC70 = 0;
			LOC71 = 0;
			LOC71 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC70 = rawNewString((*(*(*LOC71).kindU.S4.sym).name).s->Sup.len + 19);
appendString(LOC70, ((NimStringDesc*) &TMP3214));
appendString(LOC70, (*(*(*LOC71).kindU.S4.sym).name).s);
			localerror_166166((*n).info, LOC70);
			result = n;
		}
		goto LA66;
		LA68: ;
		{
			result = plugin(c, n);
		}
		LA66: ;
	}
	break;
	default:
	{
		result = n;
	}
	break;
	}
	return result;
}

N_NIMCALL(Tnode191813*, fixuptypeaftereval_411201)(Tcontext245023* c, Tnode191813* evaluated, Tnode191813* eorig) {
	Tnode191813* result;
	result = 0;
	{
		if (!((448 &(IL64(1)<<(((*(*eorig).typ).kind)&IL64(63))))!=0)) goto LA3;
		result = semexprwithtype_410211(c, evaluated, 0);
	}
	goto LA1;
	LA3: ;
	{
		Ttype191849* expectedtype;
		result = evaluated;
		expectedtype = skiptypes_195167((*eorig).typ, IL64(576460752303423488));
		annotatetype_403134(result, expectedtype);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, evalatcompiletime_445429)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tsym191843* callee;
{	result = 0;
	result = n;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = !(((*n).kind == ((NU8) 27) || (*n).kind == ((NU8) 29) || (*n).kind == ((NU8) 30) || (*n).kind == ((NU8) 31) || (*n).kind == ((NU8) 26) || (*n).kind == ((NU8) 28) || (*n).kind == ((NU8) 32)));
		if (LOC3) goto LA4;
		LOC3 = !(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)));
		LA4: ;
		if (!LOC3) goto LA5;
		goto BeforeRet;
	}
	LA5: ;
	callee = (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
	{
		NIM_BOOL LOC9;
		NIM_BOOL LOC10;
		Tnode191813* call;
		NIM_BOOL allconst;
		LOC9 = 0;
		LOC10 = 0;
		LOC10 = !(((*callee).magic == ((NU16) 0)));
		if (!(LOC10)) goto LA11;
		LOC10 = ((TMP3215[(*callee).magic/8] &(1<<((*callee).magic%8)))!=0);
		LA11: ;
		LOC9 = LOC10;
		if (!(LOC9)) goto LA12;
		LOC9 = !(((*n).typ == NIM_NIL));
		LA12: ;
		if (!LOC9) goto LA13;
		call = newnodeit_193807(((NU8) 27), (*n).info, (*n).typ);
		add_192164(call, (*n).kindU.S6.sons->data[((NI) 0)]);
		allconst = NIM_TRUE;
		{
			NI i_445513;
			NI HEX3Atmp_445826;
			NI LOC16;
			NI res_445829;
			i_445513 = 0;
			HEX3Atmp_445826 = 0;
			LOC16 = 0;
			LOC16 = len_192097(n);
			HEX3Atmp_445826 = (LOC16 - 1);
			res_445829 = ((NI) 1);
			{
				while (1) {
					Tnode191813* a;
					if (!(res_445829 <= HEX3Atmp_445826)) goto LA18;
					i_445513 = res_445829;
					a = getconstexpr_257004((*c).module, (*n).kindU.S6.sons->data[i_445513]);
					{
						if (!(a == NIM_NIL)) goto LA21;
						allconst = NIM_FALSE;
						a = (*n).kindU.S6.sons->data[i_445513];
						{
							if (!((*a).kind == ((NU8) 58))) goto LA25;
							a = (*a).kindU.S6.sons->data[((NI) 1)];
						}
						LA25: ;
					}
					LA21: ;
					add_192164(call, a);
					res_445829 += ((NI) 1);
				} LA18: ;
			}
		}
		{
			if (!allconst) goto LA29;
			result = getconstexpr_257004((*c).module, call);
			{
				if (!result == 0) goto LA33;
				result = n;
			}
			goto LA31;
			LA33: ;
			{
				goto BeforeRet;
			}
			LA31: ;
		}
		LA29: ;
		asgnRefNoCycle((void**) (&(*result).typ), getintervaltype_257365((*callee).magic, call));
	}
	LA13: ;
	{
		{
			NI LOC39;
			Ttypeseq191845* LOC57;
			TY350187 LOC58;
			LOC39 = 0;
			LOC39 = len_192097(n);
			if (!(((NI) 1) < LOC39)) goto LA40;
			{
				NI i_445571;
				NI HEX3Atmp_445834;
				NI LOC43;
				NI res_445837;
				i_445571 = 0;
				HEX3Atmp_445834 = 0;
				LOC43 = 0;
				LOC43 = len_192097(n);
				HEX3Atmp_445834 = (LOC43 - 1);
				res_445837 = ((NI) 1);
				{
					while (1) {
						if (!(res_445837 <= HEX3Atmp_445834)) goto LA45;
						i_445571 = res_445837;
						{
							NIM_BOOL LOC48;
							NIM_BOOL LOC49;
							Tnode191813* LOC50;
							Tnode191813* LOC52;
							Tnode191813* LOC54;
							LOC48 = 0;
							LOC49 = 0;
							LOC50 = 0;
							LOC50 = HEX5BHEX5D_192244(n, i_445571);
							LOC49 = (*LOC50).typ == 0;
							if (LOC49) goto LA51;
							LOC52 = 0;
							LOC52 = HEX5BHEX5D_192244(n, i_445571);
							LOC49 = !(((*(*LOC52).typ).kind == ((NU8) 59)));
							LA51: ;
							LOC48 = LOC49;
							if (LOC48) goto LA53;
							LOC54 = 0;
							LOC54 = HEX5BHEX5D_192244(n, i_445571);
							LOC48 = !((((*(*LOC54).typ).flags &(1<<((((NU8) 9))&31)))!=0));
							LA53: ;
							if (!LOC48) goto LA55;
							goto LA36;
						}
						LA55: ;
						res_445837 += ((NI) 1);
					} LA45: ;
				}
			}
			LOC57 = 0;
			LOC57 = (Ttypeseq191845*) newSeq((&NTI191845), 1);
			memset((void*)LOC58, 0, sizeof(LOC58));
			LOC58[0] = (*n).typ;
			asgnRefNoCycle((void**) (&LOC57->data[0]), LOC58[0]);
			asgnRefNoCycle((void**) (&(*n).typ), newtypewithsons_245807(c, ((NU8) 59), LOC57));
			(*(*n).typ).flags |= ((NI32)1)<<((((NU8) 9))%(sizeof(NI32)*8));
		}
		LA40: ;
	} LA36: ;
	{
		NIM_BOOL LOC61;
		NIM_BOOL LOC62;
		Tnode191813* call;
		LOC61 = 0;
		LOC62 = 0;
		LOC62 = !(((8389632 & (*callee).flags) == 0));
		if (!(LOC62)) goto LA63;
		LOC62 = ((48 & (*callee).flags) == 0);
		LA63: ;
		LOC61 = LOC62;
		if (!(LOC61)) goto LA64;
		LOC61 = !(((*n).typ == NIM_NIL));
		LA64: ;
		if (!LOC61) goto LA65;
		{
			NIM_BOOL LOC69;
			LOC69 = 0;
			LOC69 = !((((*callee).flags &(1<<((((NU8) 23))&31)))!=0));
			if (!(LOC69)) goto LA70;
			LOC69 = !(((goptions_155126 &(1<<((((NU8) 20))&31)))!=0));
			LA70: ;
			if (!LOC69) goto LA71;
			goto BeforeRet;
		}
		LA71: ;
		{
			if (!!(((TMP3215[(*callee).magic/8] &(1<<((*callee).magic%8)))!=0))) goto LA75;
			goto BeforeRet;
		}
		LA75: ;
		{
			NIM_BOOL LOC79;
			LOC79 = 0;
			LOC79 = !(((69632 &(1<<(((*callee).kind)&31)))!=0));
			if (LOC79) goto LA80;
			LOC79 = isgenericroutine_196652(callee);
			LA80: ;
			if (!LOC79) goto LA81;
			goto BeforeRet;
		}
		LA81: ;
		{
			NIM_BOOL LOC85;
			Ttype191849* LOC87;
			LOC85 = 0;
			LOC85 = !(((*n).typ == NIM_NIL));
			if (!(LOC85)) goto LA86;
			LOC87 = 0;
			LOC87 = typeallowed_229654((*n).typ, ((NU8) 10));
			LOC85 = !((LOC87 == NIM_NIL));
			LA86: ;
			if (!LOC85) goto LA88;
			goto BeforeRet;
		}
		LA88: ;
		call = newnodeit_193807(((NU8) 27), (*n).info, (*n).typ);
		add_192164(call, (*n).kindU.S6.sons->data[((NI) 0)]);
		{
			NI i_445780;
			NI HEX3Atmp_445842;
			NI LOC91;
			NI res_445845;
			i_445780 = 0;
			HEX3Atmp_445842 = 0;
			LOC91 = 0;
			LOC91 = len_192097(n);
			HEX3Atmp_445842 = (LOC91 - 1);
			res_445845 = ((NI) 1);
			{
				while (1) {
					Tnode191813* a;
					if (!(res_445845 <= HEX3Atmp_445842)) goto LA93;
					i_445780 = res_445845;
					a = getconstexpr_257004((*c).module, (*n).kindU.S6.sons->data[i_445780]);
					{
						if (!(a == NIM_NIL)) goto LA96;
						result = n;
						goto BeforeRet;
					}
					LA96: ;
					add_192164(call, a);
					res_445845 += ((NI) 1);
				} LA93: ;
			}
		}
		{
			if (!(((*callee).flags &(1<<((((NU8) 23))&31)))!=0)) goto LA100;
			result = evalstaticexpr_398832((*c).module, call, (*(*c).p).owner);
			{
				NimStringDesc* LOC106;
				if (!result == 0) goto LA104;
				LOC106 = 0;
				LOC106 = rendertree_213058(call, 0);
				localerror_166155((*n).info, ((NU16) 208), LOC106);
			}
			goto LA102;
			LA104: ;
			{
				result = fixuptypeaftereval_411201(c, result, n);
			}
			LA102: ;
		}
		goto LA98;
		LA100: ;
		{
			result = evalconstexpr_398821((*c).module, call);
			{
				if (!result == 0) goto LA111;
				result = n;
			}
			goto LA109;
			LA111: ;
			{
				result = fixuptypeaftereval_411201(c, result, n);
			}
			LA109: ;
		}
		LA98: ;
	}
	LA65: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, aftercallactions_446367)(Tcontext245023* c, Tnode191813* n, Tnode191813* orig, NU16 flags) {
	Tnode191813* result;
	Tsym191843* callee;
	result = 0;
	result = n;
	callee = (*(*result).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
	switch ((*callee).kind) {
	case ((NU8) 17):
	{
		result = semmacroexpr_411066(c, result, orig, callee, flags);
	}
	break;
	case ((NU8) 18):
	{
		result = semtemplateexpr_411055(c, result, callee, flags);
	}
	break;
	default:
	{
		semfinishoperands_351385(c, result);
		activate_410327(c, result);
		fixabstracttype_444407(c, result);
		analyseifaddresstakenincall_444851(c, result);
		{
			if (!!(((*callee).magic == ((NU16) 0)))) goto LA6;
			result = magicsafteroverloadresolution_445354(c, result, flags);
		}
		LA6: ;
	}
	break;
	}
	{
		if (!((*c).intypeclass == ((NI) 0))) goto LA10;
		result = evalatcompiletime_445429(c, result);
	}
	LA10: ;
	return result;
}

N_NIMCALL(Tnode191813*, semdirectop_411032)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Tnode191813* norig;
	result = 0;
	norig = copytree_196028(n);
	result = semoverloadedcallanalyseeffects_445901(c, n, norig, flags);
	{
		if (!!((result == NIM_NIL))) goto LA3;
		result = aftercallactions_446367(c, result, norig, flags);
	}
	goto LA1;
	LA3: ;
	{
		result = errornode_246160(c, n);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, evalpattern_411546)(Tcontext245023* c, Tnode191813* n, Tnode191813* orig) {
	Tnode191813* result;
	NimStringDesc* rule;
	Tsym191843* s;
	result = 0;
	{
		NIM_BOOL LOC3;
		NimStringDesc* LOC7;
		LOC3 = 0;
		LOC3 = ((*n).kind == ((NU8) 27));
		if (!(LOC3)) goto LA4;
		LOC3 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3));
		LA4: ;
		if (!!(LOC3)) goto LA5;
		LOC7 = 0;
		LOC7 = HEX24_166306(TMP3190);
		internalerror_166218(LOC7);
	}
	LA5: ;
	rule = 0;
	{
		NIM_BOOL LOC10;
		LOC10 = 0;
		LOC10 = ((goptions_155126 &(1<<((((NU8) 12))&31)))!=0);
		if (!(LOC10)) goto LA11;
		LOC10 = ((gnotes_165011 &(IL64(1)<<(((((NU16) 276)- 230))&IL64(63))))!=0);
		LA11: ;
		if (!LOC10) goto LA12;
		rule = rendertree_213058(n, 4);
	}
	LA12: ;
	s = (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
	switch ((*s).kind) {
	case ((NU8) 17):
	{
		result = semmacroexpr_411066(c, n, orig, s, 0);
	}
	break;
	case ((NU8) 18):
	{
		result = semtemplateexpr_411055(c, n, s, 0);
	}
	break;
	default:
	{
		result = semdirectop_411032(c, n, 0);
	}
	break;
	}
	{
		NIM_BOOL LOC19;
		NimStringDesc* LOC23;
		NimStringDesc* LOC24;
		LOC19 = 0;
		LOC19 = ((goptions_155126 &(1<<((((NU8) 12))&31)))!=0);
		if (!(LOC19)) goto LA20;
		LOC19 = ((gnotes_165011 &(IL64(1)<<(((((NU16) 276)- 230))&IL64(63))))!=0);
		LA20: ;
		if (!LOC19) goto LA21;
		LOC23 = 0;
		LOC24 = 0;
		LOC24 = rendertree_213058(result, 4);
		LOC23 = rawNewString(rule->Sup.len + LOC24->Sup.len + 7);
appendString(LOC23, rule);
appendString(LOC23, ((NimStringDesc*) &TMP3296));
appendString(LOC23, LOC24);
appendString(LOC23, ((NimStringDesc*) &TMP3176));
		message_166188((*orig).info, ((NU16) 276), LOC23);
	}
	LA21: ;
	return result;
}

N_NIMCALL(Tnode191813*, applypatterns_411630)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = n;
	{
		NI i_411662;
		NI HEX3Atmp_412013;
		NI res_412016;
		i_411662 = 0;
		HEX3Atmp_412013 = 0;
		HEX3Atmp_412013 = (((*c).patterns ? (*c).patterns->Sup.len : 0) - 1);
		res_412016 = HEX3Atmp_412013;
		{
			while (1) {
				Tsym191843* pattern;
				if (!(((NI) 0) <= res_412016)) goto LA3;
				i_411662 = res_412016;
				pattern = (*c).patterns->data[i_411662];
				{
					Tnode191813* x;
					if (!!(pattern == 0)) goto LA6;
					x = applyrule_402303(c, pattern, result);
					{
						if (!!(x == 0)) goto LA10;
						evaltemplatecounter_384256 += ((NI) 1);
						{
							if (!(((NI) 100) < evaltemplatecounter_384256)) goto LA14;
							globalerror_166134((*n).info, ((NU16) 183), ((NimStringDesc*) &TMP2991));
						}
						LA14: ;
						asgnRefNoCycle((void**) (&(*c).patterns->data[i_411662]), NIM_NIL);
						{
							if (!((*x).kind == ((NU8) 115))) goto LA18;
							asgnRefNoCycle((void**) (&(*x).kindU.S6.sons->data[((NI) 1)]), evalpattern_411546(c, (*x).kindU.S6.sons->data[((NI) 1)], result));
							result = flattenstmts_220759(x);
						}
						goto LA16;
						LA18: ;
						{
							result = evalpattern_411546(c, x, result);
						}
						LA16: ;
						evaltemplatecounter_384256 -= ((NI) 1);
						asgnRefNoCycle((void**) (&(*c).patterns->data[i_411662]), pattern);
					}
					LA10: ;
				}
				LA6: ;
				res_412016 -= ((NI) 1);
			} LA3: ;
		}
	}
	return result;
}

N_NIMCALL(Tnode191813*, hlo_411542)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
{	result = 0;
	(*c).hloloopdetector += ((NI) 1);
	{
		if (!(((NI) 300) < (*c).hloloopdetector)) goto LA3;
		result = n;
		goto BeforeRet;
	}
	LA3: ;
	switch ((*n).kind) {
	case ((NU8) 82):
	case ((NU8) 83):
	case ((NU8) 51) ... ((NU8) 52):
	case ((NU8) 79) ... ((NU8) 81):
	case ((NU8) 84):
	{
		result = n;
	}
	break;
	default:
	{
		{
			NIM_BOOL LOC9;
			NIM_BOOL LOC10;
			LOC9 = 0;
			LOC10 = 0;
			LOC10 = ((*n).kind == ((NU8) 74) || (*n).kind == ((NU8) 73) || (*n).kind == ((NU8) 35) || (*n).kind == ((NU8) 36));
			if (!(LOC10)) goto LA11;
			LOC10 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3));
			LA11: ;
			LOC9 = LOC10;
			if (!(LOC9)) goto LA12;
			LOC9 = ((520 & (*(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).flags) == 520);
			LA12: ;
			if (!LOC9) goto LA13;
			result = n;
			goto BeforeRet;
		}
		LA13: ;
		result = applypatterns_411630(c, n);
		{
			if (!(result == n)) goto LA17;
			{
				NI i_412125;
				NI HEX3Atmp_412142;
				NI LOC20;
				NI res_412145;
				i_412125 = 0;
				HEX3Atmp_412142 = 0;
				LOC20 = 0;
				LOC20 = safelen_192125(result);
				HEX3Atmp_412142 = (LOC20 - 1);
				res_412145 = ((NI) 0);
				{
					while (1) {
						Tnode191813* a;
						Tnode191813* h;
						if (!(res_412145 <= HEX3Atmp_412142)) goto LA22;
						i_412125 = res_412145;
						a = (*result).kindU.S6.sons->data[i_412125];
						h = hlo_411542(c, a);
						{
							if (!!((h == a))) goto LA25;
							asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_412125]), h);
						}
						LA25: ;
						res_412145 += ((NI) 1);
					} LA22: ;
				}
			}
		}
		goto LA15;
		LA17: ;
		{
			{
				NIM_BOOL LOC30;
				LOC30 = 0;
				LOC30 = isemptytype_196934((*n).typ);
				if (!(LOC30)) goto LA31;
				LOC30 = isemptytype_196934((*result).typ);
				LA31: ;
				if (!LOC30) goto LA32;
			}
			goto LA28;
			LA32: ;
			{
				result = fitnode_410245(c, (*n).typ, result);
			}
			LA28: ;
			result = commonoptimizations_370597((*c).module, result);
			result = hlo_411542(c, result);
			result = commonoptimizations_370597((*c).module, result);
		}
		LA15: ;
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, hlobody_412161)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
{	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = (((*c).patterns ? (*c).patterns->Sup.len : 0) == ((NI) 0));
		if (LOC3) goto LA4;
		LOC3 = !(((goptions_155126 &(1<<((((NU8) 21))&31)))!=0));
		LA4: ;
		if (!LOC3) goto LA5;
		result = n;
		goto BeforeRet;
	}
	LA5: ;
	(*c).hloloopdetector = ((NI) 0);
	result = hlo_411542(c, n);
	}BeforeRet: ;
	return result;
}

static N_INLINE(void, popproccon_245390)(Tcontext245023* c) {
	asgnRef((void**) (&(*c).p), (*(*c).p).next);
}

N_NIMCALL(void, fixupinstantiatedsymbols_413063)(Tcontext245023* c, Tsym191843* s) {
	{
		NI i_413087;
		NI HEX3Atmp_413097;
		NI res_413100;
		i_413087 = 0;
		HEX3Atmp_413097 = 0;
		HEX3Atmp_413097 = (NI)(((*c).generics ? (*c).generics->Sup.len : 0) - ((NI) 1));
		res_413100 = ((NI) 0);
		{
			while (1) {
				if (!(res_413100 <= HEX3Atmp_413097)) goto LA3;
				i_413087 = res_413100;
				{
					Tsym191843* oldprc;
					Tscope191837* LOC8;
					Tnode191813* n;
					Tnode191813* LOC9;
					if (!((*(*c).generics->data[i_413087].genericsym).Sup.id == (*s).Sup.id)) goto LA6;
					oldprc = (*(*c).generics->data[i_413087].inst).sym;
					pushinfocontext_165189((*oldprc).info);
					LOC8 = 0;
					LOC8 = openscope_250091(c);
					n = (*oldprc).ast;
					LOC9 = 0;
					LOC9 = getbody_236647(s);
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), copytree_196028(LOC9));
					instantiatebody_412941(c, n, NIM_NIL, oldprc);
					closescope_250111(c);
					popinfocontext_165208();
				}
				LA6: ;
				res_413100 += ((NI) 1);
			} LA3: ;
		}
	}
}

N_NIMCALL(Tsym191843*, searchforborrowproc_416322)(Tcontext245023* c, Tscope191837* startscope, Tsym191843* fn) {
	Tsym191843* result;
	Tnode191813* call;
	NIM_BOOL hasdistinct;
	Tnode191813* LOC1;
	result = 0;
	call = newnodei_193351(((NU8) 27), (*fn).info);
	hasdistinct = NIM_FALSE;
	LOC1 = 0;
	LOC1 = newidentnode_193313((*fn).name, (*fn).info);
	add_192164(call, LOC1);
	{
		NI i_416354;
		NI HEX3Atmp_416409;
		NI LOC3;
		NI res_416412;
		i_416354 = 0;
		HEX3Atmp_416409 = 0;
		LOC3 = 0;
		LOC3 = len_192097((*(*fn).typ).n);
		HEX3Atmp_416409 = (LOC3 - 1);
		res_416412 = ((NI) 1);
		{
			while (1) {
				Tnode191813* param;
				Ttype191849* t;
				Ttype191849* LOC12;
				Tnode191813* LOC13;
				if (!(res_416412 <= HEX3Atmp_416409)) goto LA5;
				i_416354 = res_416412;
				param = (*(*(*fn).typ).n).kindU.S6.sons->data[i_416354];
				t = skiptypes_195167((*param).typ, IL64(211106240964608));
				{
					NIM_BOOL LOC8;
					LOC8 = 0;
					LOC8 = ((*t).kind == ((NU8) 13));
					if (LOC8) goto LA9;
					LOC8 = ((*(*param).typ).kind == ((NU8) 13));
					LA9: ;
					if (!LOC8) goto LA10;
					hasdistinct = NIM_TRUE;
				}
				LA10: ;
				LOC12 = 0;
				LOC12 = baseofdistinct_230320(t);
				LOC13 = 0;
				LOC13 = newnodeit_193807(((NU8) 1), (*fn).info, LOC12);
				add_192164(call, LOC13);
				res_416412 += ((NI) 1);
			} LA5: ;
		}
	}
	{
		Tnode191813* resolved;
		NU32 LOC18;
		if (!hasdistinct) goto LA16;
		LOC18 = 0;
		LOC18 |=(1<<((NI32)((*fn).kind)%(sizeof(NI32)*8)));
		resolved = semoverloadedcall_415892(c, call, call, LOC18);
		{
			if (!!((resolved == NIM_NIL))) goto LA21;
			result = (*(*resolved).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
		}
		LA21: ;
	}
	LA16: ;
	return result;
}

N_NIMCALL(void, semborrow_438975)(Tcontext245023* c, Tnode191813* n, Tsym191843* s) {
	Tsym191843* b;
	b = searchforborrowproc_416322(c, (*(*c).currentscope).parent, s);
	{
		if (!!((b == NIM_NIL))) goto LA3;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), newsymnode_193325(b));
	}
	goto LA1;
	LA3: ;
	{
		localerror_166155((*n).info, ((NU16) 139), ((NimStringDesc*) &TMP2991));
	}
	LA1: ;
}

N_NIMCALL(void, sideeffectscheck_413116)(Tcontext245023* c, Tsym191843* s) {
	{
		if (!((3072 & (*s).flags) == 3072)) goto LA3;
		localerror_166155((*s).info, ((NU16) 217), (*(*s).name).s);
	}
	LA3: ;
}

N_NIMCALL(Tnode191813*, semprocaux_439890)(Tcontext245023* c, Tnode191813* n, NU8 kind, Tspecialwords173012 validpragmas, NU8 phase) {
	Tnode191813* result;
	Tsym191843* s;
	NIM_BOOL typeisdetermined;
	NIM_BOOL isanon;
	Tscope191837* oldscope;
	Tscope191837* LOC25;
	Tnode191813* gp;
	Tsym191843* proto;
{	result = 0;
	result = semprocannotation_439127(c, n, validpragmas);
	{
		if (!!((result == NIM_NIL))) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	result = n;
	checksonslen_246249(n, ((NI) 7));
	s = 0;
	typeisdetermined = NIM_FALSE;
	isanon = NIM_FALSE;
	{
		Tnode191813* LOC7;
		LOC7 = 0;
		LOC7 = HEX5BHEX5D_192244(n, ((NI) 0));
		if (!!(((*LOC7).kind == ((NU8) 3)))) goto LA8;
		{
			Tnode191813* LOC12;
			Tsym191843* LOC15;
			LOC12 = 0;
			LOC12 = HEX5BHEX5D_192244(n, ((NI) 0));
			if (!((*LOC12).kind == ((NU8) 1))) goto LA13;
			LOC15 = 0;
			LOC15 = getcurrowner_245255();
			s = newsym_192655(kind, idanon_168495, LOC15, (*n).info);
			isanon = NIM_TRUE;
		}
		goto LA10;
		LA13: ;
		{
			s = semidentdef_435142(c, (*n).kindU.S6.sons->data[((NI) 0)], kind);
		}
		LA10: ;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(s));
		asgnRefNoCycle((void**) (&(*s).ast), n);
		{
			NIM_BOOL LOC19;
			LOC19 = 0;
			LOC19 = (((*(*c).module).flags &(1<<((((NU8) 8))&31)))!=0);
			if (!(LOC19)) goto LA20;
			LOC19 = !((((*(*c).module).flags &(1<<((((NU8) 13))&31)))!=0));
			LA20: ;
			if (!LOC19) goto LA21;
			addinterfaceoverloadablesymat_250746(c, (*c).currentscope, s);
			(*s).flags |= ((NI32)1)<<((((NU8) 4))%(sizeof(NI32)*8));
			goto BeforeRet;
		}
		LA21: ;
	}
	goto LA5;
	LA8: ;
	{
		Tnode191813* LOC24;
		LOC24 = 0;
		LOC24 = HEX5BHEX5D_192244(n, ((NI) 0));
		s = (*LOC24).kindU.S4.sym;
		asgnRefNoCycle((void**) (&(*s).owner), getcurrowner_245255());
		typeisdetermined = ((*s).typ == NIM_NIL);
		asgnRefNoCycle((void**) (&(*s).ast), n);
	}
	LA5: ;
	oldscope = (*c).currentscope;
	pushowner_245260(s);
	LOC25 = 0;
	LOC25 = openscope_250091(c);
	gp = 0;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1)))) goto LA28;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), semgenericparamlist_422951(c, (*n).kindU.S6.sons->data[((NI) 2)], NIM_NIL));
		gp = (*n).kindU.S6.sons->data[((NI) 2)];
	}
	goto LA26;
	LA28: ;
	{
		gp = newnodei_193351(((NU8) 75), (*n).info);
	}
	LA26: ;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 3)]).kind == ((NU8) 1)))) goto LA33;
		semparamlist_410284(c, (*n).kindU.S6.sons->data[((NI) 3)], gp, s);
		{
			NI LOC37;
			LOC37 = 0;
			LOC37 = sonslen_194403(gp);
			if (!(((NI) 0) < LOC37)) goto LA38;
			{
				if (!((*(*n).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1))) goto LA42;
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), gp);
			}
			LA42: ;
		}
		LA38: ;
	}
	goto LA31;
	LA33: ;
	{
		asgnRefNoCycle((void**) (&(*s).typ), newproctype_421342(c, (*n).info, NIM_NIL));
	}
	LA31: ;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1)))) goto LA47;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), sempattern_424548(c, (*n).kindU.S6.sons->data[((NI) 1)]));
	}
	LA47: ;
	{
		if (!((49152 &(1<<(((*s).kind)&31)))!=0)) goto LA51;
		(*(*s).typ).flags |= ((NI32)1)<<((((NU8) 14))%(sizeof(NI32)*8));
	}
	LA51: ;
	proto = searchforproc_260278(c, oldscope, s);
	{
		if (!(proto == NIM_NIL)) goto LA55;
		{
			if (!((*s).kind == ((NU8) 15))) goto LA59;
			(*(*s).typ).callconv = ((NU8) 8);
		}
		goto LA57;
		LA59: ;
		{
			Toptionentry245005* LOC62;
			LOC62 = 0;
			LOC62 = lastoptionentry_245187(c);
			(*(*s).typ).callconv = (*LOC62).defaultcc;
		}
		LA57: ;
		{
			if (!(((*s).flags &(1<<((((NU8) 31))&31)))!=0)) goto LA65;
		}
		goto LA63;
		LA65: ;
		{
			if (!((520256 &(1<<((kind)&31)))!=0)) goto LA68;
			{
				if (!!(typeisdetermined)) goto LA72;
				addinterfaceoverloadablesymat_250746(c, oldscope, s);
			}
			LA72: ;
		}
		goto LA63;
		LA68: ;
		{
			{
				if (!!(typeisdetermined)) goto LA77;
				addinterfacedeclat_250677(c, oldscope, s);
			}
			LA77: ;
		}
		LA63: ;
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 4)]).kind == ((NU8) 1)))) goto LA81;
			pragma_261069(c, s, (*n).kindU.S6.sons->data[((NI) 4)], validpragmas);
		}
		goto LA79;
		LA81: ;
		{
			implicitpragmas_264505(c, s, n, validpragmas);
		}
		LA79: ;
	}
	goto LA53;
	LA55: ;
	{
		Tscope191837* LOC93;
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 4)]).kind == ((NU8) 1)))) goto LA87;
			localerror_166155((*(*n).kindU.S6.sons->data[((NI) 4)]).info, ((NU16) 136), ((NimStringDesc*) &TMP2991));
		}
		LA87: ;
		{
			if (!!((((*proto).flags &(1<<((((NU8) 4))&31)))!=0))) goto LA91;
			wrongredefinition_250588((*n).info, (*(*proto).name).s);
		}
		LA91: ;
		(*proto).flags &= ~(((NI32)1) << ((((NU8) 4)) % (sizeof(NI32)*8)));
		closescope_250111(c);
		LOC93 = 0;
		LOC93 = openscope_250091(c);
		{
			if (!!(((*(*(*proto).ast).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1)))) goto LA96;
			addgenericparamlisttoscope_438141(c, (*(*proto).ast).kindU.S6.sons->data[((NI) 2)]);
		}
		LA96: ;
		addparams_410293(c, (*(*proto).typ).n, (*proto).kind);
		(*proto).info = (*s).info;
		asgnRefNoCycle((void**) (&(*s).typ), (*proto).typ);
		s = proto;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), (*(*proto).ast).kindU.S6.sons->data[((NI) 2)]);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 3)]), (*(*proto).ast).kindU.S6.sons->data[((NI) 3)]);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 4)]), (*(*proto).ast).kindU.S6.sons->data[((NI) 4)]);
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA100;
			internalerror_166199((*n).info, ((NimStringDesc*) &TMP3154));
		}
		LA100: ;
		asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym), proto);
		{
			NIM_BOOL LOC104;
			NimStringDesc* LOC108;
			LOC104 = 0;
			LOC104 = importantcomments_155164();
			if (!(LOC104)) goto LA105;
			LOC104 = !((*(*proto).ast).comment == 0);
			LA105: ;
			if (!LOC104) goto LA106;
			LOC108 = 0;
			LOC108 = (*n).comment; (*n).comment = copyStringRC1((*(*proto).ast).comment);
			if (LOC108) nimGCunrefNoCycle(LOC108);
		}
		LA106: ;
		asgnRefNoCycle((void**) (&(*proto).ast), n);
		popowner_245266();
		pushowner_245260(s);
	}
	LA53: ;
	(*s).options = goptions_155126;
	{
		NIM_BOOL LOC111;
		LOC111 = 0;
		LOC111 = (((*s).flags &(1<<((((NU8) 30))&31)))!=0);
		if (LOC111) goto LA112;
		LOC111 = ((NU8)((*(*s).name).s->data[((NI) 0)]) == (NU8)(61));
		LA112: ;
		if (!LOC111) goto LA113;
		semoverride_439632(c, s, n);
	}
	LA113: ;
	{
		NIM_BOOL usepseudogenerics;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 6)]).kind == ((NU8) 1)))) goto LA117;
		{
			if (!(((*s).flags &(1<<((((NU8) 26))&31)))!=0)) goto LA121;
			localerror_166155((*(*n).kindU.S6.sons->data[((NI) 6)]).info, ((NU16) 137), (*(*s).name).s);
		}
		LA121: ;
		usepseudogenerics = ((393216 &(1<<((kind)&31)))!=0);
		{
			NIM_BOOL LOC125;
			LOC125 = 0;
			LOC125 = ((*(*n).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1));
			if (LOC125) goto LA126;
			LOC125 = usepseudogenerics;
			LA126: ;
			if (!LOC125) goto LA127;
			{
				if (!!(usepseudogenerics)) goto LA131;
				paramstypecheck_411015(c, (*s).typ);
			}
			LA131: ;
			pushproccon_245358(c, s);
			(*(*c).p).wasforwarded = !((proto == NIM_NIL));
			maybeaddresult_410301(c, s, n);
			{
				Tnode191813* sembody;
				Tnode191813* LOC137;
				if (!!((((*s).flags &(1<<((((NU8) 5))&31)))!=0))) goto LA135;
				LOC137 = 0;
				LOC137 = semprocbody_410238(c, (*n).kindU.S6.sons->data[((NI) 6)]);
				sembody = hlobody_412161(c, LOC137);
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), transformbody_371118((*c).module, sembody, s));
			}
			LA135: ;
			popproccon_245390(c);
		}
		goto LA123;
		LA127: ;
		{
			Tscope191837* LOC147;
			{
				NIM_BOOL LOC141;
				Tident168021* LOC145;
				Tsym191843* LOC146;
				LOC141 = 0;
				LOC141 = !(((*(*s).typ).sons->data[((NI) 0)] == NIM_NIL));
				if (!(LOC141)) goto LA142;
				LOC141 = !(((49152 &(1<<((kind)&31)))!=0));
				LA142: ;
				if (!LOC141) goto LA143;
				LOC145 = 0;
				LOC145 = getident_168463(((NimStringDesc*) &TMP3027));
				LOC146 = 0;
				LOC146 = newsym_192655(((NU8) 0), LOC145, NIM_NIL, (*n).info);
				adddecl_250607(c, LOC146);
			}
			LA143: ;
			LOC147 = 0;
			LOC147 = openscope_250091(c);
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), semgenericstmt_416688(c, (*n).kindU.S6.sons->data[((NI) 6)]));
			closescope_250111(c);
			fixupinstantiatedsymbols_413063(c, s);
		}
		LA123: ;
		{
			if (!(((*s).flags &(1<<((((NU8) 5))&31)))!=0)) goto LA150;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), emptynode_192807);
		}
		LA150: ;
	}
	goto LA115;
	LA117: ;
	{
		{
			if (!!((proto == NIM_NIL))) goto LA155;
			localerror_166155((*n).info, ((NU16) 138), (*(*proto).name).s);
		}
		LA155: ;
		{
			NIM_BOOL LOC159;
			LOC159 = 0;
			LOC159 = ((67108896 & (*s).flags) == 0);
			if (!(LOC159)) goto LA160;
			LOC159 = ((*s).magic == ((NU16) 0));
			LA160: ;
			if (!LOC159) goto LA161;
			(*s).flags |= ((NI32)1)<<((((NU8) 4))%(sizeof(NI32)*8));
		}
		goto LA157;
		LA161: ;
		{
			if (!(((*s).flags &(1<<((((NU8) 26))&31)))!=0)) goto LA164;
			semborrow_438975(c, n, s);
		}
		goto LA157;
		LA164: ;
		LA157: ;
	}
	LA115: ;
	sideeffectscheck_413116(c, s);
	closescope_250111(c);
	popowner_245266();
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1)))) goto LA168;
		(*c).patterns = (Tsymseq191815*) incrSeq(&((*c).patterns)->Sup, sizeof(Tsym191843*));
		asgnRefNoCycle((void**) (&(*c).patterns->data[(*c).patterns->Sup.len-1]), s);
	}
	LA168: ;
	{
		if (!isanon) goto LA172;
		asgnRefNoCycle((void**) (&(*result).typ), (*s).typ);
	}
	LA172: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, determinetype_413736)(Tcontext245023* c, Tsym191843* s) {
	Tnode191813* LOC5;
{	{
		if (!!(((*s).typ == NIM_NIL))) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	LOC5 = 0;
	LOC5 = semprocaux_439890(c, (*s).ast, (*s).kind, TMP3349, ((NU8) 1));
	}BeforeRet: ;
}

N_NIMCALL(void, pickbestcandidate_413740)(Tcontext245023* c, Tnode191813* headsymbol, Tnode191813* n, Tnode191813* orig, Tnode191813* initialbinding, NU32 filter, Tcandidate345209* best, Tcandidate345209* alt, Tsymseq191815** errors) {
	Toverloaditer250431 o;
	Tsym191843* symx;
	NI symscope;
	TY413757* syms;
	Tcandidate345209 z;
{	memset((void*)(&o), 0, sizeof(o));
	symx = initoverloaditer_251108((&o), c, headsymbol);
	symscope = lastoverloadscope_251259((&o));
	syms = (TY413757*) newSeq((&NTI413757), 0);
	{
		while (1) {
			if (!!((symx == NIM_NIL))) goto LA2;
			{
				TY413758 LOC7;
				if (!((filter &(1<<(((*symx).kind)&31)))!=0)) goto LA5;
				memset((void*)(&LOC7), 0, sizeof(LOC7));
				LOC7.Field0 = symx;
				LOC7.Field1 = lastoverloadscope_251259((&o));
				syms = (TY413757*) incrSeq(&(syms)->Sup, sizeof(TY413758));
				asgnRefNoCycle((void**) (&syms->data[syms->Sup.len-1].Field0), LOC7.Field0);
				syms->data[syms->Sup.len-1].Field1 = LOC7.Field1;
			}
			LA5: ;
			symx = nextoverloaditer_251277((&o), c, headsymbol);
		} LA2: ;
	}
	{
		if (!((syms ? syms->Sup.len : 0) == ((NI) 0))) goto LA10;
		goto BeforeRet;
	}
	LA10: ;
	memset((void*)(&z), 0, sizeof(z));
	initcandidate_345301(c, best, syms->data[((NI) 0)].Field0, initialbinding, symscope);
	initcandidate_345301(c, alt, syms->data[((NI) 0)].Field0, initialbinding, symscope);
	(*best).state = ((NU8) 2);
	{
		NI i_413847;
		NI HEX3Atmp_414087;
		NI res_414090;
		i_413847 = 0;
		HEX3Atmp_414087 = 0;
		HEX3Atmp_414087 = ((syms ? syms->Sup.len : 0) - 1);
		res_414090 = ((NI) 0);
		{
			while (1) {
				Tsym191843* sym;
				if (!(res_414090 <= HEX3Atmp_414087)) goto LA14;
				i_413847 = res_414090;
				sym = syms->data[i_413847].Field0;
				determinetype_413736(c, sym);
				initcandidate_345301(c, (&z), sym, initialbinding, syms->data[i_413847].Field1);
				z.calleesym = sym;
				matches_351449(c, n, orig, (&z));
				{
					NIM_BOOL LOC17;
					LOC17 = 0;
					LOC17 = HEX3DHEX3D_413853((*errors), NIM_NIL);
					if (!!(LOC17)) goto LA18;
					safeadd_413966(errors, sym);
					{
						NIM_BOOL LOC22;
						LOC22 = 0;
						LOC22 = HEX3DHEX3D_413853(z.errors, NIM_NIL);
						if (!!(LOC22)) goto LA23;
						{
							Tsym191843* err_414034;
							Tsymseq191815* HEX3Atmp_414081;
							NI i_414084;
							NI L_414086;
							err_414034 = 0;
							HEX3Atmp_414081 = 0;
							HEX3Atmp_414081 = z.errors;
							i_414084 = ((NI) 0);
							L_414086 = (HEX3Atmp_414081 ? HEX3Atmp_414081->Sup.len : 0);
							{
								while (1) {
									if (!(i_414084 < L_414086)) goto LA27;
									err_414034 = HEX3Atmp_414081->data[i_414084];
									(*errors) = (Tsymseq191815*) incrSeq(&((*errors))->Sup, sizeof(Tsym191843*));
									asgnRefNoCycle((void**) (&(*errors)->data[(*errors)->Sup.len-1]), err_414034);
									i_414084 += ((NI) 1);
								} LA27: ;
							}
						}
					}
					LA23: ;
				}
				LA18: ;
				{
					if (!(z.state == ((NU8) 1))) goto LA30;
					{
						if (!((49152 &(1<<(((*sym).kind)&31)))!=0)) goto LA34;
						z.exactmatches += ((NI) 200);
					}
					LA34: ;
					switch ((*best).state) {
					case ((NU8) 0):
					case ((NU8) 2):
					{
						genericAssign((void*)(&(*best)), (void*)(&z), (&NTI345209));
					}
					break;
					case ((NU8) 1):
					{
						NI cmp;
						cmp = cmpcandidates_345824((&(*best)), (&z));
						{
							if (!(cmp < ((NI) 0))) goto LA40;
							genericAssign((void*)(&(*best)), (void*)(&z), (&NTI345209));
						}
						goto LA38;
						LA40: ;
						{
							if (!(cmp == ((NI) 0))) goto LA43;
							genericAssign((void*)(&(*alt)), (void*)(&z), (&NTI345209));
						}
						goto LA38;
						LA43: ;
						{
						}
						LA38: ;
					}
					break;
					}
				}
				LA30: ;
				res_414090 += ((NI) 1);
			} LA14: ;
		}
	}
	}BeforeRet: ;
}

static N_INLINE(NimStringDesc*, HEX5BHEX5D_85766)(NimStringDesc* s, Slice85773 x) {
	NimStringDesc* result;
	result = 0;
	result = copyStrLast(s, x.a, x.b);
	return result;
}

N_NIMCALL(NIM_BOOL, samemethoddispatcher_413675)(Tsym191843* a, Tsym191843* b) {
	NIM_BOOL result;
	result = 0;
	result = NIM_FALSE;
	{
		NIM_BOOL LOC3;
		Tnode191813* aa;
		Tnode191813* bb;
		LOC3 = 0;
		LOC3 = ((*a).kind == ((NU8) 13));
		if (!(LOC3)) goto LA4;
		LOC3 = ((*b).kind == ((NU8) 13));
		LA4: ;
		if (!LOC3) goto LA5;
		aa = lastson_194431((*a).ast);
		bb = lastson_194431((*b).ast);
		{
			NIM_BOOL LOC9;
			LOC9 = 0;
			LOC9 = ((*aa).kind == ((NU8) 3));
			if (!(LOC9)) goto LA10;
			LOC9 = ((*bb).kind == ((NU8) 3));
			LA10: ;
			if (!LOC9) goto LA11;
			{
				if (!((*aa).kindU.S4.sym == (*bb).kindU.S4.sym)) goto LA15;
				result = NIM_TRUE;
			}
			LA15: ;
		}
		goto LA7;
		LA11: ;
		{
		}
		LA7: ;
	}
	LA5: ;
	return result;
}

N_NIMCALL(void, resolveoverloads_414359)(Tcontext245023* c, Tnode191813* n, Tnode191813* orig, NU32 filter, Tsymseq191815** errors, Tcandidate345209* Result) {
	Tnode191813* initialbinding;
	Tcandidate345209 alt;
	Tnode191813* f;
	Tnodeseq191807* usedsyms;
	NU8 overloadsstate;
{	initialbinding = 0;
	memset((void*)(&alt), 0, sizeof(alt));
	f = (*n).kindU.S6.sons->data[((NI) 0)];
	{
		if (!((*f).kind == ((NU8) 42))) goto LA3;
		initialbinding = f;
		f = (*f).kindU.S6.sons->data[((NI) 0)];
	}
	goto LA1;
	LA3: ;
	{
		initialbinding = NIM_NIL;
	}
	LA1: ;
	usedsyms = 0;
	gatherusedsyms_414249(c, (&usedsyms));
	{
		NIM_BOOL LOC8;
		Tnode191813* hiddenarg;
		LOC8 = 0;
		LOC8 = HEX3DHEX3D_264718(usedsyms, NIM_NIL);
		if (!!(LOC8)) goto LA9;
		{
			if (!(((NI) 1) < (usedsyms ? usedsyms->Sup.len : 0))) goto LA13;
			hiddenarg = newnode_193607(((NU8) 56), (*n).info, usedsyms, NIM_NIL);
		}
		goto LA11;
		LA13: ;
		{
			hiddenarg = usedsyms->data[((NI) 0)];
		}
		LA11: ;
		insert_414412((&(*n).kindU.S6.sons), hiddenarg, ((NI) 1));
		insert_414412((&(*orig).kindU.S6.sons), hiddenarg, ((NI) 1));
		pickbestcandidate_413740(c, f, n, orig, initialbinding, filter, Result, (&alt), errors);
		{
			if (!!(((*Result).state == ((NU8) 1)))) goto LA18;
			delete_414490((&(*n).kindU.S6.sons), ((NI) 1));
			delete_414490((&(*orig).kindU.S6.sons), ((NI) 1));
		}
		goto LA16;
		LA18: ;
		{
			goto BeforeRet;
		}
		LA16: ;
	}
	LA9: ;
	pickbestcandidate_413740(c, f, n, orig, initialbinding, filter, Result, (&alt), errors);
	overloadsstate = (*Result).state;
	{
		if (!!((overloadsstate == ((NU8) 1)))) goto LA23;
		{
			Tnode191813* calleename;
			Tnode191813* LOC37;
			Slice85773 LOC38;
			TY447930 LOC39;
			Slice85773 LOC40;
			TY447930 LOC41;
			if (!(((*n).flags &(1<<((((NU8) 8))&15)))!=0)) goto LA27;
			{
				NIM_BOOL LOC31;
				NI LOC33;
				NimStringDesc* LOC36;
				LOC31 = 0;
				LOC31 = ((*f).kind == ((NU8) 2));
				if (!(LOC31)) goto LA32;
				LOC33 = 0;
				LOC33 = sonslen_194403(n);
				LOC31 = (((NI) 2) <= LOC33);
				LA32: ;
				if (!!(LOC31)) goto LA34;
				LOC36 = 0;
				LOC36 = HEX24_166306(TMP3350);
				internalerror_166218(LOC36);
			}
			LA34: ;
			LOC37 = 0;
			LOC37 = newstrnode_192643(((NU8) 20), (*(*f).kindU.S5.ident).s);
			calleename = withinfo_193302(LOC37, (*n).info);
			LOC38 = HEX2EHEX2E_105273(((NI) 0), ((NI) 1));
			memset((void*)LOC39, 0, sizeof(LOC39));
			LOC39[0] = NIM_NIL;
			LOC39[1] = HEX5BHEX5D_192244(n, ((NI) 1));
			LOC39[2] = calleename;
			HEX5BHEX5DHEX3D_414619((&(*n).kindU.S6.sons), LOC38, LOC39, 3);
			LOC40 = HEX2EHEX2E_105273(((NI) 0), ((NI) 1));
			memset((void*)LOC41, 0, sizeof(LOC41));
			LOC41[0] = NIM_NIL;
			LOC41[1] = HEX5BHEX5D_192244(orig, ((NI) 1));
			LOC41[2] = calleename;
			HEX5BHEX5DHEX3D_414619((&(*orig).kindU.S6.sons), LOC40, LOC41, 3);
			{
				Tnode191813* op_414891;
				Tident168021* LOC46;
				if (!(((*n).flags &(1<<((((NU8) 10))&15)))!=0)) goto LA44;
				LOC46 = 0;
				LOC46 = getident_168463(((NimStringDesc*) &TMP3352));
				op_414891 = newidentnode_193313(LOC46, (*n).info);
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), op_414891);
				asgnRefNoCycle((void**) (&(*orig).kindU.S6.sons->data[((NI) 0)]), op_414891);
				pickbestcandidate_413740(c, op_414891, n, orig, initialbinding, filter, Result, (&alt), errors);
			}
			LA44: ;
			{
				Tnode191813* op_414908;
				Tident168021* LOC51;
				if (!((5 &(1<<(((*Result).state)&7)))!=0)) goto LA49;
				LOC51 = 0;
				LOC51 = getident_168463(((NimStringDesc*) &TMP3353));
				op_414908 = newidentnode_193313(LOC51, (*n).info);
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), op_414908);
				asgnRefNoCycle((void**) (&(*orig).kindU.S6.sons->data[((NI) 0)]), op_414908);
				pickbestcandidate_413740(c, op_414908, n, orig, initialbinding, filter, Result, (&alt), errors);
			}
			LA49: ;
		}
		goto LA25;
		LA27: ;
		{
			Tnode191813* calleename;
			Slice85773 LOC63;
			NimStringDesc* LOC64;
			Tnode191813* LOC65;
			Tnode191813* callop;
			Tident168021* LOC66;
			Slice85773 LOC67;
			TY447930 LOC68;
			Slice85773 LOC69;
			TY447930 LOC70;
			if (!(((*n).flags &(1<<((((NU8) 9))&15)))!=0)) goto LA53;
			{
				NIM_BOOL LOC57;
				NI LOC59;
				NimStringDesc* LOC62;
				LOC57 = 0;
				LOC57 = ((*f).kind == ((NU8) 2));
				if (!(LOC57)) goto LA58;
				LOC59 = 0;
				LOC59 = sonslen_194403(n);
				LOC57 = (LOC59 == ((NI) 3));
				LA58: ;
				if (!!(LOC57)) goto LA60;
				LOC62 = 0;
				LOC62 = HEX24_166306(TMP3354);
				internalerror_166218(LOC62);
			}
			LA60: ;
			LOC63 = HEX2EHEX2E_105273(((NI) 0), (NI)(((*(*f).kindU.S5.ident).s ? (*(*f).kindU.S5.ident).s->Sup.len : 0) - ((NI) 2)));
			LOC64 = 0;
			LOC64 = HEX5BHEX5D_85766((*(*f).kindU.S5.ident).s, LOC63);
			LOC65 = 0;
			LOC65 = newstrnode_192643(((NU8) 20), LOC64);
			calleename = withinfo_193302(LOC65, (*n).info);
			LOC66 = 0;
			LOC66 = getident_168463(((NimStringDesc*) &TMP3355));
			callop = newidentnode_193313(LOC66, (*n).info);
			LOC67 = HEX2EHEX2E_105273(((NI) 0), ((NI) 1));
			memset((void*)LOC68, 0, sizeof(LOC68));
			LOC68[0] = callop;
			LOC68[1] = HEX5BHEX5D_192244(n, ((NI) 1));
			LOC68[2] = calleename;
			HEX5BHEX5DHEX3D_414619((&(*n).kindU.S6.sons), LOC67, LOC68, 3);
			LOC69 = HEX2EHEX2E_105273(((NI) 0), ((NI) 1));
			memset((void*)LOC70, 0, sizeof(LOC70));
			LOC70[0] = callop;
			LOC70[1] = HEX5BHEX5D_192244(orig, ((NI) 1));
			LOC70[2] = calleename;
			HEX5BHEX5DHEX3D_414619((&(*orig).kindU.S6.sons), LOC69, LOC70, 3);
			pickbestcandidate_413740(c, callop, n, orig, initialbinding, filter, Result, (&alt), errors);
		}
		goto LA25;
		LA53: ;
		LA25: ;
		{
			NIM_BOOL LOC73;
			Tident168021* LOC77;
			LOC73 = 0;
			LOC73 = (overloadsstate == ((NU8) 0));
			if (!(LOC73)) goto LA74;
			LOC73 = ((*Result).state == ((NU8) 0));
			LA74: ;
			if (!LOC73) goto LA75;
			LOC77 = 0;
			LOC77 = considerquotedident_250010(f);
			localerror_166155((*n).info, ((NU16) 61), (*LOC77).s);
			goto BeforeRet;
		}
		goto LA71;
		LA75: ;
		{
			if (!!(((*Result).state == ((NU8) 1)))) goto LA79;
			{
				NimStringDesc* LOC85;
				if (!(((*n).flags &(1<<((((NU8) 11))&15)))!=0)) goto LA83;
				LOC85 = 0;
				LOC85 = rendertree_213058(n, 4);
				localerror_166155((*n).info, ((NU16) 88), LOC85);
			}
			goto LA81;
			LA83: ;
			{
				{
					if (!!(((768 & (*n).flags) == 0))) goto LA89;
					delete_414490((&(*n).kindU.S6.sons), ((NI) 2));
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), f);
				}
				LA89: ;
				unsureAsgnRef((void**) (&(*errors)), (Tsymseq191815*) newSeq((&NTI191815), 0));
				pickbestcandidate_413740(c, f, n, orig, initialbinding, filter, Result, (&alt), errors);
			}
			LA81: ;
			goto BeforeRet;
		}
		goto LA71;
		LA79: ;
		LA71: ;
	}
	LA23: ;
	{
		NIM_BOOL LOC93;
		NIM_BOOL LOC94;
		NI LOC96;
		NIM_BOOL LOC98;
		LOC93 = 0;
		LOC94 = 0;
		LOC94 = (alt.state == ((NU8) 1));
		if (!(LOC94)) goto LA95;
		LOC96 = 0;
		LOC96 = cmpcandidates_345824(Result, (&alt));
		LOC94 = (LOC96 == ((NI) 0));
		LA95: ;
		LOC93 = LOC94;
		if (!(LOC93)) goto LA97;
		LOC98 = 0;
		LOC98 = samemethoddispatcher_413675((*Result).calleesym, alt.calleesym);
		LOC93 = !(LOC98);
		LA97: ;
		if (!LOC93) goto LA99;
		{
			NimStringDesc* LOC105;
			if (!!(((*Result).state == ((NU8) 1)))) goto LA103;
			LOC105 = 0;
			LOC105 = HEX24_166306(TMP3356);
			internalerror_166218(LOC105);
		}
		LA103: ;
		{
			if (!(((NI) 0) < (*c).incompilescontext)) goto LA108;
			globalerror_166134((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3357));
		}
		goto LA106;
		LA108: ;
		{
			NimStringDesc* args;
			NimStringDesc* LOC122;
			TY177061 LOC123;
			NimStringDesc* LOC124;
			if (!(gerrorcounter_165012 == ((NI) 0))) goto LA111;
			args = copyString(((NimStringDesc*) &TMP3358));
			{
				NI i_415149;
				NI HEX3Atmp_415157;
				NI LOC114;
				NI res_415160;
				i_415149 = 0;
				HEX3Atmp_415157 = 0;
				LOC114 = 0;
				LOC114 = sonslen_194403(n);
				HEX3Atmp_415157 = (NI)(LOC114 - ((NI) 1));
				res_415160 = ((NI) 1);
				{
					while (1) {
						NimStringDesc* LOC121;
						if (!(res_415160 <= HEX3Atmp_415157)) goto LA116;
						i_415149 = res_415160;
						{
							if (!(((NI) 1) < i_415149)) goto LA119;
							args = resizeString(args, 2);
appendString(args, ((NimStringDesc*) &TMP3359));
						}
						LA119: ;
						LOC121 = 0;
						LOC121 = typetostring_221032((*(*n).kindU.S6.sons->data[i_415149]).typ, ((NU8) 0));
						args = resizeString(args, LOC121->Sup.len + 0);
appendString(args, LOC121);
						res_415160 += ((NI) 1);
					} LA116: ;
				}
			}
			args = resizeString(args, 1);
appendString(args, ((NimStringDesc*) &TMP3012));
			LOC122 = 0;
			LOC122 = msgkindtostring_165616(((NU16) 132));
			memset((void*)LOC123, 0, sizeof(LOC123));
			LOC123[0] = getprocheader_221447((*Result).calleesym, ((NU8) 0));
			LOC123[1] = getprocheader_221447(alt.calleesym, ((NU8) 0));
			LOC123[2] = copyString(args);
			LOC124 = 0;
			LOC124 = nsuFormatOpenArray(LOC122, LOC123, 3);
			localerror_166155((*n).info, ((NU16) 4), LOC124);
		}
		goto LA106;
		LA111: ;
		LA106: ;
	}
	LA99: ;
	}BeforeRet: ;
}

N_NIMCALL(void, instgenericconverterssons_415212)(Tcontext245023* c, Tnode191813* n, Tcandidate345209* x) {
	{
		if (!(*x).genericconverter) goto LA3;
		{
			NI i_415420;
			NI HEX3Atmp_415423;
			NI LOC6;
			NI res_415426;
			i_415420 = 0;
			HEX3Atmp_415423 = 0;
			LOC6 = 0;
			LOC6 = len_192097(n);
			HEX3Atmp_415423 = (LOC6 - 1);
			res_415426 = ((NI) 1);
			{
				while (1) {
					if (!(res_415426 <= HEX3Atmp_415423)) goto LA8;
					i_415420 = res_415426;
					instgenericconvertersarg_415176(c, (*n).kindU.S6.sons->data[i_415420], x);
					res_415426 += ((NI) 1);
				} LA8: ;
			}
		}
	}
	LA3: ;
}

N_NIMCALL(Tnode191813*, semresolvedcall_415507)(Tcontext245023* c, Tnode191813* n, Tcandidate345209* x) {
	Tnode191813* result;
	Tsym191843* finalcallee;
{	result = 0;
	finalcallee = (*x).calleesym;
	markused_345251((*(*n).kindU.S6.sons->data[((NI) 0)]).info, finalcallee);
	{
		if (!((*finalcallee).ast == NIM_NIL)) goto LA3;
		internalerror_166199((*n).info, ((NimStringDesc*) &TMP3360));
	}
	LA3: ;
	{
		if (!!(((*x).fauxmatch == ((NU8) 0)))) goto LA7;
		result = (*x).call;
		asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(finalcallee, (*(*result).kindU.S6.sons->data[((NI) 0)]).info));
		{
			NIM_BOOL LOC11;
			LOC11 = 0;
			LOC11 = containsgenerictype_230310((*result).typ);
			if (LOC11) goto LA12;
			LOC11 = ((*x).fauxmatch == ((NU8) 60));
			LA12: ;
			if (!LOC11) goto LA13;
			asgnRefNoCycle((void**) (&(*result).typ), newtypes_245218((*x).fauxmatch, c));
		}
		LA13: ;
		goto BeforeRet;
	}
	LA7: ;
	{
		if (!!(((*(*(*finalcallee).ast).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1)))) goto LA17;
		finalcallee = generateinstance_413450(c, (*x).calleesym, (*x).bindings, (*n).info);
	}
	LA17: ;
	result = (*x).call;
	instgenericconverterssons_415212(c, result, x);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(finalcallee, (*(*result).kindU.S6.sons->data[((NI) 0)]).info));
	asgnRefNoCycle((void**) (&(*result).typ), (*(*finalcallee).typ).sons->data[((NI) 0)]);
	}BeforeRet: ;
	return result;
}

static N_INLINE(NIM_BOOL, canderef_415851)(Tnode191813* n) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	NI LOC2;
	Ttype191849* t;
	Tnode191813* LOC4;
	NIM_BOOL LOC5;
	Ttype191849* LOC7;
	result = 0;
	LOC1 = 0;
	LOC2 = 0;
	LOC2 = len_192097(n);
	LOC1 = (((NI) 2) <= LOC2);
	if (!(LOC1)) goto LA3;
	LOC4 = 0;
	LOC4 = HEX5BHEX5D_192244(n, ((NI) 1));
	t = (*LOC4).typ;
	LOC5 = 0;
	LOC5 = !((t == NIM_NIL));
	if (!(LOC5)) goto LA6;
	LOC7 = 0;
	LOC7 = skiptypes_195167(t, 2048);
	LOC5 = ((6291456 &(IL64(1)<<(((*LOC7).kind)&IL64(63))))!=0);
	LA6: ;
	LOC1 = LOC5;
	LA3: ;
	result = LOC1;
	return result;
}

N_NIMCALL(Tnode191813*, tryderef_415884)(Tnode191813* n) {
	Tnode191813* result;
	Ttype191849* LOC1;
	result = 0;
	result = newnodei_193351(((NU8) 65), (*n).info);
	LOC1 = 0;
	LOC1 = skiptypes_195167((*n).typ, IL64(211106232576256));
	asgnRefNoCycle((void**) (&(*result).typ), (*LOC1).sons->data[((NI) 0)]);
	addson_193819(result, n);
	return result;
}

N_NIMCALL(void, notfounderror_414121)(Tcontext245023* c, Tnode191813* n_414124, Tsymseq191815* errors) {
	NimStringDesc* proto;
	NU8 prefer;
	NimStringDesc* result;
	NimStringDesc* LOC34;
	NimStringDesc* candidates;
{	{
		if (!(((NI) 0) < (*c).incompilescontext)) goto LA3;
		globalerror_166134((*n_414124).info, ((NU16) 129), ((NimStringDesc*) &TMP2991));
	}
	LA3: ;
	{
		NIM_BOOL LOC7;
		Tnode191813* LOC11;
		NimStringDesc* LOC12;
		LOC7 = 0;
		LOC7 = errors == 0;
		if (LOC7) goto LA8;
		LOC7 = ((errors ? errors->Sup.len : 0) == ((NI) 0));
		LA8: ;
		if (!LOC7) goto LA9;
		LOC11 = 0;
		LOC11 = HEX5BHEX5D_192244(n_414124, ((NI) 0));
		LOC12 = 0;
		LOC12 = rendertree_213058(LOC11, 0);
		localerror_166155((*n_414124).info, ((NU16) 88), LOC12);
		goto BeforeRet;
	}
	LA9: ;
	proto = describeargs_345974(c, n_414124, ((NI) 1), ((NU8) 0));
	prefer = ((NU8) 0);
	{
		Tsym191843* err_414154;
		NI i_414210;
		NI L_414212;
		err_414154 = 0;
		i_414210 = ((NI) 0);
		L_414212 = (errors ? errors->Sup.len : 0);
		{
			while (1) {
				NimStringDesc* errproto;
				Tnode191813* n;
				if (!(i_414210 < L_414212)) goto LA15;
				err_414154 = errors->data[i_414210];
				errproto = copyString(((NimStringDesc*) &TMP2991));
				n = (*(*err_414154).typ).n;
				{
					NI i_414171;
					NI HEX3Atmp_414201;
					NI LOC17;
					NI res_414204;
					i_414171 = 0;
					HEX3Atmp_414201 = 0;
					LOC17 = 0;
					LOC17 = len_192097(n);
					HEX3Atmp_414201 = (NI)(LOC17 - ((NI) 1));
					res_414204 = ((NI) 1);
					{
						while (1) {
							Tnode191813* p;
							if (!(res_414204 <= HEX3Atmp_414201)) goto LA19;
							i_414171 = res_414204;
							p = (*n).kindU.S6.sons->data[i_414171];
							{
								NimStringDesc* LOC24;
								if (!((*p).kind == ((NU8) 3))) goto LA22;
								LOC24 = 0;
								LOC24 = typetostring_221032((*(*p).kindU.S4.sym).typ, ((NU8) 0));
								errproto = resizeString(errproto, LOC24->Sup.len + 0);
appendString(errproto, LOC24);
								{
									NI LOC27;
									LOC27 = 0;
									LOC27 = len_192097(n);
									if (!!((i_414171 == (NI)(LOC27 - ((NI) 1))))) goto LA28;
									errproto = resizeString(errproto, 2);
appendString(errproto, ((NimStringDesc*) &TMP3359));
								}
								LA28: ;
							}
							LA22: ;
							res_414204 += ((NI) 1);
						} LA19: ;
					}
				}
				{
					if (!eqStrings(errproto, proto)) goto LA32;
					prefer = ((NU8) 3);
					goto LA13;
				}
				LA32: ;
				i_414210 += ((NI) 1);
			} LA15: ;
		}
	} LA13: ;
	result = msgkindtostring_165616(((NU16) 129));
	LOC34 = 0;
	LOC34 = describeargs_345974(c, n_414124, ((NI) 1), prefer);
	result = resizeString(result, LOC34->Sup.len + 0);
appendString(result, LOC34);
	result = addChar(result, 41);
	candidates = copyString(((NimStringDesc*) &TMP2991));
	{
		Tsym191843* err_414197;
		NI i_414216;
		NI L_414218;
		err_414197 = 0;
		i_414216 = ((NI) 0);
		L_414218 = (errors ? errors->Sup.len : 0);
		{
			while (1) {
				NimStringDesc* LOC38;
				if (!(i_414216 < L_414218)) goto LA37;
				err_414197 = errors->data[i_414216];
				LOC38 = 0;
				LOC38 = getprocheader_221447(err_414197, prefer);
				candidates = resizeString(candidates, LOC38->Sup.len + 0);
appendString(candidates, LOC38);
				candidates = resizeString(candidates, 1);
appendString(candidates, ((NimStringDesc*) &TMP3361));
				i_414216 += ((NI) 1);
			} LA37: ;
		}
	}
	{
		NimStringDesc* LOC43;
		NimStringDesc* LOC44;
		if (!!(((candidates) && (candidates)->Sup.len == 0))) goto LA41;
		LOC43 = 0;
		LOC44 = 0;
		LOC44 = msgkindtostring_165616(((NU16) 130));
		LOC43 = rawNewString(LOC44->Sup.len + candidates->Sup.len + 2);
appendString(LOC43, ((NimStringDesc*) &TMP3361));
appendString(LOC43, LOC44);
appendString(LOC43, ((NimStringDesc*) &TMP3361));
appendString(LOC43, candidates);
		result = resizeString(result, LOC43->Sup.len + 0);
appendString(result, LOC43);
	}
	LA41: ;
	localerror_166155((*n_414124).info, ((NU16) 4), result);
	}BeforeRet: ;
}

N_NIMCALL(Tnode191813*, semoverloadedcall_415892)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, NU32 filter) {
	Tnode191813* result;
	Tsymseq191815* errors;
	Tcandidate345209 r_415901;
	result = 0;
	errors = 0;
	memset((void*)(&r_415901), 0, sizeof(r_415901));
	chckNil((void*)(&r_415901));
	memset((void*)(&r_415901), 0, sizeof(r_415901));
	resolveoverloads_414359(c, n, norig, filter, (&errors), (&r_415901));
	{
		if (!(r_415901.state == ((NU8) 1))) goto LA3;
		result = semresolvedcall_415507(c, n, (&r_415901));
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC6;
		Tcandidate345209 r;
		LOC6 = 0;
		LOC6 = experimentalmode_246279(c);
		if (!(LOC6)) goto LA7;
		LOC6 = canderef_415851(n);
		LA7: ;
		if (!LOC6) goto LA8;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), tryderef_415884((*n).kindU.S6.sons->data[((NI) 1)]));
		memset((void*)(&r), 0, sizeof(r));
		chckNil((void*)(&r));
		memset((void*)(&r), 0, sizeof(r));
		resolveoverloads_414359(c, n, norig, filter, (&errors), (&r));
		{
			if (!(r.state == ((NU8) 1))) goto LA12;
			result = semresolvedcall_415507(c, n, (&r));
		}
		goto LA10;
		LA12: ;
		{
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), (*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S6.sons->data[((NI) 0)]);
			notfounderror_414121(c, n, errors);
		}
		LA10: ;
	}
	goto LA1;
	LA8: ;
	{
		notfounderror_414121(c, n, errors);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semoverloadedcallanalyseeffects_445901)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, NU16 flags) {
	Tnode191813* result;
{	result = 0;
	{
		if (!!(((flags & 6) == 0))) goto LA3;
		result = semoverloadedcall_415892(c, n, norig, 520192);
	}
	goto LA1;
	LA3: ;
	{
		result = semoverloadedcall_415892(c, n, norig, 471040);
	}
	LA1: ;
	{
		Tsym191843* callee;
		if (!!((result == NIM_NIL))) goto LA8;
		{
			if (!!(((*(*result).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA12;
			internalerror_166218(((NimStringDesc*) &TMP3362));
			goto BeforeRet;
		}
		LA12: ;
		callee = (*(*result).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
		switch ((*callee).kind) {
		case ((NU8) 17):
		case ((NU8) 18):
		{
		}
		break;
		default:
		{
			{
				NIM_BOOL LOC18;
				Tsym191843* LOC22;
				LOC18 = 0;
				LOC18 = ((49152 &(1<<(((*callee).kind)&31)))!=0);
				if (!(LOC18)) goto LA19;
				LOC18 = ((*callee).Sup.id == (*(*(*c).p).owner).Sup.id);
				LA19: ;
				if (!LOC18) goto LA20;
				localerror_166155((*n).info, ((NU16) 25), (*(*callee).name).s);
				LOC22 = 0;
				LOC22 = errorsym_250372(c, n);
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(LOC22));
			}
			LA20: ;
			{
				if (!!((((*callee).flags &(1<<((((NU8) 10))&31)))!=0))) goto LA25;
				{
					if (!!(((2080 & (*callee).flags) == 0))) goto LA29;
					(*(*(*c).p).owner).flags |= ((NI32)1)<<((((NU8) 11))%(sizeof(NI32)*8));
				}
				LA29: ;
			}
			LA25: ;
		}
		break;
		}
	}
	LA8: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, propertywriteaccess_447920)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, Tnode191813* a) {
	Tnode191813* result;
	Tident168021* id;
	Tnode191813* LOC1;
	Tnode191813* setterid;
	NimStringDesc* LOC2;
	Tident168021* LOC3;
	Tnode191813* aorig;
	Tnodeseq191807* LOC4;
	TY447930 LOC5;
	Tnode191813* LOC6;
	Tnode191813* orig;
	Tnodeseq191807* LOC7;
	TY447930 LOC8;
	result = 0;
	LOC1 = 0;
	LOC1 = HEX5BHEX5D_192244(a, ((NI) 1));
	id = considerquotedident_250010(LOC1);
	LOC2 = 0;
	LOC2 = rawNewString((*id).s->Sup.len + 1);
appendString(LOC2, (*id).s);
appendChar(LOC2, 61);
	LOC3 = 0;
	LOC3 = getident_168463(LOC2);
	setterid = newidentnode_193313(LOC3, (*n).info);
	aorig = HEX5BHEX5D_192244(norig, ((NI) 0));
	LOC4 = 0;
	LOC4 = (Tnodeseq191807*) newSeq((&NTI191807), 3);
	memset((void*)LOC5, 0, sizeof(LOC5));
	LOC5[0] = setterid;
	LOC5[1] = HEX5BHEX5D_192244(a, ((NI) 0));
	LOC6 = 0;
	LOC6 = HEX5BHEX5D_192244(n, ((NI) 1));
	LOC5[2] = semexpr_410201(c, LOC6, 0);
	asgnRefNoCycle((void**) (&LOC4->data[0]), LOC5[0]);
	asgnRefNoCycle((void**) (&LOC4->data[1]), LOC5[1]);
	asgnRefNoCycle((void**) (&LOC4->data[2]), LOC5[2]);
	result = newnode_193607(((NU8) 27), (*n).info, LOC4, NIM_NIL);
	(*result).flags |= ((NI16)1)<<((((NU8) 9))%(sizeof(NI16)*8));
	LOC7 = 0;
	LOC7 = (Tnodeseq191807*) newSeq((&NTI191807), 3);
	memset((void*)LOC8, 0, sizeof(LOC8));
	LOC8[0] = setterid;
	LOC8[1] = HEX5BHEX5D_192244(aorig, ((NI) 0));
	LOC8[2] = HEX5BHEX5D_192244(norig, ((NI) 1));
	asgnRefNoCycle((void**) (&LOC7->data[0]), LOC8[0]);
	asgnRefNoCycle((void**) (&LOC7->data[1]), LOC8[1]);
	asgnRefNoCycle((void**) (&LOC7->data[2]), LOC8[2]);
	orig = newnode_193607(((NU8) 27), (*n).info, LOC7, NIM_NIL);
	result = semoverloadedcallanalyseeffects_445901(c, result, orig, 0);
	{
		if (!!((result == NIM_NIL))) goto LA11;
		result = aftercallactions_446367(c, result, norig, 0);
	}
	LA11: ;
	return result;
}

static N_INLINE(NIM_BOOL, issymchoice_443471)(Tnode191813* n) {
	NIM_BOOL result;
	result = 0;
	result = ((*n).kind == ((NU8) 56) || (*n).kind == ((NU8) 57));
	return result;
}

N_NIMCALL(Tnode191813*, dottransformation_447679)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		Tnode191813* LOC6;
		Tnode191813* LOC7;
		LOC3 = 0;
		LOC3 = issymchoice_443471((*n).kindU.S6.sons->data[((NI) 1)]);
		if (!LOC3) goto LA4;
		result = newnodei_193351(((NU8) 25), (*n).info);
		addson_193819(result, (*n).kindU.S6.sons->data[((NI) 1)]);
		LOC6 = 0;
		LOC6 = HEX5BHEX5D_192244(n, ((NI) 0));
		LOC7 = 0;
		LOC7 = copytree_196028(LOC6);
		addson_193819(result, LOC7);
	}
	goto LA1;
	LA4: ;
	{
		Tident168021* i;
		Tnode191813* LOC9;
		Tnode191813* LOC10;
		Tnode191813* LOC11;
		Tnode191813* LOC12;
		i = considerquotedident_250010((*n).kindU.S6.sons->data[((NI) 1)]);
		result = newnodei_193351(((NU8) 25), (*n).info);
		(*result).flags |= ((NI16)1)<<((((NU8) 8))%(sizeof(NI16)*8));
		LOC9 = 0;
		LOC9 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC10 = 0;
		LOC10 = newidentnode_193313(i, (*LOC9).info);
		addson_193819(result, LOC10);
		LOC11 = 0;
		LOC11 = HEX5BHEX5D_192244(n, ((NI) 0));
		LOC12 = 0;
		LOC12 = copytree_196028(LOC11);
		addson_193819(result, LOC12);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semderef_447761)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Ttype191849* t;
	result = 0;
	checksonslen_246249(n, ((NI) 1));
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 0)], 0));
	result = n;
	t = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 0)]).typ, 8390656);
	switch ((*t).kind) {
	case ((NU8) 22):
	case ((NU8) 21):
	{
		asgnRefNoCycle((void**) (&(*n).typ), lastson_194442(t));
	}
	break;
	default:
	{
		result = NIM_NIL;
	}
	break;
	}
	return result;
}

N_NIMCALL(Tnode191813*, semsubscript_447774)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Ttype191849* arr;
{	result = 0;
	{
		NI LOC3;
		Tnode191813* x;
		Tnode191813* LOC10;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 1))) goto LA4;
		x = semderef_447761(c, n);
		{
			if (!(x == NIM_NIL)) goto LA8;
			result = NIM_NIL;
			goto BeforeRet;
		}
		LA8: ;
		result = newnodeit_193807(((NU8) 47), (*x).info, (*x).typ);
		LOC10 = 0;
		LOC10 = HEX5BHEX5D_192244(x, ((NI) 0));
		add_192164(result, LOC10);
		goto BeforeRet;
	}
	LA4: ;
	checkminsonslen_246259(n, ((NI) 2));
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 0)], 0));
	arr = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 0)]).typ, 14682112);
	switch ((*arr).kind) {
	case ((NU8) 16):
	case ((NU8) 27):
	case ((NU8) 48):
	case ((NU8) 4):
	case ((NU8) 24):
	case ((NU8) 28):
	case ((NU8) 29):
	{
		Ttype191849* indextype;
		Tnode191813* arg;
		{
			NI LOC14;
			LOC14 = 0;
			LOC14 = len_192097(n);
			if (!!((LOC14 == ((NI) 2)))) goto LA15;
			result = NIM_NIL;
			goto BeforeRet;
		}
		LA15: ;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), makederef_446833((*n).kindU.S6.sons->data[((NI) 0)]));
		asgnRefNoCycle((void**) (&(*(*c).p).bracketexpr), (*n).kindU.S6.sons->data[((NI) 0)]);
		{
			NI i_447815;
			NI HEX3Atmp_447879;
			NI LOC18;
			NI res_447882;
			i_447815 = 0;
			HEX3Atmp_447879 = 0;
			LOC18 = 0;
			LOC18 = sonslen_194403(n);
			HEX3Atmp_447879 = (NI)(LOC18 - ((NI) 1));
			res_447882 = ((NI) 1);
			{
				while (1) {
					if (!(res_447882 <= HEX3Atmp_447879)) goto LA20;
					i_447815 = res_447882;
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_447815]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[i_447815], (flags & 36)));
					res_447882 += ((NI) 1);
				} LA20: ;
			}
		}
		{
			if (!((*arr).kind == ((NU8) 16))) goto LA23;
			indextype = (*arr).sons->data[((NI) 0)];
		}
		goto LA21;
		LA23: ;
		{
			indextype = getsystype_239030(((NU8) 31));
		}
		LA21: ;
		arg = indextypesmatch_410348(c, indextype, (*(*n).kindU.S6.sons->data[((NI) 1)]).typ, (*n).kindU.S6.sons->data[((NI) 1)]);
		{
			if (!!((arg == NIM_NIL))) goto LA28;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), arg);
			result = n;
			asgnRefNoCycle((void**) (&(*result).typ), elemtype_221522(arr));
		}
		LA28: ;
	}
	break;
	case ((NU8) 8):
	{
		Ttype191849* LOC31;
		result = n;
		LOC31 = 0;
		LOC31 = semtypenode_410269(c, n, NIM_NIL);
		asgnRefNoCycle((void**) (&(*result).typ), maketypedesc_245681(c, LOC31));
	}
	break;
	case ((NU8) 18):
	{
		checksonslen_246249(n, ((NI) 2));
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), makederef_446833((*n).kindU.S6.sons->data[((NI) 0)]));
		asgnRefNoCycle((void**) (&(*(*c).p).bracketexpr), (*n).kindU.S6.sons->data[((NI) 0)]);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), semconstexpr_411485(c, (*n).kindU.S6.sons->data[((NI) 1)]));
		{
			Ttype191849* LOC35;
			NI64 idx;
			LOC35 = 0;
			LOC35 = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 1)]).typ, 1083392);
			if (!((IL64(66571993088) &(IL64(1)<<(((*LOC35).kind)&IL64(63))))!=0)) goto LA36;
			idx = getordvalue_221178((*n).kindU.S6.sons->data[((NI) 1)]);
			{
				NIM_BOOL LOC40;
				NI LOC42;
				LOC40 = 0;
				LOC40 = (IL64(0) <= idx);
				if (!(LOC40)) goto LA41;
				LOC42 = 0;
				LOC42 = sonslen_194351(arr);
				LOC40 = (idx < ((NI64) (LOC42)));
				LA41: ;
				if (!LOC40) goto LA43;
				asgnRefNoCycle((void**) (&(*n).typ), (*arr).sons->data[idx]);
			}
			goto LA38;
			LA43: ;
			{
				localerror_166155((*n).info, ((NU16) 185), ((NimStringDesc*) &TMP2991));
			}
			LA38: ;
		}
		goto LA33;
		LA36: ;
		{
			localerror_166155((*n).info, ((NU16) 83), ((NimStringDesc*) &TMP2991));
		}
		LA33: ;
		result = n;
	}
	break;
	default:
	{
		asgnRefNoCycle((void**) (&(*(*c).p).bracketexpr), (*n).kindU.S6.sons->data[((NI) 0)]);
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, buildoverloadedsubscripts_447722)(Tnode191813* n, Tident168021* ident) {
	Tnode191813* result;
	Tnode191813* LOC1;
	result = 0;
	result = newnodei_193351(((NU8) 27), (*n).info);
	LOC1 = 0;
	LOC1 = newidentnode_193313(ident, (*n).info);
	add_192164(result, LOC1);
	{
		NI i_447739;
		NI HEX3Atmp_447742;
		NI LOC3;
		NI res_447745;
		i_447739 = 0;
		HEX3Atmp_447742 = 0;
		LOC3 = 0;
		LOC3 = len_192097(n);
		HEX3Atmp_447742 = (NI)(LOC3 - ((NI) 1));
		res_447745 = ((NI) 0);
		{
			while (1) {
				Tnode191813* LOC6;
				if (!(res_447745 <= HEX3Atmp_447742)) goto LA5;
				i_447739 = res_447745;
				LOC6 = 0;
				LOC6 = HEX5BHEX5D_192244(n, i_447739);
				add_192164(result, LOC6);
				res_447745 += ((NI) 1);
			} LA5: ;
		}
	}
	return result;
}

N_NIMCALL(void, typemismatch_410379)(Tnode191813* n, Ttype191849* formal, Ttype191849* actual) {
	{
		NIM_BOOL LOC3;
		NimStringDesc* LOC7;
		NimStringDesc* LOC8;
		NimStringDesc* LOC9;
		NimStringDesc* LOC10;
		TY165566 LOC11;
		NimStringDesc* LOC12;
		LOC3 = 0;
		LOC3 = !(((*formal).kind == ((NU8) 50)));
		if (!(LOC3)) goto LA4;
		LOC3 = !(((*actual).kind == ((NU8) 50)));
		LA4: ;
		if (!LOC3) goto LA5;
		LOC7 = 0;
		LOC8 = 0;
		LOC8 = msgkindtostring_165616(((NU16) 129));
		LOC9 = 0;
		LOC9 = typetostring_221032(actual, ((NU8) 0));
		LOC10 = 0;
		LOC10 = msgkindtostring_165616(((NU16) 131));
		memset((void*)LOC11, 0, sizeof(LOC11));
		LOC11[0] = typetostring_221032(formal, ((NU8) 0));
		LOC12 = 0;
		LOC12 = nsuFormatOpenArray(LOC10, LOC11, 1);
		LOC7 = rawNewString(LOC8->Sup.len + LOC9->Sup.len + LOC12->Sup.len + 2);
appendString(LOC7, LOC8);
appendString(LOC7, LOC9);
appendString(LOC7, ((NimStringDesc*) &TMP3366));
appendString(LOC7, LOC12);
		localerror_166155((*n).info, ((NU16) 4), LOC7);
	}
	LA5: ;
}

N_NIMCALL(Ttype191849*, newproctype_436194)(Tlineinfo164338 info, Tsym191843* owner) {
	Ttype191849* result;
	Tnode191813* LOC1;
	result = 0;
	result = newtype_194140(((NU8) 25), owner);
	asgnRefNoCycle((void**) (&(*result).n), newnodei_193351(((NU8) 76), info));
	rawaddson_195478(result, NIM_NIL);
	LOC1 = 0;
	LOC1 = newnodei_193351(((NU8) 152), info);
	addson_193819((*result).n, LOC1);
	return result;
}

N_NIMCALL(void, addparam_436202)(Ttype191849* proctype, Tsym191843* param) {
	NI LOC1;
	Tnode191813* LOC2;
	LOC1 = 0;
	LOC1 = len_194377(proctype);
	(*param).position = (NI)(LOC1 - ((NI) 1));
	LOC2 = 0;
	LOC2 = newsymnode_193325(param);
	addson_193819((*proctype).n, LOC2);
	rawaddson_195478(proctype, (*param).typ);
}

N_NIMCALL(Tnode191813*, newasgnstmt_435510)(Tnode191813* le, Tnode191813* ri) {
	Tnode191813* result;
	result = 0;
	result = newnodei_193407(((NU8) 73), (*le).info, ((NI) 2));
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), le);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), ri);
	return result;
}

N_NIMCALL(void, defaultop_436006)(Tliftctx435286* c, Ttype191849* t, Tnode191813* body, Tnode191813* x, Tnode191813* y) {
	{
		Tnode191813* LOC5;
		if (!!(((*c).kind == ((NU8) 2)))) goto LA3;
		LOC5 = 0;
		LOC5 = newasgnstmt_435510(x, y);
		add_192164(body, LOC5);
	}
	LA3: ;
}

N_NIMCALL(Tnode191813*, genbuiltin_436065)(NU16 magic, NimStringDesc* name, Tnode191813* i) {
	Tnode191813* result;
	Tsym191843* LOC1;
	Tnode191813* LOC2;
	result = 0;
	result = newnodei_193351(((NU8) 27), (*i).info);
	LOC1 = 0;
	LOC1 = createmagic_196987(name, magic);
	LOC2 = 0;
	LOC2 = newsymnode_193325(LOC1);
	add_192164(result, LOC2);
	add_192164(result, i);
	return result;
}

N_NIMCALL(Tnode191813*, newseqcall_436101)(Tcontext245023* c, Tnode191813* x, Tnode191813* y) {
	Tnode191813* result;
	Tnode191813* lencall;
	result = 0;
	result = genbuiltin_436065(((NU16) 28), ((NimStringDesc*) &TMP3370), x);
	lencall = genbuiltin_436065(((NU16) 32), ((NimStringDesc*) &TMP3371), y);
	asgnRefNoCycle((void**) (&(*lencall).typ), getsystype_239030(((NU8) 31)));
	add_192164(result, lencall);
	return result;
}

N_NIMCALL(void, addvar_436027)(Tnode191813* father, Tnode191813* v, Tnode191813* value) {
	Tnode191813* vpart;
	vpart = newnodei_193407(((NU8) 35), (*v).info, ((NI) 3));
	asgnRefNoCycle((void**) (&(*vpart).kindU.S6.sons->data[((NI) 0)]), v);
	asgnRefNoCycle((void**) (&(*vpart).kindU.S6.sons->data[((NI) 1)]), emptynode_192807);
	asgnRefNoCycle((void**) (&(*vpart).kindU.S6.sons->data[((NI) 2)]), value);
	addson_193819(father, vpart);
}

N_NIMCALL(Tnode191813*, declarecounter_436039)(Tliftctx435286* c, Tnode191813* body, NI64 first) {
	Tnode191813* result;
	Tsym191843* temp;
	Tident168021* LOC1;
	Tnode191813* v;
	Tnode191813* LOC2;
	result = 0;
	LOC1 = 0;
	LOC1 = getident_168463(((NimStringDesc*) &TMP3372));
	temp = newsym_192655(((NU8) 5), LOC1, (*c).fn, (*c).info);
	asgnRefNoCycle((void**) (&(*temp).typ), getsystype_239030(((NU8) 31)));
	(*temp).flags |= ((NI32)1)<<((((NU8) 2))%(sizeof(NI32)*8));
	v = newnodei_193351(((NU8) 99), (*c).info);
	result = newsymnode_193325(temp);
	LOC2 = 0;
	LOC2 = newintlit_360438(first);
	addvar_436027(v, result, LOC2);
	add_192164(body, v);
	return result;
}

N_NIMCALL(Tnode191813*, genwhileloop_436077)(Tliftctx435286* c, Tnode191813* i, Tnode191813* dest) {
	Tnode191813* result;
	Tnode191813* cmp;
	Tnode191813* LOC1;
	result = 0;
	result = newnodei_193407(((NU8) 96), (*c).info, ((NI) 2));
	cmp = genbuiltin_436065(((NU16) 77), ((NimStringDesc*) &TMP3373), i);
	LOC1 = 0;
	LOC1 = genhigh_360448(dest);
	add_192164(cmp, LOC1);
	asgnRefNoCycle((void**) (&(*cmp).typ), getsystype_239030(((NU8) 1)));
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), cmp);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), newnodei_193351(((NU8) 115), (*c).info));
	return result;
}

N_NIMCALL(Tnode191813*, at_435306)(Tnode191813* a, Tnode191813* i, Ttype191849* elemtype) {
	Tnode191813* result;
	result = 0;
	result = newnodei_193407(((NU8) 42), (*a).info, ((NI) 2));
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), a);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), i);
	asgnRefNoCycle((void**) (&(*result).typ), elemtype);
	return result;
}

N_NIMCALL(void, addincstmt_436091)(Tnode191813* body, Tnode191813* i) {
	Tnode191813* inccall;
	Tnode191813* LOC1;
	inccall = genbuiltin_436065(((NU16) 23), ((NimStringDesc*) &TMP3375), i);
	LOC1 = 0;
	LOC1 = newintlit_360438(IL64(1));
	add_192164(inccall, LOC1);
	add_192164(body, inccall);
}

N_NIMCALL(Tnode191813*, newdestructorcall_435520)(Tsym191843* op, Tnode191813* x) {
	Tnode191813* result;
	Tnode191813* LOC1;
	result = 0;
	result = newnodeit_193807(((NU8) 27), (*x).info, (*(*op).typ).sons->data[((NI) 0)]);
	LOC1 = 0;
	LOC1 = newsymnode_193325(op);
	add_192164(result, LOC1);
	add_192164(result, x);
	return result;
}

N_NIMCALL(Tnode191813*, genaddr_435467)(Tcontext245023* c, Tnode191813* x) {
	Tnode191813* result;
	result = 0;
	{
		if (!((*x).kind == ((NU8) 65))) goto LA3;
		checksonslen_246249(x, ((NI) 1));
		result = (*x).kindU.S6.sons->data[((NI) 0)];
	}
	goto LA1;
	LA3: ;
	{
		Ttype191849* LOC6;
		LOC6 = 0;
		LOC6 = makevartype_245642(c, (*x).typ);
		result = newnodeit_193807(((NU8) 64), (*x).info, LOC6);
		addson_193819(result, x);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, newasgncall_435485)(Tcontext245023* c, Tsym191843* op, Tnode191813* x, Tnode191813* y) {
	Tnode191813* result;
	Tnode191813* LOC5;
	Tnode191813* LOC6;
	result = 0;
	{
		if (!(((*op).flags &(1<<((((NU8) 20))&31)))!=0)) goto LA3;
		localerror_166155((*x).info, ((NU16) 221), (*(*op).name).s);
	}
	LA3: ;
	result = newnodei_193351(((NU8) 27), (*x).info);
	LOC5 = 0;
	LOC5 = newsymnode_193325(op);
	add_192164(result, LOC5);
	LOC6 = 0;
	LOC6 = genaddr_435467(c, x);
	add_192164(result, LOC6);
	add_192164(result, y);
	return result;
}

N_NIMCALL(Tnode191813*, newdeepcopycall_435531)(Tsym191843* op, Tnode191813* x, Tnode191813* y) {
	Tnode191813* result;
	Tnode191813* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = newdestructorcall_435520(op, y);
	result = newasgnstmt_435510(x, LOC1);
	return result;
}

N_NIMCALL(NIM_BOOL, consideroverloadedop_435540)(Tliftctx435286* c, Ttype191849* t, Tnode191813* body, Tnode191813* x, Tnode191813* y) {
	NIM_BOOL result;
{	result = 0;
	switch ((*c).kind) {
	case ((NU8) 2):
	{
		Tsym191843* op;
		op = (*t).destructor;
		{
			Tnode191813* LOC6;
			if (!!((op == NIM_NIL))) goto LA4;
			markused_345251((*c).info, op);
			LOC6 = 0;
			LOC6 = newdestructorcall_435520(op, x);
			add_192164(body, LOC6);
			result = NIM_TRUE;
		}
		LA4: ;
	}
	break;
	case ((NU8) 0):
	{
		{
			Tsym191843* op;
			Tnode191813* LOC27;
			if (!(((*t).flags &(1<<((((NU8) 26))&31)))!=0)) goto LA10;
			op = 0;
			{
				NIM_BOOL LOC14;
				LOC14 = 0;
				LOC14 = sametype_226092(t, (*c).asgnfortype, 0);
				if (!LOC14) goto LA15;
				{
					if (!(*c).recurse) goto LA19;
					op = (*c).fn;
				}
				goto LA17;
				LA19: ;
				{
					(*c).recurse = NIM_TRUE;
					result = NIM_FALSE;
					goto BeforeRet;
				}
				LA17: ;
			}
			goto LA12;
			LA15: ;
			{
				op = (*t).assignment;
				{
					if (!(op == NIM_NIL)) goto LA25;
					op = liftbody_435301((*c).c, t, (*c).info);
				}
				LA25: ;
			}
			LA12: ;
			markused_345251((*c).info, op);
			LOC27 = 0;
			LOC27 = newasgncall_435485((*c).c, op, x, y);
			add_192164(body, LOC27);
			result = NIM_TRUE;
		}
		LA10: ;
	}
	break;
	case ((NU8) 1):
	{
		Tsym191843* op;
		op = (*t).deepcopy;
		{
			Tnode191813* LOC33;
			if (!!((op == NIM_NIL))) goto LA31;
			markused_345251((*c).info, op);
			LOC33 = 0;
			LOC33 = newdeepcopycall_435531(op, x, y);
			add_192164(body, LOC33);
			result = NIM_TRUE;
		}
		LA31: ;
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, dotfield_435367)(Tnode191813* x, Tsym191843* f) {
	Tnode191813* result;
	result = 0;
	result = newnodei_193407(((NU8) 45), (*x).info, ((NI) 2));
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), x);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), newsymnode_193338(f, (*x).info));
	asgnRefNoCycle((void**) (&(*result).typ), (*f).typ);
	return result;
}

N_NIMCALL(void, liftbodyobj_435378)(Tliftctx435286* c, Tnode191813* n, Tnode191813* body, Tnode191813* x, Tnode191813* y) {
	switch ((*n).kind) {
	case ((NU8) 3):
	{
		Tsym191843* f;
		Tnode191813* LOC2;
		Tnode191813* LOC3;
		f = (*n).kindU.S4.sym;
		LOC2 = 0;
		LOC2 = dotfield_435367(x, f);
		LOC3 = 0;
		LOC3 = dotfield_435367(y, f);
		liftbodyaux_435293(c, (*f).typ, body, LOC2, LOC3);
	}
	break;
	case ((NU8) 23):
	{
	}
	break;
	case ((NU8) 139):
	{
		Tnode191813* LOC6;
		Tnode191813* casestmt;
		Tnode191813* access;
		Tnode191813* LOC7;
		LOC6 = 0;
		LOC6 = HEX5BHEX5D_192244(n, ((NI) 0));
		liftbodyobj_435378(c, LOC6, body, x, y);
		casestmt = newnodei_193351(((NU8) 97), (*c).info);
		LOC7 = 0;
		LOC7 = HEX5BHEX5D_192244(n, ((NI) 0));
		access = dotfield_435367(x, (*LOC7).kindU.S4.sym);
		add_192164(casestmt, access);
		{
			NI i_435414;
			NI HEX3Atmp_435425;
			NI LOC9;
			NI res_435428;
			i_435414 = 0;
			HEX3Atmp_435425 = 0;
			LOC9 = 0;
			LOC9 = len_192097(n);
			HEX3Atmp_435425 = (LOC9 - 1);
			res_435428 = ((NI) 1);
			{
				while (1) {
					Tnode191813* branch;
					Tnode191813* LOC12;
					NI L;
					Tnode191813* LOC13;
					Tnode191813* LOC14;
					if (!(res_435428 <= HEX3Atmp_435425)) goto LA11;
					i_435414 = res_435428;
					LOC12 = 0;
					LOC12 = HEX5BHEX5D_192244(n, i_435414);
					branch = copytree_196028(LOC12);
					L = len_192097(branch);
					asgnRefNoCycle((void**) (&(*branch).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), newnodei_193351(((NU8) 115), (*c).info));
					LOC13 = 0;
					LOC13 = HEX5BHEX5D_192244(n, i_435414);
					LOC14 = 0;
					LOC14 = lastson_194431(LOC13);
					liftbodyobj_435378(c, LOC14, (*branch).kindU.S6.sons->data[(NI)(L - ((NI) 1))], x, y);
					add_192164(casestmt, branch);
					res_435428 += ((NI) 1);
				} LA11: ;
			}
		}
		add_192164(body, casestmt);
		localerror_166166((*c).info, ((NimStringDesc*) &TMP3376));
	}
	break;
	case ((NU8) 138):
	{
		{
			Tnode191813* t_435423;
			t_435423 = 0;
			{
				NI i_435436;
				NI HEX3Atmp_435438;
				NI LOC18;
				NI res_435440;
				i_435436 = 0;
				HEX3Atmp_435438 = 0;
				LOC18 = 0;
				LOC18 = len_192097(n);
				HEX3Atmp_435438 = (LOC18 - 1);
				res_435440 = ((NI) 0);
				{
					while (1) {
						if (!(res_435440 <= HEX3Atmp_435438)) goto LA20;
						i_435436 = res_435440;
						t_435423 = (*n).kindU.S6.sons->data[i_435436];
						liftbodyobj_435378(c, t_435423, body, x, y);
						res_435440 += ((NI) 1);
					} LA20: ;
				}
			}
		}
	}
	break;
	default:
	{
		illformedastlocal_246239(n);
	}
	break;
	}
}

N_NIMCALL(void, liftbodytup_435317)(Tliftctx435286* c, Ttype191849* t, Tnode191813* body, Tnode191813* x, Tnode191813* y) {
	{
		NI i_435343;
		NI HEX3Atmp_435348;
		NI LOC2;
		NI res_435351;
		i_435343 = 0;
		HEX3Atmp_435348 = 0;
		LOC2 = 0;
		LOC2 = len_194377(t);
		HEX3Atmp_435348 = (LOC2 - 1);
		res_435351 = ((NI) 0);
		{
			while (1) {
				Tnode191813* lit;
				Tnode191813* LOC5;
				Tnode191813* LOC6;
				if (!(res_435351 <= HEX3Atmp_435348)) goto LA4;
				i_435343 = res_435351;
				lit = newintlit_360438(((NI64) (i_435343)));
				LOC5 = 0;
				LOC5 = at_435306(x, lit, (*t).sons->data[i_435343]);
				LOC6 = 0;
				LOC6 = at_435306(y, lit, (*t).sons->data[i_435343]);
				liftbodyaux_435293(c, (*t).sons->data[i_435343], body, LOC5, LOC6);
				res_435351 += ((NI) 1);
			} LA4: ;
		}
	}
}

N_NIMCALL(void, liftbodyaux_435293)(Tliftctx435286* c, Ttype191849* t, Tnode191813* body, Tnode191813* x, Tnode191813* y) {
	switch ((*t).kind) {
	case ((NU8) 0):
	case ((NU8) 3):
	{
	}
	break;
	case ((NU8) 26):
	case ((NU8) 19):
	case ((NU8) 1):
	case ((NU8) 2):
	case ((NU8) 14):
	case ((NU8) 31) ... ((NU8) 44):
	case ((NU8) 29):
	case ((NU8) 21):
	case ((NU8) 28):
	case ((NU8) 22):
	{
		defaultop_436006(c, t, body, x, y);
	}
	break;
	case ((NU8) 4):
	case ((NU8) 16):
	case ((NU8) 24):
	{
		{
			Tnode191813* i;
			NI64 LOC13;
			Tnode191813* whileloop;
			Ttype191849* elemtype;
			Tnode191813* LOC14;
			Tnode191813* LOC15;
			if (!(((*t).flags &(1<<((((NU8) 26))&31)))!=0)) goto LA6;
			{
				Tnode191813* LOC12;
				if (!((*t).kind == ((NU8) 24))) goto LA10;
				LOC12 = 0;
				LOC12 = newseqcall_436101((*c).c, x, y);
				add_192164(body, LOC12);
			}
			LA10: ;
			LOC13 = 0;
			LOC13 = firstord_221004(t);
			i = declarecounter_436039(c, body, LOC13);
			whileloop = genwhileloop_436077(c, i, x);
			elemtype = lastson_194442(t);
			LOC14 = 0;
			LOC14 = at_435306(x, i, elemtype);
			LOC15 = 0;
			LOC15 = at_435306(y, i, elemtype);
			liftbodyaux_435293(c, elemtype, (*whileloop).kindU.S6.sons->data[((NI) 1)], LOC14, LOC15);
			addincstmt_436091((*whileloop).kindU.S6.sons->data[((NI) 1)], i);
			add_192164(body, whileloop);
		}
		goto LA4;
		LA6: ;
		{
			defaultop_436006(c, t, body, x, y);
		}
		LA4: ;
	}
	break;
	case ((NU8) 17):
	case ((NU8) 13):
	{
		{
			NIM_BOOL LOC20;
			LOC20 = 0;
			LOC20 = consideroverloadedop_435540(c, t, body, x, y);
			if (!!(LOC20)) goto LA21;
			{
				if (!!(((*t).sons->data[((NI) 0)] == NIM_NIL))) goto LA25;
				liftbodyaux_435293(c, (*t).sons->data[((NI) 0)], body, x, y);
			}
			LA25: ;
			{
				if (!((*t).kind == ((NU8) 17))) goto LA29;
				liftbodyobj_435378(c, (*t).n, body, x, y);
			}
			LA29: ;
		}
		LA21: ;
	}
	break;
	case ((NU8) 18):
	{
		liftbodytup_435317(c, t, body, x, y);
	}
	break;
	case ((NU8) 25):
	{
		{
			NIM_BOOL LOC35;
			LOC35 = 0;
			LOC35 = !(((*t).callconv == ((NU8) 8)));
			if (LOC35) goto LA36;
			LOC35 = !(((*c).kind == ((NU8) 1)));
			LA36: ;
			if (!LOC35) goto LA37;
			defaultop_436006(c, t, body, x, y);
		}
		goto LA33;
		LA37: ;
		{
			Tnode191813* call;
			Tsym191843* LOC40;
			Tnode191813* LOC41;
			call = newnodei_193407(((NU8) 27), (*c).info, ((NI) 2));
			asgnRefNoCycle((void**) (&(*call).typ), t);
			LOC40 = 0;
			LOC40 = createmagic_196987(((NimStringDesc*) &TMP3377), ((NU16) 214));
			asgnRefNoCycle((void**) (&(*call).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(LOC40));
			asgnRefNoCycle((void**) (&(*call).kindU.S6.sons->data[((NI) 1)]), y);
			LOC41 = 0;
			LOC41 = newasgnstmt_435510(x, call);
			add_192164(body, LOC41);
		}
		LA33: ;
	}
	break;
	case ((NU8) 48):
	case ((NU8) 27):
	{
		localerror_166155((*c).info, ((NU16) 4), ((NimStringDesc*) &TMP3378));
	}
	break;
	case ((NU8) 60):
	case ((NU8) 49):
	case ((NU8) 50):
	case ((NU8) 51):
	case ((NU8) 52):
	case ((NU8) 53):
	case ((NU8) 54):
	case ((NU8) 55):
	case ((NU8) 56):
	case ((NU8) 57):
	case ((NU8) 58):
	case ((NU8) 47):
	case ((NU8) 12):
	case ((NU8) 10):
	case ((NU8) 5):
	case ((NU8) 6):
	case ((NU8) 7):
	case ((NU8) 8):
	case ((NU8) 9):
	case ((NU8) 45):
	case ((NU8) 46):
	case ((NU8) 30):
	{
		NimStringDesc* LOC44;
		NimStringDesc* LOC45;
		LOC44 = 0;
		LOC45 = 0;
		LOC45 = typetostring_221032(t, ((NU8) 0));
		LOC44 = rawNewString(LOC45->Sup.len + 31);
appendString(LOC44, ((NimStringDesc*) &TMP3379));
appendString(LOC44, LOC45);
		internalerror_166199((*c).info, LOC44);
	}
	break;
	case ((NU8) 15):
	case ((NU8) 20):
	case ((NU8) 11):
	case ((NU8) 61):
	case ((NU8) 59):
	case ((NU8) 23):
	{
		Ttype191849* LOC47;
		LOC47 = 0;
		LOC47 = lastson_194442(t);
		liftbodyaux_435293(c, LOC47, body, x, y);
	}
	break;
	}
}

static N_INLINE(Tnode191813*, newderef_358024)(Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = newnodeit_193807(((NU8) 65), (*n).info, (*(*n).typ).sons->data[((NI) 0)]);
	addson_193819(result, n);
	return result;
}

N_NIMCALL(Tsym191843*, liftbody_435301)(Tcontext245023* c, Ttype191849* typ, Tlineinfo164338 info) {
	Tsym191843* result;
	Tliftctx435286 a;
	Tnode191813* body;
	Tident168021* LOC1;
	Tsym191843* dest;
	Tident168021* LOC2;
	Tsym191843* src;
	Tident168021* LOC3;
	Tnode191813* LOC4;
	Tnode191813* LOC5;
	Tnode191813* LOC6;
	Tnode191813* n;
	result = 0;
	memset((void*)(&a), 0, sizeof(a));
	a.info = info;
	body = newnodei_193351(((NU8) 115), info);
	LOC1 = 0;
	LOC1 = getident_168463(((NimStringDesc*) &TMP3367));
	result = newsym_192655(((NU8) 12), LOC1, (*typ).owner, info);
	a.fn = result;
	a.asgnfortype = typ;
	LOC2 = 0;
	LOC2 = getident_168463(((NimStringDesc*) &TMP3368));
	dest = newsym_192655(((NU8) 3), LOC2, result, info);
	LOC3 = 0;
	LOC3 = getident_168463(((NimStringDesc*) &TMP3369));
	src = newsym_192655(((NU8) 3), LOC3, result, info);
	asgnRefNoCycle((void**) (&(*dest).typ), makevartype_245642(c, typ));
	asgnRefNoCycle((void**) (&(*src).typ), typ);
	asgnRefNoCycle((void**) (&(*result).typ), newproctype_436194(info, (*typ).owner));
	addparam_436202((*result).typ, dest);
	addparam_436202((*result).typ, src);
	LOC4 = 0;
	LOC4 = newsymnode_193325(dest);
	LOC5 = 0;
	LOC5 = newderef_358024(LOC4);
	LOC6 = 0;
	LOC6 = newsymnode_193325(src);
	liftbodyaux_435293((&a), typ, body, LOC5, LOC6);
	n = newnodei_193407(((NU8) 79), info, ((NI) 7));
	{
		NI i_436248;
		NI HEX3Atmp_436257;
		NI LOC8;
		NI res_436260;
		i_436248 = 0;
		HEX3Atmp_436257 = 0;
		LOC8 = 0;
		LOC8 = len_192097(n);
		HEX3Atmp_436257 = (LOC8 - 1);
		res_436260 = ((NI) 0);
		{
			while (1) {
				if (!(res_436260 <= HEX3Atmp_436257)) goto LA10;
				i_436248 = res_436260;
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_436248]), emptynode_192807);
				res_436260 += ((NI) 1);
			} LA10: ;
		}
	}
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(result));
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 3)]), (*(*result).typ).n);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), body);
	asgnRefNoCycle((void**) (&(*result).ast), n);
	asgnRefNoCycle((void**) (&(*typ).assignment), result);
	return result;
}

N_NIMCALL(Tsym191843*, getasgnorliftbody_436276)(Tcontext245023* c, Ttype191849* typ, Tlineinfo164338 info) {
	Tsym191843* result;
	Ttype191849* t;
	result = 0;
	t = skiptypes_195167(typ, 8390656);
	result = (*t).assignment;
	{
		if (!result == 0) goto LA3;
		result = liftbody_435301(c, t, info);
	}
	LA3: ;
	return result;
}

N_NIMCALL(Tnode191813*, overloadedasgn_436296)(Tcontext245023* c, Tnode191813* dest, Tnode191813* src) {
	Tnode191813* result;
	Tsym191843* a;
	result = 0;
	a = getasgnorliftbody_436276(c, (*dest).typ, (*dest).info);
	result = newasgncall_435485(c, a, dest, src);
	return result;
}

N_NIMCALL(Tnode191813*, takeimplicitaddr_447986)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	NU8 valid;
	Ttype191849* LOC20;
{	result = 0;
	switch ((*n).kind) {
	case ((NU8) 64):
	case ((NU8) 63):
	{
		result = n;
		goto BeforeRet;
	}
	break;
	case ((NU8) 65):
	case ((NU8) 47):
	{
		result = (*n).kindU.S6.sons->data[((NI) 0)];
		goto BeforeRet;
	}
	break;
	case ((NU8) 42):
	{
		{
			NI LOC6;
			LOC6 = 0;
			LOC6 = len_192097(n);
			if (!(LOC6 == ((NI) 1))) goto LA7;
			result = (*n).kindU.S6.sons->data[((NI) 0)];
			goto BeforeRet;
		}
		LA7: ;
	}
	break;
	default:
	{
	}
	break;
	}
	valid = isassignable_444642(c, n);
	{
		if (!!((valid == ((NU8) 1)))) goto LA12;
		{
			NimStringDesc* LOC18;
			if (!(valid == ((NU8) 2))) goto LA16;
			LOC18 = 0;
			LOC18 = rendertree_213058(n, 4);
			localerror_166155((*n).info, ((NU16) 126), LOC18);
		}
		goto LA14;
		LA16: ;
		{
			localerror_166155((*n).info, ((NU16) 125), ((NimStringDesc*) &TMP2991));
		}
		LA14: ;
	}
	LA12: ;
	LOC20 = 0;
	LOC20 = makeptrtype_245211(c, (*n).typ);
	result = newnodeit_193807(((NU8) 64), (*n).info, LOC20);
	add_192164(result, n);
	}BeforeRet: ;
	return result;
}

static N_INLINE(void, asgntoresultvar_448017)(Tcontext245023* c, Tnode191813* n, Tnode191813* le, Tnode191813* ri) {
	{
		Tnode191813* x;
		if (!((*le).kind == ((NU8) 65))) goto LA3;
		x = (*le).kindU.S6.sons->data[((NI) 0)];
		{
			NIM_BOOL LOC7;
			NIM_BOOL LOC8;
			LOC7 = 0;
			LOC8 = 0;
			LOC8 = ((*(*x).typ).kind == ((NU8) 23));
			if (!(LOC8)) goto LA9;
			LOC8 = ((*x).kind == ((NU8) 3));
			LA9: ;
			LOC7 = LOC8;
			if (!(LOC7)) goto LA10;
			LOC7 = ((*(*x).kindU.S4.sym).kind == ((NU8) 11));
			LA10: ;
			if (!LOC7) goto LA11;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), x);
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), takeimplicitaddr_447986(c, ri));
			(*(*x).typ).flags |= ((NI32)1)<<((((NU8) 18))%(sizeof(NI32)*8));
		}
		LA11: ;
	}
	LA3: ;
}

N_NIMCALL(Tnode191813*, semasgn_448081)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* a;
	Ttype191849* le;
{	result = 0;
	checksonslen_246249(n, ((NI) 2));
	a = (*n).kindU.S6.sons->data[((NI) 0)];
	switch ((*a).kind) {
	case ((NU8) 45):
	{
		Tnode191813* norig;
		norig = copytree_196028(n);
		a = builtinfieldaccess_446958(c, a, 1);
		{
			Tnode191813* LOC6;
			Tnode191813* LOC11;
			if (!(a == NIM_NIL)) goto LA4;
			LOC6 = 0;
			LOC6 = HEX5BHEX5D_192244(n, ((NI) 0));
			a = propertywriteaccess_447920(c, n, norig, LOC6);
			{
				if (!!((a == NIM_NIL))) goto LA9;
				result = a;
				goto BeforeRet;
			}
			LA9: ;
			LOC11 = 0;
			LOC11 = HEX5BHEX5D_192244(n, ((NI) 0));
			a = dottransformation_447679(c, LOC11);
			{
				if (!((*a).kind == ((NU8) 25))) goto LA14;
				(*a).kind = ((NU8) 27);
				a = semexprwithtype_410211(c, a, 1);
			}
			LA14: ;
		}
		LA4: ;
	}
	break;
	case ((NU8) 42):
	{
		Tnode191813* oldbracketexpr;
		oldbracketexpr = (*(*c).p).bracketexpr;
		a = semsubscript_447774(c, a, 1);
		{
			Tident168021* LOC21;
			Tnode191813* LOC22;
			if (!(a == NIM_NIL)) goto LA19;
			LOC21 = 0;
			LOC21 = getident_168463(((NimStringDesc*) &TMP3363));
			result = buildoverloadedsubscripts_447722((*n).kindU.S6.sons->data[((NI) 0)], LOC21);
			LOC22 = 0;
			LOC22 = HEX5BHEX5D_192244(n, ((NI) 1));
			add_192164(result, LOC22);
			result = semexprnotype_410221(c, result);
			asgnRefNoCycle((void**) (&(*(*c).p).bracketexpr), oldbracketexpr);
			goto BeforeRet;
		}
		LA19: ;
		asgnRefNoCycle((void**) (&(*(*c).p).bracketexpr), oldbracketexpr);
	}
	break;
	case ((NU8) 40):
	{
		Tident168021* LOC24;
		Tnode191813* LOC25;
		LOC24 = 0;
		LOC24 = getident_168463(((NimStringDesc*) &TMP3364));
		result = buildoverloadedsubscripts_447722((*n).kindU.S6.sons->data[((NI) 0)], LOC24);
		LOC25 = 0;
		LOC25 = HEX5BHEX5D_192244(n, ((NI) 1));
		add_192164(result, LOC25);
		result = semexprnotype_410221(c, result);
		goto BeforeRet;
	}
	break;
	default:
	{
		a = semexprwithtype_410211(c, a, 1);
	}
	break;
	}
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), a);
	le = (*a).typ;
	{
		NIM_BOOL LOC29;
		Ttype191849* LOC30;
		NU8 LOC32;
		NimStringDesc* LOC35;
		LOC29 = 0;
		LOC30 = 0;
		LOC30 = skiptypes_195167(le, 2048);
		LOC29 = !(((*LOC30).kind == ((NU8) 23)));
		if (!(LOC29)) goto LA31;
		LOC32 = 0;
		LOC32 = isassignable_444642(c, a);
		LOC29 = (LOC32 == ((NU8) 0));
		LA31: ;
		if (!LOC29) goto LA33;
		LOC35 = 0;
		LOC35 = rendertree_213058(a, 4);
		localerror_166155((*a).info, ((NU16) 176), LOC35);
	}
	goto LA27;
	LA33: ;
	{
		Tnode191813* lhs;
		NIM_BOOL lhsisresult;
		NIM_BOOL LOC37;
		Tnode191813* rhs;
		NU16 LOC39;
		lhs = (*n).kindU.S6.sons->data[((NI) 0)];
		LOC37 = 0;
		LOC37 = ((*lhs).kind == ((NU8) 3));
		if (!(LOC37)) goto LA38;
		LOC37 = ((*(*lhs).kindU.S4.sym).kind == ((NU8) 11));
		LA38: ;
		lhsisresult = LOC37;
		{
			if (!lhsisresult) goto LA42;
			LOC39 = 64;
		}
		goto LA40;
		LA42: ;
		{
			LOC39 = 0;
		}
		LA40: ;
		rhs = semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 1)], LOC39);
		{
			if (!lhsisresult) goto LA47;
			asgnRefNoCycle((void**) (&(*n).typ), enforcevoidcontext_432005);
			{
				NIM_BOOL LOC51;
				NIM_BOOL LOC53;
				LOC51 = 0;
				LOC51 = !(((*(*(*c).p).owner).kind == ((NU8) 17)));
				if (!(LOC51)) goto LA52;
				LOC53 = 0;
				LOC53 = ismetatype_192821((*(*lhs).kindU.S4.sym).typ);
				if (!(LOC53)) goto LA54;
				LOC53 = !(((*(*(*lhs).kindU.S4.sym).typ).kind == ((NU8) 8)));
				LA54: ;
				LOC51 = LOC53;
				LA52: ;
				if (!LOC51) goto LA55;
				{
					NU8 LOC59;
					LOC59 = 0;
					LOC59 = cmptypes_349708(c, (*lhs).typ, (*rhs).typ);
					if (!(LOC59 == ((NU8) 7))) goto LA60;
					{
						NimStringDesc* LOC66;
						if (!!(!(((*(*c).p).resultsym == NIM_NIL)))) goto LA64;
						LOC66 = 0;
						LOC66 = HEX24_166306(TMP3365);
						internalerror_166218(LOC66);
					}
					LA64: ;
					asgnRefNoCycle((void**) (&(*lhs).typ), (*rhs).typ);
					asgnRefNoCycle((void**) (&(*(*(*c).p).resultsym).typ), (*rhs).typ);
					asgnRefNoCycle((void**) (&(*(*(*(*c).p).owner).typ).sons->data[((NI) 0)]), (*rhs).typ);
				}
				goto LA57;
				LA60: ;
				{
					typemismatch_410379(n, (*lhs).typ, (*rhs).typ);
				}
				LA57: ;
			}
			LA55: ;
		}
		LA47: ;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), fitnode_410245(c, le, rhs));
		{
			NIM_BOOL LOC70;
			LOC70 = 0;
			LOC70 = (((*(*lhs).typ).flags &(1<<((((NU8) 26))&31)))!=0);
			if (!(LOC70)) goto LA71;
			LOC70 = !(lhsisresult);
			LA71: ;
			if (!LOC70) goto LA72;
			result = overloadedasgn_436296(c, lhs, (*n).kindU.S6.sons->data[((NI) 1)]);
			goto BeforeRet;
		}
		LA72: ;
		fixabstracttype_444407(c, n);
		asgntoresultvar_448017(c, n, (*n).kindU.S6.sons->data[((NI) 0)], (*n).kindU.S6.sons->data[((NI) 1)]);
	}
	LA27: ;
	result = n;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semprocbody_410238)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tscope191837* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	result = semexpr_410201(c, n, 0);
	{
		NIM_BOOL LOC4;
		NIM_BOOL LOC6;
		LOC4 = 0;
		LOC4 = !(((*(*c).p).resultsym == NIM_NIL));
		if (!(LOC4)) goto LA5;
		LOC6 = 0;
		LOC6 = isemptytype_196934((*result).typ);
		LOC4 = !(LOC6);
		LA5: ;
		if (!LOC4) goto LA7;
		{
			NIM_BOOL LOC11;
			LOC11 = 0;
			LOC11 = ((*result).kind == ((NU8) 3));
			if (!(LOC11)) goto LA12;
			LOC11 = ((*result).kindU.S4.sym == (*(*c).p).resultsym);
			LA12: ;
			if (!LOC11) goto LA13;
		}
		goto LA9;
		LA13: ;
		{
			if (!((*result).kind == ((NU8) 23))) goto LA16;
			asgnRefNoCycle((void**) (&(*result).typ), NIM_NIL);
		}
		goto LA9;
		LA16: ;
		{
			NIM_BOOL LOC19;
			LOC19 = 0;
			LOC19 = ((*result).kind == ((NU8) 126));
			if (!(LOC19)) goto LA20;
			LOC19 = ((*(*result).typ).kind == ((NU8) 5));
			LA20: ;
			if (!LOC19) goto LA21;
			fixniltype_433694(result);
		}
		goto LA9;
		LA21: ;
		{
			Tnode191813* a;
			a = newnodei_193407(((NU8) 73), (*n).info, ((NI) 2));
			asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325((*(*c).p).resultsym));
			asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 1)]), result);
			result = semasgn_448081(c, a);
		}
		LA9: ;
	}
	goto LA2;
	LA7: ;
	{
		discardcheck_433756(c, result);
	}
	LA2: ;
	{
		NIM_BOOL LOC27;
		NIM_BOOL LOC28;
		LOC27 = 0;
		LOC28 = 0;
		LOC28 = !(((393216 &(1<<(((*(*(*c).p).owner).kind)&31)))!=0));
		if (!(LOC28)) goto LA29;
		LOC28 = !(((*(*c).p).resultsym == NIM_NIL));
		LA29: ;
		LOC27 = LOC28;
		if (!(LOC27)) goto LA30;
		LOC27 = ismetatype_192821((*(*(*c).p).resultsym).typ);
		LA30: ;
		if (!LOC27) goto LA31;
		{
			NIM_BOOL LOC35;
			LOC35 = 0;
			LOC35 = isemptytype_196934((*result).typ);
			if (!LOC35) goto LA36;
			asgnRefNoCycle((void**) (&(*(*(*c).p).resultsym).typ), NIM_NIL);
			asgnRefNoCycle((void**) (&(*(*(*(*c).p).owner).typ).sons->data[((NI) 0)]), NIM_NIL);
		}
		goto LA33;
		LA36: ;
		{
			localerror_166155((*(*(*c).p).resultsym).info, ((NU16) 226), ((NimStringDesc*) &TMP2991));
		}
		LA33: ;
	}
	LA31: ;
	closescope_250111(c);
	return result;
}

N_NIMCALL(void, instantiatebody_412941)(Tcontext245023* c, Tnode191813* n, Tnode191813* params, Tsym191843* result) {
	{
		Tnode191813* b;
		Tidtable191861 symmap;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 6)]).kind == ((NU8) 1)))) goto LA3;
		(*c).ingenericinst += ((NI) 1);
		b = (*n).kindU.S6.sons->data[((NI) 6)];
		memset((void*)(&symmap), 0, sizeof(symmap));
		initidtable_195057((&symmap));
		{
			if (!!((params == NIM_NIL))) goto LA7;
			{
				NI i_413001;
				NI HEX3Atmp_413044;
				NI LOC10;
				NI res_413047;
				i_413001 = 0;
				HEX3Atmp_413044 = 0;
				LOC10 = 0;
				LOC10 = len_192097(params);
				HEX3Atmp_413044 = (LOC10 - 1);
				res_413047 = ((NI) 1);
				{
					while (1) {
						Tsym191843* param;
						Tnode191813* LOC13;
						if (!(res_413047 <= HEX3Atmp_413044)) goto LA12;
						i_413001 = res_413047;
						LOC13 = 0;
						LOC13 = HEX5BHEX5D_192244(params, i_413001);
						param = (*LOC13).kindU.S4.sym;
						{
							Tnode191813* LOC18;
							Tidobj168015* LOC19;
							Tnode191813* LOC20;
							TNimObject* LOC21;
							if (!(((*param).flags &(1<<((((NU8) 31))&31)))!=0)) goto LA16;
							LOC18 = 0;
							LOC18 = HEX5BHEX5D_192244(params, i_413001);
							LOC19 = 0;
							LOC19 = &(*LOC18).kindU.S4.sym->Sup;
							LOC20 = 0;
							LOC20 = HEX5BHEX5D_192244((*(*result).typ).n, (NI)((*param).position + ((NI) 1)));
							LOC21 = 0;
							LOC21 = &(*LOC20).kindU.S4.sym->Sup.Sup;
							idtableput_199196((&symmap), LOC19, LOC21);
						}
						LA16: ;
						res_413047 += ((NI) 1);
					} LA12: ;
				}
			}
		}
		LA7: ;
		freshgensyms_412801(b, result, (&symmap));
		b = semprocbody_410238(c, b);
		b = hlobody_412161(c, b);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), transformbody_371118((*c).module, b, result));
		(*result).flags &= ~(((NI32)1) << ((((NU8) 4)) % (sizeof(NI32)*8)));
		(*c).ingenericinst -= ((NI) 1);
	}
	LA3: ;
}

static N_INLINE(Tsym191843*, pop_368918)(Tsymseq191815** s) {
	Tsym191843* result;
	NI L;
	result = 0;
	L = (NI)(((*s) ? (*s)->Sup.len : 0) - ((NI) 1));
	result = (*s)->data[L];
	(*s) = (Tsymseq191815*) setLengthSeq(&((*s))->Sup, sizeof(Tsym191843*), ((NI) (L)));
	return result;
}

N_NIMCALL(NIM_BOOL, hasobjparam_440633)(Tsym191843* s) {
	NIM_BOOL result;
	Ttype191849* t;
{	result = 0;
	t = (*s).typ;
	{
		NI col_440651;
		NI HEX3Atmp_440662;
		NI LOC2;
		NI res_440665;
		col_440651 = 0;
		HEX3Atmp_440662 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194351(t);
		HEX3Atmp_440662 = (NI)(LOC2 - ((NI) 1));
		res_440665 = ((NI) 1);
		{
			while (1) {
				if (!(res_440665 <= HEX3Atmp_440662)) goto LA4;
				col_440651 = res_440665;
				{
					Ttype191849* LOC7;
					LOC7 = 0;
					LOC7 = skiptypes_195167((*t).sons->data[col_440651], IL64(211106247215360));
					if (!((*LOC7).kind == ((NU8) 17))) goto LA8;
					result = NIM_TRUE;
					goto BeforeRet;
				}
				LA8: ;
				res_440665 += ((NI) 1);
			} LA4: ;
		}
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, finishmethod_410341)(Tcontext245023* c, Tsym191843* s) {
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = hasobjparam_440633(s);
		if (!LOC3) goto LA4;
		methoddef_356634(s, NIM_FALSE);
	}
	LA4: ;
}

N_NIMCALL(Tsym191843*, generateinstance_413450)(Tcontext245023* c, Tsym191843* fn, Tidtable191861 pt, Tlineinfo164338 info) {
	Tsym191843* result;
	Tnode191813* n;
	Tsym191843* LOC9;
	Tscope191837* LOC10;
	Tinstantiation191833* entry;
	Tsym191843* oldprc;
	Tsym191843* LOC35;
{	result = 0;
	{
		if (!((393216 &(1<<(((*fn).kind)&31)))!=0)) goto LA3;
		result = fn;
		goto BeforeRet;
	}
	LA3: ;
	{
		if (!(((NI) 1000) < (*c).instcounter)) goto LA7;
		internalerror_166199((*(*fn).ast).info, ((NimStringDesc*) &TMP3020));
	}
	LA7: ;
	(*c).instcounter += ((NI) 1);
	n = copytree_196028((*fn).ast);
	LOC9 = 0;
	LOC9 = getmodule_199243(fn);
	(*c).friendmodules = (Tsymseq191815*) incrSeq(&((*c).friendmodules)->Sup, sizeof(Tsym191843*));
	asgnRefNoCycle((void**) (&(*c).friendmodules->data[(*c).friendmodules->Sup.len-1]), LOC9);
	result = copysym_194607(fn, NIM_FALSE);
	(*result).flags |= ((NI32)1)<<((((NU8) 2))%(sizeof(NI32)*8));
	asgnRefNoCycle((void**) (&(*result).owner), fn);
	asgnRefNoCycle((void**) (&(*result).ast), n);
	pushowner_245260(result);
	LOC10 = 0;
	LOC10 = openscope_250091(c);
	{
		NimStringDesc* LOC15;
		if (!!(!(((*(*n).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1))))) goto LA13;
		LOC15 = 0;
		LOC15 = HEX24_166306(TMP3021);
		internalerror_166218(LOC15);
	}
	LA13: ;
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(result));
	pushinfocontext_165189(info);
	entry = new_413524();
	asgnRefNoCycle((void**) (&(*entry).sym), result);
	instantiategenericparamlist_412213(c, (*n).kindU.S6.sons->data[((NI) 2)], pt, entry);
	pushproccon_245358(c, result);
	instantiateproctype_413176(c, pt, result, info);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), emptynode_192807);
	oldprc = genericcacheget_412447(fn, (&(*entry)));
	{
		Tinstantiationpair245013 LOC24;
		if (!(oldprc == NIM_NIL)) goto LA18;
		{
			if (!((*c).incompilescontext == ((NI) 0))) goto LA22;
			safeadd_413561((&(*fn).kindU.S2.procinstcache), entry);
		}
		LA22: ;
		memset((void*)(&LOC24), 0, sizeof(LOC24));
		makeinstpair_245157(fn, entry, (&LOC24));
		(*c).generics = (TY245141*) incrSeq(&((*c).generics)->Sup, sizeof(Tinstantiationpair245013));
		asgnRefNoCycle((void**) (&(*c).generics->data[(*c).generics->Sup.len-1].genericsym), LOC24.genericsym);
		asgnRefNoCycle((void**) (&(*c).generics->data[(*c).generics->Sup.len-1].inst), LOC24.inst);
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 4)]).kind == ((NU8) 1)))) goto LA27;
			pragma_261069(c, result, (*n).kindU.S6.sons->data[((NI) 4)], TMP3101);
		}
		LA27: ;
		{
			Tnode191813* LOC33;
			if (!(*n).kindU.S6.sons->data[((NI) 6)] == 0) goto LA31;
			LOC33 = 0;
			LOC33 = getbody_236647(fn);
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), copytree_196028(LOC33));
		}
		LA31: ;
		instantiatebody_412941(c, n, (*(*fn).typ).n, result);
		sideeffectscheck_413116(c, result);
		paramstypecheck_411015(c, (*result).typ);
	}
	goto LA16;
	LA18: ;
	{
		result = oldprc;
	}
	LA16: ;
	popproccon_245390(c);
	popinfocontext_165208();
	closescope_250111(c);
	popowner_245266();
	LOC35 = 0;
	LOC35 = pop_368918((&(*c).friendmodules));
	(*c).instcounter -= ((NI) 1);
	{
		if (!((*result).kind == ((NU8) 13))) goto LA38;
		finishmethod_410341(c, result);
	}
	LA38: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, instgenericconvertersarg_415176)(Tcontext245023* c, Tnode191813* a, Tcandidate345209* x) {
	{
		NIM_BOOL LOC3;
		NIM_BOOL LOC4;
		Tsym191843* finalcallee;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = ((*a).kind == ((NU8) 32));
		if (!(LOC4)) goto LA5;
		LOC4 = ((*(*a).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3));
		LA5: ;
		LOC3 = LOC4;
		if (!(LOC3)) goto LA6;
		LOC3 = isgenericroutine_196652((*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym);
		LA6: ;
		if (!LOC3) goto LA7;
		finalcallee = generateinstance_413450(c, (*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym, (*x).bindings, (*a).info);
		asgnRefNoCycle((void**) (&(*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym), finalcallee);
		asgnRefNoCycle((void**) (&(*(*a).kindU.S6.sons->data[((NI) 0)]).typ), (*finalcallee).typ);
	}
	LA7: ;
}

N_NIMCALL(Tnode191813*, indextypesmatch_410348)(Tcontext245023* c, Ttype191849* f, Ttype191849* a, Tnode191813* arg) {
	Tnode191813* result;
	Tcandidate345209 m;
	result = 0;
	memset((void*)(&m), 0, sizeof(m));
	initcandidate_345276(c, (&m), f);
	result = paramtypesmatch_350556((&m), f, a, arg, NIM_NIL);
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = m.genericconverter;
		if (!(LOC3)) goto LA4;
		LOC3 = !((result == NIM_NIL));
		LA4: ;
		if (!LOC3) goto LA5;
		instgenericconvertersarg_415176(c, result, (&m));
	}
	LA5: ;
	return result;
}

N_NIMCALL(Tnode191813*, fitnode_410245)(Tcontext245023* c, Ttype191849* formal, Tnode191813* arg) {
	Tnode191813* result;
	result = 0;
	{
		NimStringDesc* LOC5;
		if (!(*arg).typ == 0) goto LA3;
		LOC5 = 0;
		LOC5 = rendertree_213058(arg, 4);
		localerror_166155((*arg).info, ((NU16) 90), LOC5);
		result = copynode_195640(arg);
		asgnRefNoCycle((void**) (&(*result).typ), formal);
	}
	goto LA1;
	LA3: ;
	{
		result = indextypesmatch_410348(c, formal, (*arg).typ, arg);
		{
			if (!(result == NIM_NIL)) goto LA9;
			typemismatch_410379(arg, formal, (*arg).typ);
			result = copytree_196028(arg);
			asgnRefNoCycle((void**) (&(*result).typ), formal);
		}
		goto LA7;
		LA9: ;
		{
			Tnode191813* x;
			x = skipconv_230935(result);
			{
				NIM_BOOL LOC14;
				LOC14 = 0;
				LOC14 = ((*x).kind == ((NU8) 37));
				if (!(LOC14)) goto LA15;
				LOC14 = !(((*formal).kind == ((NU8) 6)));
				LA15: ;
				if (!LOC14) goto LA16;
				changetype_410253(x, formal, NIM_TRUE);
			}
			goto LA12;
			LA16: ;
			{
				result = skiphiddensubconv_231078(result);
			}
			LA12: ;
		}
		LA7: ;
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semconstboolexpr_416652)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* nn;
	Ttype191849* LOC1;
{	result = 0;
	nn = semexprwithtype_410211(c, n, 0);
	LOC1 = 0;
	LOC1 = getsystype_239030(((NU8) 1));
	result = fitnode_410245(c, LOC1, nn);
	{
		if (!(result == NIM_NIL)) goto LA4;
		localerror_166155((*n).info, ((NU16) 104), ((NimStringDesc*) &TMP2991));
		result = nn;
		goto BeforeRet;
	}
	LA4: ;
	result = getconstexpr_257004((*c).module, result);
	{
		if (!(result == NIM_NIL)) goto LA8;
		localerror_166155((*n).info, ((NU16) 104), ((NimStringDesc*) &TMP2991));
		result = nn;
	}
	LA8: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, forcebool_416629)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Ttype191849* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = getsystype_239030(((NU8) 1));
	result = fitnode_410245(c, LOC1, n);
	{
		if (!(result == NIM_NIL)) goto LA4;
		result = n;
	}
	LA4: ;
	return result;
}

N_NIMCALL(Tnode191813*, sembranchrange_418878)(Tcontext245023* c, Tnode191813* t, Tnode191813* a, Tnode191813* b, NI64* covered) {
	Tnode191813* result;
	Tnode191813* ac;
	Tnode191813* bc;
	Tnode191813* at;
	Tnode191813* LOC1;
	Tnode191813* bt;
	Tnode191813* LOC2;
	result = 0;
	checkminsonslen_246259(t, ((NI) 1));
	ac = semconstexpr_411485(c, a);
	bc = semconstexpr_411485(c, b);
	LOC1 = 0;
	LOC1 = fitnode_410245(c, (*(*t).kindU.S6.sons->data[((NI) 0)]).typ, ac);
	at = skipconvtaketype_230967(LOC1);
	LOC2 = 0;
	LOC2 = fitnode_410245(c, (*(*t).kindU.S6.sons->data[((NI) 0)]).typ, bc);
	bt = skipconvtaketype_230967(LOC2);
	result = newnodei_193351(((NU8) 44), (*a).info);
	add_192164(result, at);
	add_192164(result, bt);
	{
		NIM_BOOL LOC5;
		LOC5 = 0;
		LOC5 = emptyrange_241034(ac, bc);
		if (!LOC5) goto LA6;
		localerror_166155((*b).info, ((NU16) 106), ((NimStringDesc*) &TMP2991));
	}
	goto LA3;
	LA6: ;
	{
		NI64 LOC9;
		NI64 LOC10;
		LOC9 = 0;
		LOC9 = getordvalue_221178(bc);
		LOC10 = 0;
		LOC10 = getordvalue_221178(ac);
		(*covered) = (NI64)((NI64)((NI64)((*covered) + LOC9) - LOC10) + IL64(1));
	}
	LA3: ;
	return result;
}

N_NIMCALL(Tnode191813*, semcasebranchrange_418900)(Tcontext245023* c, Tnode191813* t, Tnode191813* b, NI64* covered) {
	Tnode191813* result;
	result = 0;
	checksonslen_246249(b, ((NI) 3));
	result = sembranchrange_418878(c, t, (*b).kindU.S6.sons->data[((NI) 1)], (*b).kindU.S6.sons->data[((NI) 2)], covered);
	return result;
}

N_NIMCALL(Tnode191813*, semcasebranchsetelem_418913)(Tcontext245023* c, Tnode191813* t, Tnode191813* b, NI64* covered) {
	Tnode191813* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = isrange_220612(b);
		if (!LOC3) goto LA4;
		checksonslen_246249(b, ((NI) 3));
		result = sembranchrange_418878(c, t, (*b).kindU.S6.sons->data[((NI) 1)], (*b).kindU.S6.sons->data[((NI) 2)], covered);
	}
	goto LA1;
	LA4: ;
	{
		if (!((*b).kind == ((NU8) 44))) goto LA7;
		checksonslen_246249(b, ((NI) 2));
		result = sembranchrange_418878(c, t, (*b).kindU.S6.sons->data[((NI) 0)], (*b).kindU.S6.sons->data[((NI) 1)], covered);
	}
	goto LA1;
	LA7: ;
	{
		result = fitnode_410245(c, (*(*t).kindU.S6.sons->data[((NI) 0)]).typ, b);
		(*covered) += ((NI) 1);
	}
	LA1: ;
	return result;
}

N_NIMCALL(void, checkforoverlap_418804)(Tcontext245023* c, Tnode191813* t, NI currentex, NI branchindex) {
	Tnode191813* ex;
	Tnode191813* LOC1;
	Tnode191813* LOC2;
	LOC1 = 0;
	LOC1 = HEX5BHEX5D_192244(t, branchindex);
	LOC2 = 0;
	LOC2 = HEX5BHEX5D_192244(LOC1, currentex);
	ex = skipconv_230935(LOC2);
	{
		NI i_418824;
		NI res_418853;
		i_418824 = 0;
		res_418853 = ((NI) 1);
		{
			while (1) {
				if (!(res_418853 <= branchindex)) goto LA5;
				i_418824 = res_418853;
				{
					NI j_418838;
					NI HEX3Atmp_418844;
					NI LOC7;
					NI res_418847;
					j_418838 = 0;
					HEX3Atmp_418844 = 0;
					LOC7 = 0;
					LOC7 = sonslen_194403((*t).kindU.S6.sons->data[i_418824]);
					HEX3Atmp_418844 = (NI)(LOC7 - ((NI) 2));
					res_418847 = ((NI) 0);
					{
						while (1) {
							if (!(res_418847 <= HEX3Atmp_418844)) goto LA9;
							j_418838 = res_418847;
							{
								NIM_BOOL LOC12;
								LOC12 = 0;
								LOC12 = (i_418824 == branchindex);
								if (!(LOC12)) goto LA13;
								LOC12 = (j_418838 == currentex);
								LA13: ;
								if (!LOC12) goto LA14;
								goto LA6;
							}
							LA14: ;
							{
								Tnode191813* LOC18;
								NIM_BOOL LOC19;
								LOC18 = 0;
								LOC18 = skipconv_230935((*(*t).kindU.S6.sons->data[i_418824]).kindU.S6.sons->data[j_418838]);
								LOC19 = 0;
								LOC19 = overlap_241012(LOC18, ex);
								if (!LOC19) goto LA20;
								localerror_166155((*ex).info, ((NU16) 105), ((NimStringDesc*) &TMP2991));
							}
							LA20: ;
							res_418847 += ((NI) 1);
						} LA9: ;
					}
				} LA6: ;
				res_418853 += ((NI) 1);
			} LA5: ;
		}
	}
}

N_NIMCALL(void, semcasebranch_418947)(Tcontext245023* c, Tnode191813* t, Tnode191813* branch, NI branchindex, NI64* covered) {
{	{
		NI i_418967;
		NI HEX3Atmp_419060;
		NI LOC2;
		NI res_419063;
		i_418967 = 0;
		HEX3Atmp_419060 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(branch);
		HEX3Atmp_419060 = (NI)(LOC2 - ((NI) 2));
		res_419063 = ((NI) 0);
		{
			while (1) {
				Tnode191813* b;
				if (!(res_419063 <= HEX3Atmp_419060)) goto LA4;
				i_418967 = res_419063;
				b = (*branch).kindU.S6.sons->data[i_418967];
				{
					if (!((*b).kind == ((NU8) 44))) goto LA7;
					asgnRefNoCycle((void**) (&(*branch).kindU.S6.sons->data[i_418967]), b);
				}
				goto LA5;
				LA7: ;
				{
					NIM_BOOL LOC10;
					LOC10 = 0;
					LOC10 = isrange_220612(b);
					if (!LOC10) goto LA11;
					asgnRefNoCycle((void**) (&(*branch).kindU.S6.sons->data[i_418967]), semcasebranchrange_418900(c, t, b, covered));
				}
				goto LA5;
				LA11: ;
				{
					Tnode191813* r;
					r = semconstexpr_411485(c, b);
					{
						NIM_BOOL LOC16;
						NIM_BOOL LOC17;
						NI LOC19;
						NI LOC21;
						LOC16 = 0;
						LOC17 = 0;
						LOC17 = ((*r).kind == ((NU8) 39) || (*r).kind == ((NU8) 41));
						if (!(LOC17)) goto LA18;
						LOC19 = 0;
						LOC19 = len_192097(r);
						LOC17 = (LOC19 == ((NI) 0));
						LA18: ;
						LOC16 = LOC17;
						if (!(LOC16)) goto LA20;
						LOC21 = 0;
						LOC21 = sonslen_194403(branch);
						LOC16 = (LOC21 == ((NI) 2));
						LA20: ;
						if (!LOC16) goto LA22;
						delson_195577(branch, ((NI) 0));
						goto BeforeRet;
					}
					goto LA14;
					LA22: ;
					{
						NIM_BOOL LOC25;
						NI LOC27;
						Tnode191813* LOC30;
						LOC25 = 0;
						LOC25 = !(((*r).kind == ((NU8) 39) || (*r).kind == ((NU8) 41)));
						if (LOC25) goto LA26;
						LOC27 = 0;
						LOC27 = len_192097(r);
						LOC25 = (LOC27 == ((NI) 0));
						LA26: ;
						if (!LOC25) goto LA28;
						checkminsonslen_246259(t, ((NI) 1));
						LOC30 = 0;
						LOC30 = fitnode_410245(c, (*(*t).kindU.S6.sons->data[((NI) 0)]).typ, r);
						asgnRefNoCycle((void**) (&(*branch).kindU.S6.sons->data[i_418967]), skipconv_230935(LOC30));
						(*covered) += ((NI) 1);
					}
					goto LA14;
					LA28: ;
					{
						Tnode191813* LOC32;
						LOC32 = 0;
						LOC32 = HEX5BHEX5D_192244(r, ((NI) 0));
						asgnRefNoCycle((void**) (&(*branch).kindU.S6.sons->data[i_418967]), semcasebranchsetelem_418913(c, t, LOC32, covered));
						{
							NI j_419035;
							NI HEX3Atmp_419053;
							NI LOC34;
							NI res_419056;
							j_419035 = 0;
							HEX3Atmp_419053 = 0;
							LOC34 = 0;
							LOC34 = len_192097(r);
							HEX3Atmp_419053 = (LOC34 - 1);
							res_419056 = ((NI) 1);
							{
								while (1) {
									Tnode191813* LOC37;
									Tnode191813* LOC38;
									NI L;
									Tnode191813* LOC39;
									if (!(res_419056 <= HEX3Atmp_419053)) goto LA36;
									j_419035 = res_419056;
									LOC37 = 0;
									LOC37 = HEX5BHEX5D_192244(r, j_419035);
									LOC38 = 0;
									LOC38 = semcasebranchsetelem_418913(c, t, LOC37, covered);
									add_192164(branch, LOC38);
									L = len_192097(branch);
									LOC39 = 0;
									LOC39 = (*branch).kindU.S6.sons->data[(NI)(L - ((NI) 2))];
									asgnRefNoCycle((void**) (&(*branch).kindU.S6.sons->data[(NI)(L - ((NI) 2))]), (*branch).kindU.S6.sons->data[(NI)(L - ((NI) 1))]);
									asgnRefNoCycle((void**) (&(*branch).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), LOC39);
									res_419056 += ((NI) 1);
								} LA36: ;
							}
						}
					}
					LA14: ;
				}
				LA5: ;
				checkforoverlap_418804(c, t, i_418967, branchindex);
				res_419063 += ((NI) 1);
			} LA4: ;
		}
	}
	}BeforeRet: ;
}

N_NIMCALL(void, semrecordcase_419098)(Tcontext245023* c, Tnode191813* n, Intset188056* check, NI* pos, Tnode191813* father, Ttype191849* rectype) {
	Tnode191813* a;
	NI64 covered;
	Ttype191849* typ;
	NIM_BOOL chckcovered;
{	a = copynode_195640(n);
	checkminsonslen_246259(n, ((NI) 2));
	semrecordnodeaux_419088(c, (*n).kindU.S6.sons->data[((NI) 0)], check, pos, a, rectype);
	{
		if (!!(((*(*a).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA3;
		internalerror_166218(((NimStringDesc*) &TMP3381));
		goto BeforeRet;
	}
	LA3: ;
	(*(*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).flags |= ((NI32)1)<<((((NU8) 18))%(sizeof(NI32)*8));
	covered = IL64(0);
	typ = skiptypes_195167((*(*a).kindU.S6.sons->data[((NI) 0)]).typ, IL64(211106240964608));
	{
		NIM_BOOL LOC7;
		LOC7 = 0;
		LOC7 = isordinaltype_221093(typ);
		if (!!(LOC7)) goto LA8;
		localerror_166155((*n).info, ((NU16) 108), ((NimStringDesc*) &TMP2991));
	}
	goto LA5;
	LA8: ;
	{
		NI64 LOC11;
		LOC11 = 0;
		LOC11 = firstord_221004(typ);
		if (!(LOC11 < IL64(0))) goto LA12;
		localerror_166155((*n).info, ((NU16) 109), (*(*(*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).name).s);
	}
	goto LA5;
	LA12: ;
	{
		NI64 LOC15;
		LOC15 = 0;
		LOC15 = lengthord_221016(typ);
		if (!(IL64(32767) < LOC15)) goto LA16;
		localerror_166155((*n).info, ((NU16) 110), (*(*(*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).name).s);
	}
	goto LA5;
	LA16: ;
	LA5: ;
	chckcovered = NIM_TRUE;
	{
		NI i_419169;
		NI HEX3Atmp_419178;
		NI LOC19;
		NI res_419181;
		i_419169 = 0;
		HEX3Atmp_419178 = 0;
		LOC19 = 0;
		LOC19 = sonslen_194403(n);
		HEX3Atmp_419178 = (NI)(LOC19 - ((NI) 1));
		res_419181 = ((NI) 1);
		{
			while (1) {
				Tnode191813* b;
				NI LOC25;
				Tnode191813* LOC26;
				if (!(res_419181 <= HEX3Atmp_419178)) goto LA21;
				i_419169 = res_419181;
				b = copytree_196028((*n).kindU.S6.sons->data[i_419169]);
				addson_193819(a, b);
				switch ((*(*n).kindU.S6.sons->data[i_419169]).kind) {
				case ((NU8) 85):
				{
					checkminsonslen_246259(b, ((NI) 2));
					semcasebranch_418947(c, a, b, i_419169, (&covered));
				}
				break;
				case ((NU8) 88):
				{
					chckcovered = NIM_FALSE;
					checksonslen_246249(b, ((NI) 1));
				}
				break;
				default:
				{
					illformedast_246229(n);
				}
				break;
				}
				LOC25 = 0;
				LOC25 = sonslen_194403(b);
				delson_195577(b, (NI)(LOC25 - ((NI) 1)));
				LOC26 = 0;
				LOC26 = lastson_194431((*n).kindU.S6.sons->data[i_419169]);
				semrecordnodeaux_419088(c, LOC26, check, pos, b, rectype);
				res_419181 += ((NI) 1);
			} LA21: ;
		}
	}
	{
		NIM_BOOL LOC29;
		NI64 LOC31;
		LOC29 = 0;
		LOC29 = chckcovered;
		if (!(LOC29)) goto LA30;
		LOC31 = 0;
		LOC31 = lengthord_221016((*(*a).kindU.S6.sons->data[((NI) 0)]).typ);
		LOC29 = !((covered == LOC31));
		LA30: ;
		if (!LOC29) goto LA32;
		localerror_166155((*a).info, ((NU16) 151), ((NimStringDesc*) &TMP2991));
	}
	LA32: ;
	addson_193819(father, a);
	}BeforeRet: ;
}

N_NIMCALL(void, semrecordnodeaux_419088)(Tcontext245023* c, Tnode191813* n, Intset188056* check, NI* pos, Tnode191813* father, Ttype191849* rectype) {
{	{
		if (!(n == NIM_NIL)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	switch ((*n).kind) {
	case ((NU8) 140):
	{
		Tnode191813* branch;
		branch = NIM_NIL;
		{
			NI i_419232;
			NI HEX3Atmp_419613;
			NI LOC7;
			NI res_419616;
			i_419232 = 0;
			HEX3Atmp_419613 = 0;
			LOC7 = 0;
			LOC7 = sonslen_194403(n);
			HEX3Atmp_419613 = (NI)(LOC7 - ((NI) 1));
			res_419616 = ((NI) 0);
			{
				while (1) {
					Tnode191813* it;
					NI idx;
					if (!(res_419616 <= HEX3Atmp_419613)) goto LA9;
					i_419232 = res_419616;
					it = (*n).kindU.S6.sons->data[i_419232];
					{
						if (!(it == NIM_NIL)) goto LA12;
						illformedast_246229(n);
					}
					LA12: ;
					idx = ((NI) 1);
					switch ((*it).kind) {
					case ((NU8) 86):
					{
						checksonslen_246249(it, ((NI) 2));
						{
							Tnode191813* e;
							if (!((*c).ingenericcontext == ((NI) 0))) goto LA17;
							e = semconstboolexpr_416652(c, (*it).kindU.S6.sons->data[((NI) 0)]);
							{
								if (!!(((*e).kind == ((NU8) 6)))) goto LA21;
								internalerror_166199((*e).info, ((NimStringDesc*) &TMP3380));
							}
							goto LA19;
							LA21: ;
							{
								NIM_BOOL LOC24;
								LOC24 = 0;
								LOC24 = !(((*e).kindU.S1.intval == IL64(0)));
								if (!(LOC24)) goto LA25;
								LOC24 = (branch == NIM_NIL);
								LA25: ;
								if (!LOC24) goto LA26;
								branch = (*it).kindU.S6.sons->data[((NI) 1)];
							}
							goto LA19;
							LA26: ;
							LA19: ;
						}
						goto LA15;
						LA17: ;
						{
							Tnode191813* LOC29;
							LOC29 = 0;
							LOC29 = semexprwithtype_410211(c, (*it).kindU.S6.sons->data[((NI) 0)], 0);
							asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[((NI) 0)]), forcebool_416629(c, LOC29));
						}
						LA15: ;
					}
					break;
					case ((NU8) 88):
					{
						checksonslen_246249(it, ((NI) 1));
						{
							if (!(branch == NIM_NIL)) goto LA33;
							branch = (*it).kindU.S6.sons->data[((NI) 0)];
						}
						LA33: ;
						idx = ((NI) 0);
					}
					break;
					default:
					{
						illformedast_246229(n);
					}
					break;
					}
					{
						Intset188056 newcheck;
						NI newpos;
						Tnode191813* newf;
						if (!(((NI) 0) < (*c).ingenericcontext)) goto LA38;
						memset((void*)(&newcheck), 0, sizeof(newcheck));
						assign_188946((&newcheck), (&(*check)));
						newpos = (*pos);
						newf = newnodei_193351(((NU8) 138), (*n).info);
						semrecordnodeaux_419088(c, (*it).kindU.S6.sons->data[idx], (&newcheck), (&newpos), newf, rectype);
						{
							NI LOC42;
							LOC42 = 0;
							LOC42 = len_192097(newf);
							if (!(LOC42 == ((NI) 1))) goto LA43;
							asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[idx]), HEX5BHEX5D_192244(newf, ((NI) 0)));
						}
						goto LA40;
						LA43: ;
						{
							asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[idx]), newf);
						}
						LA40: ;
					}
					LA38: ;
					res_419616 += ((NI) 1);
				} LA9: ;
			}
		}
		{
			if (!(((NI) 0) < (*c).ingenericcontext)) goto LA48;
			addson_193819(father, n);
		}
		goto LA46;
		LA48: ;
		{
			if (!!((branch == NIM_NIL))) goto LA51;
			semrecordnodeaux_419088(c, branch, check, pos, father, rectype);
		}
		goto LA46;
		LA51: ;
		LA46: ;
	}
	break;
	case ((NU8) 139):
	{
		semrecordcase_419098(c, n, check, pos, father, rectype);
	}
	break;
	case ((NU8) 23):
	{
		{
			Tnode191813* LOC59;
			if (!!(((*father).kind == ((NU8) 138)))) goto LA57;
			LOC59 = 0;
			LOC59 = newnodei_193351(((NU8) 138), (*n).info);
			addson_193819(father, LOC59);
		}
		LA57: ;
	}
	break;
	case ((NU8) 138):
	{
		Tnode191813* a;
		{
			if (!((*father).kind == ((NU8) 138))) goto LA63;
			a = father;
		}
		goto LA61;
		LA63: ;
		{
			a = copynode_195640(n);
		}
		LA61: ;
		{
			NI i_419340;
			NI HEX3Atmp_419621;
			NI LOC67;
			NI res_419624;
			i_419340 = 0;
			HEX3Atmp_419621 = 0;
			LOC67 = 0;
			LOC67 = sonslen_194403(n);
			HEX3Atmp_419621 = (NI)(LOC67 - ((NI) 1));
			res_419624 = ((NI) 0);
			{
				while (1) {
					if (!(res_419624 <= HEX3Atmp_419621)) goto LA69;
					i_419340 = res_419624;
					semrecordnodeaux_419088(c, (*n).kindU.S6.sons->data[i_419340], check, pos, a, rectype);
					res_419624 += ((NI) 1);
				} LA69: ;
			}
		}
		{
			if (!!((a == father))) goto LA72;
			addson_193819(father, a);
		}
		LA72: ;
	}
	break;
	case ((NU8) 35):
	{
		NI length;
		Tnode191813* a;
		Ttype191849* typ;
		Tsym191843* rec;
		checkminsonslen_246259(n, ((NI) 3));
		length = sonslen_194403(n);
		a = 0;
		{
			NIM_BOOL LOC77;
			LOC77 = 0;
			LOC77 = !(((*father).kind == ((NU8) 138)));
			if (!(LOC77)) goto LA78;
			LOC77 = (((NI) 4) <= length);
			LA78: ;
			if (!LOC77) goto LA79;
			a = newnodei_193351(((NU8) 138), (*n).info);
		}
		goto LA75;
		LA79: ;
		{
			a = emptynode_192807;
		}
		LA75: ;
		{
			if (!!(((*(*n).kindU.S6.sons->data[(NI)(length - ((NI) 1))]).kind == ((NU8) 1)))) goto LA84;
			localerror_166155((*(*n).kindU.S6.sons->data[(NI)(length - ((NI) 1))]).info, ((NU16) 175), ((NimStringDesc*) &TMP2991));
		}
		LA84: ;
		typ = 0;
		{
			if (!((*(*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))]).kind == ((NU8) 1))) goto LA88;
			localerror_166155((*n).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
			typ = errortype_246150(c);
		}
		goto LA86;
		LA88: ;
		{
			typ = semtypenode_410269(c, (*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))], NIM_NIL);
			propagatetoowner_195274(rectype, typ);
		}
		LA86: ;
		rec = (*rectype).sym;
		{
			NI i_419400;
			NI HEX3Atmp_419631;
			NI LOC92;
			NI res_419634;
			i_419400 = 0;
			HEX3Atmp_419631 = 0;
			LOC92 = 0;
			LOC92 = sonslen_194403(n);
			HEX3Atmp_419631 = (NI)(LOC92 - ((NI) 3));
			res_419634 = ((NI) 0);
			{
				while (1) {
					Tsym191843* f;
					if (!(res_419634 <= HEX3Atmp_419631)) goto LA94;
					i_419400 = res_419634;
					f = semidentwithpragma_410964(c, ((NU8) 19), (*n).kindU.S6.sons->data[i_419400], 2);
					suggestsym_354960((*(*n).kindU.S6.sons->data[i_419400]).info, f);
					asgnRefNoCycle((void**) (&(*f).typ), typ);
					(*f).position = (*pos);
					{
						NIM_BOOL LOC97;
						NIM_BOOL LOC98;
						LOC97 = 0;
						LOC98 = 0;
						LOC98 = !((rec == NIM_NIL));
						if (!(LOC98)) goto LA99;
						LOC98 = !(((96 & (*rec).flags) == 0));
						LA99: ;
						LOC97 = LOC98;
						if (!(LOC97)) goto LA100;
						LOC97 = ((*f).loc.r == NIM_NIL);
						LA100: ;
						if (!LOC97) goto LA101;
						asgnRefNoCycle((void**) (&(*f).loc.r), rope_162320((*(*f).name).s));
						(*f).flags = ((*f).flags | (96 & (*rec).flags));
					}
					LA101: ;
					(*pos) += ((NI) 1);
					{
						NIM_BOOL LOC105;
						LOC105 = 0;
						LOC105 = containsorincl_188898(check, (*(*f).name).Sup.id);
						if (!LOC105) goto LA106;
						localerror_166155((*(*n).kindU.S6.sons->data[i_419400]).info, ((NU16) 40), (*(*f).name).s);
					}
					LA106: ;
					{
						Tnode191813* LOC112;
						if (!((*a).kind == ((NU8) 1))) goto LA110;
						LOC112 = 0;
						LOC112 = newsymnode_193325(f);
						addson_193819(father, LOC112);
					}
					goto LA108;
					LA110: ;
					{
						Tnode191813* LOC114;
						LOC114 = 0;
						LOC114 = newsymnode_193325(f);
						addson_193819(a, LOC114);
					}
					LA108: ;
					res_419634 += ((NI) 1);
				} LA94: ;
			}
		}
		{
			if (!!(((*a).kind == ((NU8) 1)))) goto LA117;
			addson_193819(father, a);
		}
		LA117: ;
	}
	break;
	case ((NU8) 1):
	{
	}
	break;
	default:
	{
		illformedast_246229(n);
	}
	break;
	}
	}BeforeRet: ;
}

N_NIMCALL(Ttype191849*, semobjectnode_420016)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	Intset188056 check;
	NI pos;
	Ttype191849* base;
{	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 0))) goto LA4;
		result = newconstraint_416725(c, ((NU8) 17));
		goto BeforeRet;
	}
	LA4: ;
	memset((void*)(&check), 0, sizeof(check));
	chckNil((void*)(&check));
	memset((void*)(&check), 0, sizeof(check));
	initintset_188927((&check));
	pos = ((NI) 0);
	base = NIM_NIL;
	checksonslen_246249(n, ((NI) 3));
	{
		Ttype191849* LOC10;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1)))) goto LA8;
		LOC10 = 0;
		LOC10 = semtypenode_410269(c, (*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
		base = skiptypesornil_195195(LOC10, IL64(211106247215360));
		{
			if (!base == 0) goto LA13;
			localerror_166155((*n).info, ((NU16) 123), ((NimStringDesc*) &TMP3015));
		}
		goto LA11;
		LA13: ;
		{
			Ttype191849* concretebase;
			Ttype191849* LOC16;
			LOC16 = 0;
			LOC16 = skipgenericinvocation_419764(base);
			concretebase = skiptypes_195167(LOC16, IL64(211106247215360));
			{
				NIM_BOOL LOC19;
				LOC19 = 0;
				LOC19 = ((*concretebase).kind == ((NU8) 17));
				if (!(LOC19)) goto LA20;
				LOC19 = !((((*concretebase).flags &(1<<((((NU8) 2))&31)))!=0));
				LA20: ;
				if (!LOC19) goto LA21;
				addinheritedfields_419798(c, (&check), (&pos), concretebase);
			}
			goto LA17;
			LA21: ;
			{
				{
					if (!!(((*concretebase).kind == ((NU8) 50)))) goto LA26;
					localerror_166155((*(*n).kindU.S6.sons->data[((NI) 1)]).info, ((NU16) 121), ((NimStringDesc*) &TMP2991));
				}
				LA26: ;
				base = NIM_NIL;
			}
			LA17: ;
		}
		LA11: ;
	}
	LA8: ;
	{
		if (!!(((*n).kind == ((NU8) 133)))) goto LA30;
		internalerror_166199((*n).info, ((NimStringDesc*) &TMP3019));
	}
	LA30: ;
	result = neworprevtype_416695(((NU8) 17), prev, c);
	rawaddson_195478(result, base);
	asgnRefNoCycle((void**) (&(*result).n), newnodei_193351(((NU8) 138), (*n).info));
	semrecordnodeaux_419088(c, (*n).kindU.S6.sons->data[((NI) 2)], (&check), (&pos), (*result).n, result);
	{
		Tsym191843* s;
		Tident168021* LOC36;
		Tnode191813* LOC37;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA34;
		LOC36 = 0;
		LOC36 = getident_168463(((NimStringDesc*) &TMP3382));
		LOC37 = 0;
		LOC37 = newidentnode_193313(LOC36, (*n).info);
		s = newsyms_410904(((NU8) 7), LOC37, c);
		asgnRefNoCycle((void**) (&(*s).typ), result);
		pragma_261069(c, s, (*n).kindU.S6.sons->data[((NI) 0)], TMP3383);
	}
	LA34: ;
	{
		NIM_BOOL LOC40;
		LOC40 = 0;
		LOC40 = (base == NIM_NIL);
		if (!(LOC40)) goto LA41;
		LOC40 = !((((*result).flags &(1<<((((NU8) 3))&31)))!=0));
		LA41: ;
		if (!LOC40) goto LA42;
		(*result).flags |= ((NI32)1)<<((((NU8) 2))%(sizeof(NI32)*8));
	}
	LA42: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, semtuple_418454)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	Ttype191849* typ;
	Intset188056 check;
	NI counter;
	result = 0;
	typ = 0;
	result = neworprevtype_416695(((NU8) 18), prev, c);
	asgnRefNoCycle((void**) (&(*result).n), newnodei_193351(((NU8) 138), (*n).info));
	memset((void*)(&check), 0, sizeof(check));
	chckNil((void*)(&check));
	memset((void*)(&check), 0, sizeof(check));
	initintset_188927((&check));
	counter = ((NI) 0);
	{
		NI i_418475;
		NI HEX3Atmp_418611;
		NI LOC2;
		NI res_418614;
		i_418475 = 0;
		HEX3Atmp_418611 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_418611 = (NI)(LOC2 - ((NI) 1));
		res_418614 = ((NI) 0);
		{
			while (1) {
				Tnode191813* a;
				NI length;
				if (!(res_418614 <= HEX3Atmp_418611)) goto LA4;
				i_418475 = res_418614;
				a = (*n).kindU.S6.sons->data[i_418475];
				{
					if (!!(((*a).kind == ((NU8) 35)))) goto LA7;
					illformedast_246229(a);
				}
				LA7: ;
				checkminsonslen_246259(a, ((NI) 3));
				length = sonslen_194403(a);
				{
					if (!!(((*(*a).kindU.S6.sons->data[(NI)(length - ((NI) 2))]).kind == ((NU8) 1)))) goto LA11;
					typ = semtypenode_410269(c, (*a).kindU.S6.sons->data[(NI)(length - ((NI) 2))], NIM_NIL);
				}
				goto LA9;
				LA11: ;
				{
					localerror_166155((*a).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
					typ = errortype_246150(c);
				}
				LA9: ;
				{
					if (!!(((*(*a).kindU.S6.sons->data[(NI)(length - ((NI) 1))]).kind == ((NU8) 1)))) goto LA16;
					localerror_166155((*(*a).kindU.S6.sons->data[(NI)(length - ((NI) 1))]).info, ((NU16) 175), ((NimStringDesc*) &TMP2991));
				}
				LA16: ;
				{
					NI j_418522;
					NI HEX3Atmp_418604;
					NI res_418607;
					j_418522 = 0;
					HEX3Atmp_418604 = 0;
					HEX3Atmp_418604 = (NI)(length - ((NI) 3));
					res_418607 = ((NI) 0);
					{
						while (1) {
							Tsym191843* field;
							if (!(res_418607 <= HEX3Atmp_418604)) goto LA20;
							j_418522 = res_418607;
							field = newsymg_410916(((NU8) 19), (*a).kindU.S6.sons->data[j_418522], c);
							asgnRefNoCycle((void**) (&(*field).typ), typ);
							(*field).position = counter;
							counter += ((NI) 1);
							{
								NIM_BOOL LOC23;
								LOC23 = 0;
								LOC23 = containsorincl_188898((&check), (*(*field).name).Sup.id);
								if (!LOC23) goto LA24;
								localerror_166155((*(*a).kindU.S6.sons->data[j_418522]).info, ((NU16) 40), (*(*field).name).s);
							}
							goto LA21;
							LA24: ;
							{
								Tnode191813* LOC27;
								LOC27 = 0;
								LOC27 = newsymnode_193325(field);
								addson_193819((*result).n, LOC27);
								addsonskipintlit_239731(result, typ);
							}
							LA21: ;
							{
								if (!(gcmd_155130 == ((NU8) 7))) goto LA30;
							}
							LA30: ;
							res_418607 += ((NI) 1);
						} LA20: ;
					}
				}
				res_418614 += ((NI) 1);
			} LA4: ;
		}
	}
	return result;
}

N_NIMCALL(Ttype191849*, semtypeclass_422208)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	Tnode191813* pragmas;
	Tnode191813* inherited;
	result = 0;
	{
		if (!(((*n).flags &(1<<((((NU8) 1))&15)))!=0)) goto LA3;
		message_166188((*n).info, ((NU16) 234), ((NimStringDesc*) &TMP3384));
	}
	LA3: ;
	result = neworprevtype_416695(((NU8) 52), prev, c);
	asgnRefNoCycle((void**) (&(*result).n), n);
	pragmas = HEX5BHEX5D_192244(n, ((NI) 1));
	inherited = HEX5BHEX5D_192244(n, ((NI) 2));
	{
		if (!!(((*inherited).kind == ((NU8) 1)))) goto LA7;
		{
			Tnode191813* n_422245;
			Tnodeseq191807* HEX3Atmp_422259;
			NI i_422262;
			NI L_422264;
			n_422245 = 0;
			HEX3Atmp_422259 = 0;
			HEX3Atmp_422259 = (*inherited).kindU.S6.sons;
			i_422262 = ((NI) 0);
			L_422264 = (HEX3Atmp_422259 ? HEX3Atmp_422259->Sup.len : 0);
			{
				while (1) {
					Ttype191849* typ;
					if (!(i_422262 < L_422264)) goto LA11;
					n_422245 = HEX3Atmp_422259->data[i_422262];
					typ = semtypenode_410269(c, n_422245, NIM_NIL);
					safeadd_266489((&(*result).sons), typ);
					i_422262 += ((NI) 1);
				} LA11: ;
			}
		}
	}
	LA7: ;
	return result;
}

N_NIMCALL(Ttype191849*, semvartype_417260)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	{
		NI LOC3;
		Ttype191849* base;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 1))) goto LA4;
		result = neworprevtype_416695(((NU8) 23), prev, c);
		base = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
		{
			if (!((*base).kind == ((NU8) 23))) goto LA8;
			localerror_166155((*n).info, ((NU16) 197), ((NimStringDesc*) &TMP2991));
			base = (*base).sons->data[((NI) 0)];
		}
		LA8: ;
		addsonskipintlit_239731(result, base);
	}
	goto LA1;
	LA4: ;
	{
		result = newconstraint_416725(c, ((NU8) 23));
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, semdistinct_417280)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	Ttype191849* LOC6;
{	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = len_192097(n);
		if (!(LOC3 == ((NI) 0))) goto LA4;
		result = newconstraint_416725(c, ((NU8) 13));
		goto BeforeRet;
	}
	LA4: ;
	result = neworprevtype_416695(((NU8) 13), prev, c);
	LOC6 = 0;
	LOC6 = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
	addsonskipintlit_239731(result, LOC6);
	{
		NI LOC9;
		LOC9 = 0;
		LOC9 = len_192097(n);
		if (!(((NI) 1) < LOC9)) goto LA10;
		asgnRefNoCycle((void**) (&(*result).n), HEX5BHEX5D_192244(n, ((NI) 1)));
	}
	LA10: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, semproctypewithscope_422277)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev, NU8 kind) {
	Ttype191849* result;
	Tscope191837* LOC1;
	Tsym191843* s;
	Tident168021* LOC2;
	Tnode191813* LOC3;
	result = 0;
	checksonslen_246249(n, ((NI) 2));
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	result = semproctypenode_421351(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL, prev, kind, NIM_TRUE);
	LOC2 = 0;
	LOC2 = getident_168463(((NimStringDesc*) &TMP3382));
	LOC3 = 0;
	LOC3 = newidentnode_193313(LOC2, (*n).info);
	s = newsyms_410904(kind, LOC3, c);
	asgnRefNoCycle((void**) (&(*s).typ), result);
	{
		NIM_BOOL LOC6;
		NI LOC8;
		LOC6 = 0;
		LOC6 = ((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1));
		if (LOC6) goto LA7;
		LOC8 = 0;
		LOC8 = len_192097((*n).kindU.S6.sons->data[((NI) 1)]);
		LOC6 = (LOC8 == ((NI) 0));
		LA7: ;
		if (!LOC6) goto LA9;
		{
			if (!((*result).callconv == ((NU8) 0))) goto LA13;
			(*result).callconv = ((NU8) 8);
		}
		LA13: ;
	}
	goto LA4;
	LA9: ;
	{
		pragma_261069(c, s, (*n).kindU.S6.sons->data[((NI) 1)], TMP3385);
		seteffectsforproctype_330412(result, (*n).kindU.S6.sons->data[((NI) 1)]);
	}
	LA4: ;
	closescope_250111(c);
	return result;
}

N_NIMCALL(Ttype191849*, semenum_416733)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	NI64 counter;
	NI64 x;
	Tsym191843* e;
	Ttype191849* base;
	NIM_BOOL ispure;
	NIM_BOOL LOC15;
	NIM_BOOL hasnull;
{	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 0))) goto LA4;
		result = newconstraint_416725(c, ((NU8) 14));
		goto BeforeRet;
	}
	LA4: ;
	counter = 0;
	x = 0;
	e = 0;
	base = 0;
	counter = IL64(0);
	base = NIM_NIL;
	result = neworprevtype_416695(((NU8) 14), prev, c);
	asgnRefNoCycle((void**) (&(*result).n), newnodei_193351(((NU8) 150), (*n).info));
	checkminsonslen_246259(n, ((NI) 1));
	{
		NI64 LOC14;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA8;
		base = semtypenode_410269(c, (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
		{
			if (!!(((*base).kind == ((NU8) 14)))) goto LA12;
			localerror_166155((*(*n).kindU.S6.sons->data[((NI) 0)]).info, ((NU16) 122), ((NimStringDesc*) &TMP2991));
		}
		LA12: ;
		LOC14 = 0;
		LOC14 = lastord_221010(base);
		counter = (NI64)(LOC14 + IL64(1));
	}
	LA8: ;
	rawaddson_195478(result, base);
	LOC15 = 0;
	LOC15 = !(((*result).sym == NIM_NIL));
	if (!(LOC15)) goto LA16;
	LOC15 = (((*(*result).sym).flags &(1<<((((NU8) 9))&31)))!=0);
	LA16: ;
	ispure = LOC15;
	hasnull = NIM_FALSE;
	{
		NI i_416803;
		NI HEX3Atmp_417038;
		NI LOC18;
		NI res_417041;
		i_416803 = 0;
		HEX3Atmp_417038 = 0;
		LOC18 = 0;
		LOC18 = sonslen_194403(n);
		HEX3Atmp_417038 = (NI)(LOC18 - ((NI) 1));
		res_417041 = ((NI) 1);
		{
			while (1) {
				Tnode191813* LOC68;
				if (!(res_417041 <= HEX3Atmp_417038)) goto LA20;
				i_416803 = res_417041;
				switch ((*(*n).kindU.S6.sons->data[i_416803]).kind) {
				case ((NU8) 151):
				{
					Tnode191813* v;
					Tnode191813* strval;
					Ttype191849* LOC22;
					e = newsyms_410904(((NU8) 20), (*(*n).kindU.S6.sons->data[i_416803]).kindU.S6.sons->data[((NI) 0)], c);
					v = semconstexpr_411485(c, (*(*n).kindU.S6.sons->data[i_416803]).kindU.S6.sons->data[((NI) 1)]);
					strval = NIM_NIL;
					LOC22 = 0;
					LOC22 = skiptypes_195167((*v).typ, IL64(211106232576000));
					switch ((*LOC22).kind) {
					case ((NU8) 18):
					{
						{
							NI LOC26;
							LOC26 = 0;
							LOC26 = sonslen_194403(v);
							if (!(LOC26 == ((NI) 2))) goto LA27;
							strval = (*v).kindU.S6.sons->data[((NI) 1)];
							{
								Ttype191849* LOC31;
								LOC31 = 0;
								LOC31 = skiptypes_195167((*strval).typ, IL64(211106232576256));
								if (!((805306368 &(IL64(1)<<(((*LOC31).kind)&IL64(63))))!=0)) goto LA32;
								x = getordvalue_221178((*v).kindU.S6.sons->data[((NI) 0)]);
							}
							goto LA29;
							LA32: ;
							{
								localerror_166155((*strval).info, ((NU16) 6), ((NimStringDesc*) &TMP2991));
							}
							LA29: ;
						}
						goto LA24;
						LA27: ;
						{
							localerror_166155((*v).info, ((NU16) 111), ((NimStringDesc*) &TMP2991));
						}
						LA24: ;
					}
					break;
					case ((NU8) 28):
					case ((NU8) 29):
					{
						strval = v;
						x = counter;
					}
					break;
					default:
					{
						x = getordvalue_221178(v);
					}
					break;
					}
					{
						if (!!((i_416803 == ((NI) 1)))) goto LA40;
						{
							if (!!((x == counter))) goto LA44;
							(*result).flags |= ((NI32)1)<<((((NU8) 5))%(sizeof(NI32)*8));
						}
						LA44: ;
						{
							if (!(x < counter)) goto LA48;
							localerror_166155((*(*n).kindU.S6.sons->data[i_416803]).info, ((NU16) 145), (*(*e).name).s);
							x = counter;
						}
						LA48: ;
					}
					LA40: ;
					asgnRefNoCycle((void**) (&(*e).ast), strval);
					counter = x;
				}
				break;
				case ((NU8) 3):
				{
					e = (*(*n).kindU.S6.sons->data[i_416803]).kindU.S4.sym;
				}
				break;
				case ((NU8) 2):
				case ((NU8) 53):
				{
					e = newsyms_410904(((NU8) 20), (*n).kindU.S6.sons->data[i_416803], c);
				}
				break;
				default:
				{
					Tnode191813* LOC53;
					LOC53 = 0;
					LOC53 = HEX5BHEX5D_192244(n, i_416803);
					illformedast_246229(LOC53);
				}
				break;
				}
				asgnRefNoCycle((void**) (&(*e).typ), result);
				(*e).position = ((NI) (counter));
				{
					if (!((*e).position == ((NI) 0))) goto LA56;
					hasnull = NIM_TRUE;
				}
				LA56: ;
				{
					NIM_BOOL LOC60;
					LOC60 = 0;
					LOC60 = !(((*result).sym == NIM_NIL));
					if (!(LOC60)) goto LA61;
					LOC60 = (((*(*result).sym).flags &(1<<((((NU8) 1))&31)))!=0);
					LA61: ;
					if (!LOC60) goto LA62;
					(*e).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
					(*e).flags |= ((NI32)1)<<((((NU8) 1))%(sizeof(NI32)*8));
					{
						if (!!(ispure)) goto LA66;
						strtableadd_199103((&(*(*c).module).kindU.S3.tab), e);
					}
					LA66: ;
				}
				LA62: ;
				LOC68 = 0;
				LOC68 = newsymnode_193325(e);
				addson_193819((*result).n, LOC68);
				{
					NIM_BOOL LOC71;
					LOC71 = 0;
					LOC71 = !((((*e).flags &(1<<((((NU8) 31))&31)))!=0));
					if (!(LOC71)) goto LA72;
					LOC71 = !(ispure);
					LA72: ;
					if (!LOC71) goto LA73;
					adddecl_250607(c, e);
				}
				LA73: ;
				counter += ((NI) 1);
				res_417041 += ((NI) 1);
			} LA20: ;
		}
	}
	{
		if (!!(hasnull)) goto LA77;
		(*result).flags |= ((NI32)1)<<((((NU8) 17))%(sizeof(NI32)*8));
	}
	LA77: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, semstmtlisttype_421829)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	NI length;
	result = 0;
	checkminsonslen_246259(n, ((NI) 1));
	length = sonslen_194403(n);
	{
		NI i_421848;
		NI HEX3Atmp_421854;
		NI res_421857;
		i_421848 = 0;
		HEX3Atmp_421854 = 0;
		HEX3Atmp_421854 = (NI)(length - ((NI) 2));
		res_421857 = ((NI) 0);
		{
			while (1) {
				if (!(res_421857 <= HEX3Atmp_421854)) goto LA3;
				i_421848 = res_421857;
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_421848]), semstmt_410277(c, (*n).kindU.S6.sons->data[i_421848]));
				res_421857 += ((NI) 1);
			} LA3: ;
		}
	}
	{
		if (!(((NI) 0) < length)) goto LA6;
		result = semtypenode_410269(c, (*n).kindU.S6.sons->data[(NI)(length - ((NI) 1))], prev);
		asgnRefNoCycle((void**) (&(*n).typ), result);
		asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[(NI)(length - ((NI) 1))]).typ), result);
	}
	goto LA4;
	LA6: ;
	{
		result = NIM_NIL;
	}
	LA4: ;
	return result;
}

N_NIMCALL(Ttype191849*, semblocktype_421873)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	Tscope191837* LOC1;
	result = 0;
	(*(*c).p).nestedblockcounter += ((NI) 1);
	checksonslen_246249(n, ((NI) 2));
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	{
		Tsym191843* LOC6;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1) || (*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA4;
		LOC6 = 0;
		LOC6 = newsyms_410904(((NU8) 22), (*n).kindU.S6.sons->data[((NI) 0)], c);
		adddecl_250607(c, LOC6);
	}
	LA4: ;
	result = semstmtlisttype_421829(c, (*n).kindU.S6.sons->data[((NI) 1)], prev);
	asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[((NI) 1)]).typ), result);
	asgnRefNoCycle((void**) (&(*n).typ), result);
	closescope_250111(c);
	(*(*c).p).nestedblockcounter -= ((NI) 1);
	return result;
}

N_NIMCALL(Ttype191849*, semtypenode_410269)(Tcontext245023* c, Tnode191813* n, Ttype191849* prev) {
	Ttype191849* result;
	result = 0;
	result = NIM_NIL;
	{
		if (!(gcmd_155130 == ((NU8) 14))) goto LA3;
		suggestexpr_355070(c, n);
	}
	LA3: ;
	switch ((*n).kind) {
	case ((NU8) 1):
	{
	}
	break;
	case ((NU8) 132):
	{
		Tnode191813* typexpr;
		checksonslen_246249(n, ((NI) 1));
		typexpr = semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 0)], 4);
		result = skiptypes_195167((*typexpr).typ, IL64(562949953421312));
	}
	break;
	case ((NU8) 37):
	{
		{
			NI LOC10;
			LOC10 = 0;
			LOC10 = sonslen_194403(n);
			if (!(LOC10 == ((NI) 1))) goto LA11;
			result = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], prev);
		}
		goto LA8;
		LA11: ;
		{
			result = semanontuple_418414(c, n, prev);
		}
		LA8: ;
	}
	break;
	case ((NU8) 27):
	case ((NU8) 29):
	case ((NU8) 30):
	case ((NU8) 31):
	case ((NU8) 26):
	case ((NU8) 28):
	case ((NU8) 32):
	{
		{
			NIM_BOOL LOC17;
			LOC17 = 0;
			LOC17 = isrange_220612(n);
			if (!LOC17) goto LA18;
			result = semrangeaux_417292(c, n, prev);
		}
		goto LA15;
		LA18: ;
		{
			Tnode191813* LOC21;
			LOC21 = 0;
			LOC21 = HEX5BHEX5D_192244(n, ((NI) 0));
			if (!!(((*LOC21).kind == ((NU8) 2) || (*LOC21).kind == ((NU8) 3) || (*LOC21).kind == ((NU8) 53) || (*LOC21).kind == ((NU8) 57) || (*LOC21).kind == ((NU8) 56)))) goto LA22;
			result = semtypeexpr_422172(c, n);
		}
		goto LA15;
		LA22: ;
		{
			Tident168021* op;
			op = considerquotedident_250010((*n).kindU.S6.sons->data[((NI) 0)]);
			{
				NIM_BOOL LOC27;
				Ttype191849* t1;
				Ttype191849* t2;
				LOC27 = 0;
				LOC27 = ((*op).Sup.id == ((NI) 2) || (*op).Sup.id == ((NI) 49));
				if (LOC27) goto LA28;
				LOC27 = eqStrings((*op).s, ((NimStringDesc*) &TMP2993));
				LA28: ;
				if (!LOC27) goto LA29;
				checksonslen_246249(n, ((NI) 3));
				t1 = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 1)], NIM_NIL);
				t2 = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 2)], NIM_NIL);
				{
					if (!(t1 == NIM_NIL)) goto LA33;
					localerror_166155((*(*n).kindU.S6.sons->data[((NI) 1)]).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
					result = neworprevtype_416695(((NU8) 50), prev, c);
				}
				goto LA31;
				LA33: ;
				{
					if (!(t2 == NIM_NIL)) goto LA36;
					localerror_166155((*(*n).kindU.S6.sons->data[((NI) 2)]).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
					result = neworprevtype_416695(((NU8) 50), prev, c);
				}
				goto LA31;
				LA36: ;
				{
					{
						if (!((*op).Sup.id == ((NI) 2))) goto LA41;
						result = makeandtype_245858(c, t1, t2);
					}
					goto LA39;
					LA41: ;
					{
						result = makeortype_245930(c, t1, t2);
					}
					LA39: ;
				}
				LA31: ;
			}
			goto LA25;
			LA29: ;
			{
				NI LOC47;
				if (!((*op).Sup.id == ((NI) 45))) goto LA45;
				LOC47 = 0;
				LOC47 = len_192097(n);
				switch (LOC47) {
				case ((NI) 3):
				{
					result = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 1)], prev);
					{
						NIM_BOOL LOC51;
						Ttype191849* LOC52;
						LOC51 = 0;
						LOC52 = 0;
						LOC52 = skiptypes_195167(result, 2048);
						LOC51 = ((IL64(1125900835886592) &(IL64(1)<<(((*LOC52).kind)&IL64(63))))!=0);
						if (!(LOC51)) goto LA53;
						LOC51 = ((*(*n).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 23));
						LA53: ;
						if (!LOC51) goto LA54;
						result = freshtype_422192(result, prev);
						(*result).flags |= ((NI32)1)<<((((NU8) 16))%(sizeof(NI32)*8));
					}
					goto LA49;
					LA54: ;
					{
						localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP2994));
					}
					LA49: ;
				}
				break;
				case ((NI) 2):
				{
					Ttype191849* negated;
					negated = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 1)], prev);
					result = makenottype_246002(c, negated);
				}
				break;
				default:
				{
					localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP2994));
				}
				break;
				}
			}
			goto LA25;
			LA45: ;
			{
				if (!((*op).Sup.id == ((NI) 52))) goto LA60;
				result = semanyref_417112(c, n, ((NU8) 21), prev);
			}
			goto LA25;
			LA60: ;
			{
				if (!((*op).Sup.id == ((NI) 54))) goto LA63;
				result = semanyref_417112(c, n, ((NU8) 22), prev);
			}
			goto LA25;
			LA63: ;
			{
				Tnode191813* typexpr;
				if (!((*op).Sup.id == ((NI) 62))) goto LA66;
				checksonslen_246249(n, ((NI) 2));
				typexpr = semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 1)], 4);
				result = skiptypes_195167((*typexpr).typ, IL64(562949953421312));
			}
			goto LA25;
			LA66: ;
			{
				result = semtypeexpr_422172(c, n);
			}
			LA25: ;
		}
		LA15: ;
	}
	break;
	case ((NU8) 93):
	{
		Tnode191813* whenresult;
		whenresult = semwhen_411040(c, n, NIM_FALSE);
		{
			if (!((*whenresult).kind == ((NU8) 115))) goto LA72;
			(*whenresult).kind = ((NU8) 128);
		}
		LA72: ;
		result = semtypenode_410269(c, whenresult, prev);
	}
	break;
	case ((NU8) 42):
	{
		Tsym191843* s;
		checkminsonslen_246259(n, ((NI) 2));
		s = semtypeident_417777(c, (*n).kindU.S6.sons->data[((NI) 0)]);
		switch ((*s).magic) {
		case ((NU16) 176):
		{
			result = semarray_417720(c, n, prev);
		}
		break;
		case ((NU16) 177):
		{
			result = semcontainer_417086(c, n, ((NU8) 27), ((NimStringDesc*) &TMP2997), prev);
		}
		break;
		case ((NU16) 178):
		{
			result = semrange_417501(c, n, prev);
		}
		break;
		case ((NU16) 179):
		{
			result = semset_417057(c, n, prev);
		}
		break;
		case ((NU16) 182):
		{
			result = semordinal_417756(c, n, prev);
		}
		break;
		case ((NU16) 180):
		{
			result = semcontainer_417086(c, n, ((NU8) 24), ((NimStringDesc*) &TMP3001), prev);
		}
		break;
		case ((NU16) 181):
		{
			result = semvarargs_417099(c, n, prev);
		}
		break;
		case ((NU16) 207):
		{
			Tnode191813* LOC83;
			Ttype191849* LOC84;
			LOC83 = 0;
			LOC83 = HEX5BHEX5D_192244(n, ((NI) 1));
			LOC84 = 0;
			LOC84 = semtypenode_410269(c, LOC83, NIM_NIL);
			result = maketypedesc_245681(c, LOC84);
		}
		break;
		case ((NU16) 205):
		{
			result = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
			{
				Tsym191843* LOC90;
				if (!!((result == NIM_NIL))) goto LA88;
				LOC90 = 0;
				LOC90 = getcurrowner_245255();
				result = copytype_194549(result, LOC90, NIM_FALSE);
				{
					NI i_422626;
					NI HEX3Atmp_422858;
					NI LOC92;
					NI res_422861;
					i_422626 = 0;
					HEX3Atmp_422858 = 0;
					LOC92 = 0;
					LOC92 = len_192097(n);
					HEX3Atmp_422858 = (NI)(LOC92 - ((NI) 1));
					res_422861 = ((NI) 1);
					{
						while (1) {
							Ttype191849* LOC95;
							if (!(res_422861 <= HEX3Atmp_422858)) goto LA94;
							i_422626 = res_422861;
							LOC95 = 0;
							LOC95 = semtypenode_410269(c, (*n).kindU.S6.sons->data[i_422626], NIM_NIL);
							rawaddson_195478(result, LOC95);
							res_422861 += ((NI) 1);
						} LA94: ;
					}
				}
			}
			LA88: ;
		}
		break;
		default:
		{
			result = semgeneric_421923(c, n, s, prev);
		}
		break;
		}
	}
	break;
	case ((NU8) 45):
	{
		Tnode191813* typeexpr;
		typeexpr = semexpr_410201(c, n, 0);
		{
			if (!!(((*(*typeexpr).typ).kind == ((NU8) 8)))) goto LA100;
			localerror_166155((*n).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
			result = errortype_246150(c);
		}
		goto LA98;
		LA100: ;
		{
			result = base_221039((*typeexpr).typ);
			{
				NIM_BOOL LOC105;
				Tnode191813* preprocessed;
				Tnode191813* LOC108;
				LOC105 = 0;
				LOC105 = ismetatype_192821(result);
				if (!LOC105) goto LA106;
				preprocessed = semgenericstmt_416688(c, n);
				LOC108 = 0;
				LOC108 = copytree_196028(preprocessed);
				result = maketypefromexpr_245726(c, LOC108);
			}
			LA106: ;
		}
		LA98: ;
	}
	break;
	case ((NU8) 2):
	case ((NU8) 53):
	{
		Tsym191843* s;
		s = semtypeident_417777(c, n);
		{
			if (!((*s).typ == NIM_NIL)) goto LA112;
			{
				if (!!(((*s).kind == ((NU8) 0)))) goto LA116;
				localerror_166155((*n).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
			}
			LA116: ;
			result = neworprevtype_416695(((NU8) 50), prev, c);
		}
		goto LA110;
		LA112: ;
		{
			NIM_BOOL LOC119;
			LOC119 = 0;
			LOC119 = ((*s).kind == ((NU8) 3));
			if (!(LOC119)) goto LA120;
			LOC119 = ((*(*s).typ).kind == ((NU8) 8));
			LA120: ;
			if (!LOC119) goto LA121;
			{
				NIM_BOOL LOC125;
				Ttype191849* LOC126;
				NimStringDesc* LOC130;
				LOC125 = 0;
				LOC126 = 0;
				LOC126 = base_221039((*s).typ);
				LOC125 = !(((*LOC126).kind == ((NU8) 0)));
				if (!(LOC125)) goto LA127;
				LOC125 = (prev == NIM_NIL);
				LA127: ;
				if (!!(LOC125)) goto LA128;
				LOC130 = 0;
				LOC130 = HEX24_166306(TMP3014);
				internalerror_166218(LOC130);
			}
			LA128: ;
			result = base_221039((*s).typ);
		}
		goto LA110;
		LA121: ;
		{
			if (!(prev == NIM_NIL)) goto LA132;
			result = (*s).typ;
		}
		goto LA110;
		LA132: ;
		{
			assigntype_194452(prev, (*s).typ);
			{
				if (!!(((IL64(35182224605190) &(IL64(1)<<(((*(*s).typ).kind)&IL64(63))))!=0))) goto LA137;
				(*prev).Sup.id = (*(*s).typ).Sup.id;
			}
			LA137: ;
			result = prev;
		}
		LA110: ;
	}
	break;
	case ((NU8) 3):
	{
		{
			NIM_BOOL LOC142;
			Ttype191849* t;
			LOC142 = 0;
			LOC142 = ((*(*n).kindU.S4.sym).kind == ((NU8) 7));
			if (!(LOC142)) goto LA143;
			LOC142 = !(((*(*n).kindU.S4.sym).typ == NIM_NIL));
			LA143: ;
			if (!LOC142) goto LA144;
			t = (*(*n).kindU.S4.sym).typ;
			{
				if (!(prev == NIM_NIL)) goto LA148;
				result = t;
			}
			goto LA146;
			LA148: ;
			{
				assigntype_194452(prev, t);
				result = prev;
			}
			LA146: ;
			markused_345251((*n).info, (*n).kindU.S4.sym);
		}
		goto LA140;
		LA144: ;
		{
			{
				if (!!(((*(*n).kindU.S4.sym).kind == ((NU8) 0)))) goto LA154;
				localerror_166155((*n).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
			}
			LA154: ;
			result = neworprevtype_416695(((NU8) 50), prev, c);
		}
		LA140: ;
	}
	break;
	case ((NU8) 133):
	{
		result = semobjectnode_420016(c, n, prev);
	}
	break;
	case ((NU8) 134):
	{
		result = semtuple_418454(c, n, prev);
	}
	break;
	case ((NU8) 135):
	{
		result = newconstraint_416725(c, ((NU8) 18));
	}
	break;
	case ((NU8) 136):
	{
		result = semtypeclass_422208(c, n, prev);
	}
	break;
	case ((NU8) 141):
	{
		result = semanyref_417112(c, n, ((NU8) 22), prev);
	}
	break;
	case ((NU8) 142):
	{
		result = semanyref_417112(c, n, ((NU8) 21), prev);
	}
	break;
	case ((NU8) 143):
	{
		result = semvartype_417260(c, n, prev);
	}
	break;
	case ((NU8) 146):
	{
		result = semdistinct_417280(c, n, prev);
	}
	break;
	case ((NU8) 137):
	{
		Ttype191849* base;
		result = neworprevtype_416695(((NU8) 59), prev, c);
		base = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
		rawaddson_195478(result, base);
		(*result).flags |= ((NI32)1)<<((((NU8) 22))%(sizeof(NI32)*8));
	}
	break;
	case ((NU8) 148):
	{
		{
			NI LOC168;
			LOC168 = 0;
			LOC168 = sonslen_194403(n);
			if (!(LOC168 == ((NI) 0))) goto LA169;
			result = newconstraint_416725(c, ((NU8) 49));
		}
		goto LA166;
		LA169: ;
		{
			result = semproctypewithscope_422277(c, n, prev, ((NU8) 15));
			{
				NIM_BOOL LOC174;
				Tnode191813* LOC175;
				Tnode191813* LOC177;
				LOC174 = 0;
				LOC175 = 0;
				LOC175 = lastson_194431(n);
				LOC174 = ((*LOC175).kind == ((NU8) 90));
				if (!(LOC174)) goto LA176;
				LOC177 = 0;
				LOC177 = lastson_194431(n);
				LOC174 = haspragma_264698(LOC177, ((NU16) 134));
				LA176: ;
				if (!LOC174) goto LA178;
				(*result).kind = ((NU8) 49);
				(*result).callconv = ((NU8) 5);
			}
			goto LA172;
			LA178: ;
			{
				(*result).flags |= ((NI32)1)<<((((NU8) 14))%(sizeof(NI32)*8));
				(*result).callconv = ((NU8) 8);
			}
			LA172: ;
		}
		LA166: ;
	}
	break;
	case ((NU8) 147):
	{
		{
			NI LOC184;
			LOC184 = 0;
			LOC184 = sonslen_194403(n);
			if (!(LOC184 == ((NI) 0))) goto LA185;
			result = newconstraint_416725(c, ((NU8) 25));
		}
		goto LA182;
		LA185: ;
		{
			result = semproctypewithscope_422277(c, n, prev, ((NU8) 12));
		}
		LA182: ;
	}
	break;
	case ((NU8) 150):
	{
		result = semenum_416733(c, n, prev);
	}
	break;
	case ((NU8) 4):
	{
		result = (*n).typ;
	}
	break;
	case ((NU8) 128):
	{
		result = semstmtlisttype_421829(c, n, prev);
	}
	break;
	case ((NU8) 129):
	{
		result = semblocktype_421873(c, n, prev);
	}
	break;
	case ((NU8) 149):
	{
		checksonslen_246249(n, ((NI) 1));
		result = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], prev);
		result = freshtype_422192(result, prev);
		(*result).flags |= ((NI32)1)<<((((NU8) 15))%(sizeof(NI32)*8));
	}
	break;
	default:
	{
		localerror_166155((*n).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
		result = neworprevtype_416695(((NU8) 50), prev, c);
	}
	break;
	}
	asgnRefNoCycle((void**) (&(*n).typ), result);
	return result;
}

N_NIMCALL(Tnode191813*, semaftermacrocall_416431)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU16 flags) {
	Tnode191813* result;
	Tsym191843* LOC5;
	Tsym191843* LOC19;
	result = 0;
	evaltemplatecounter_384256 += ((NI) 1);
	{
		if (!(((NI) 100) < evaltemplatecounter_384256)) goto LA3;
		globalerror_166134((*s).info, ((NU16) 183), ((NimStringDesc*) &TMP2991));
	}
	LA3: ;
	LOC5 = 0;
	LOC5 = getmodule_199243((*s).owner);
	(*c).friendmodules = (Tsymseq191815*) incrSeq(&((*c).friendmodules)->Sup, sizeof(Tsym191843*));
	asgnRefNoCycle((void**) (&(*c).friendmodules->data[(*c).friendmodules->Sup.len-1]), LOC5);
	result = n;
	{
		if (!((*(*s).typ).sons->data[((NI) 0)] == NIM_NIL)) goto LA8;
		result = semstmt_410277(c, result);
	}
	goto LA6;
	LA8: ;
	{
		switch ((*(*(*s).typ).sons->data[((NI) 0)]).kind) {
		case ((NU8) 6):
		{
			result = semexpr_410201(c, result, flags);
		}
		break;
		case ((NU8) 7):
		{
			result = semstmt_410277(c, result);
		}
		break;
		case ((NU8) 8):
		{
			Ttype191849* typ;
			{
				if (!((*n).kind == ((NU8) 115))) goto LA16;
				(*result).kind = ((NU8) 128);
			}
			LA16: ;
			typ = semtypenode_410269(c, result, NIM_NIL);
			asgnRefNoCycle((void**) (&(*result).typ), maketypedesc_245681(c, typ));
		}
		break;
		default:
		{
			result = semexpr_410201(c, result, flags);
			result = fitnode_410245(c, (*(*s).typ).sons->data[((NI) 0)], result);
		}
		break;
		}
	}
	LA6: ;
	evaltemplatecounter_384256 -= ((NI) 1);
	LOC19 = 0;
	LOC19 = pop_368918((&(*c).friendmodules));
	return result;
}

N_NIMCALL(Tnode191813*, semmacroexpr_411066)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, Tsym191843* sym, NU16 flags) {
	Tnode191813* result;
	result = 0;
	pushinfocontext_165189((*norig).info);
	markused_345251((*n).info, sym);
	{
		if (!(sym == (*(*c).p).owner)) goto LA3;
		globalerror_166134((*n).info, ((NU16) 25), (*(*sym).name).s);
	}
	LA3: ;
	result = evalmacrocall_398902((*c).module, n, norig, sym);
	{
		if (!!(((flags &(1<<((((NU8) 9))&15)))!=0))) goto LA7;
		result = semaftermacrocall_416431(c, result, sym, flags);
	}
	LA7: ;
	popinfocontext_165208();
	return result;
}

N_NIMCALL(Tnode191813*, semsym_442038)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU16 flags) {
	Tnode191813* result;
{	result = 0;
	switch ((*s).kind) {
	case ((NU8) 10):
	{
		Ttype191849* LOC2;
		markused_345251((*n).info, s);
		LOC2 = 0;
		LOC2 = skiptypes_195167((*s).typ, IL64(211106232576000));
		switch ((*LOC2).kind) {
		case ((NU8) 5):
		case ((NU8) 2):
		case ((NU8) 31) ... ((NU8) 35):
		case ((NU8) 36) ... ((NU8) 39):
		case ((NU8) 18):
		case ((NU8) 19):
		case ((NU8) 40) ... ((NU8) 44):
		{
			{
				if (!((*s).magic == ((NU16) 0))) goto LA6;
				result = inlineconst_442028(n, s);
			}
			goto LA4;
			LA6: ;
			{
				result = newsymnode_193338(s, (*n).info);
			}
			LA4: ;
		}
		break;
		case ((NU8) 4):
		case ((NU8) 24):
		{
			{
				NI LOC12;
				LOC12 = 0;
				LOC12 = len_192097((*s).ast);
				if (!(LOC12 == ((NI) 0))) goto LA13;
				result = inlineconst_442028(n, s);
			}
			goto LA10;
			LA13: ;
			{
				result = newsymnode_193338(s, (*n).info);
			}
			LA10: ;
		}
		break;
		default:
		{
			result = newsymnode_193338(s, (*n).info);
		}
		break;
		}
	}
	break;
	case ((NU8) 17):
	{
		result = semmacroexpr_411066(c, n, n, s, flags);
	}
	break;
	case ((NU8) 18):
	{
		result = semtemplateexpr_411055(c, n, s, flags);
	}
	break;
	case ((NU8) 3):
	{
		markused_345251((*n).info, s);
		{
			NIM_BOOL LOC22;
			LOC22 = 0;
			LOC22 = ((*(*s).typ).kind == ((NU8) 59));
			if (!(LOC22)) goto LA23;
			LOC22 = !(((*(*s).typ).n == NIM_NIL));
			LA23: ;
			if (!LOC22) goto LA24;
			result = (*(*s).typ).n;
			goto BeforeRet;
		}
		goto LA20;
		LA24: ;
		{
			if (!(((*s).flags &(1<<((((NU8) 31))&31)))!=0)) goto LA27;
			{
				Tnode191813* realparam;
				Tnode191813* LOC40;
				if (!(*(*c).p).wasforwarded) goto LA31;
				realparam = HEX5BHEX5D_192244((*(*(*(*c).p).owner).typ).n, (NI)((*s).position + ((NI) 1)));
				{
					NIM_BOOL LOC35;
					NimStringDesc* LOC39;
					LOC35 = 0;
					LOC35 = ((*realparam).kind == ((NU8) 3));
					if (!(LOC35)) goto LA36;
					LOC35 = ((*(*realparam).kindU.S4.sym).kind == ((NU8) 3));
					LA36: ;
					if (!!(LOC35)) goto LA37;
					LOC39 = 0;
					LOC39 = HEX24_166306(TMP3388);
					internalerror_166218(LOC39);
				}
				LA37: ;
				LOC40 = 0;
				LOC40 = HEX5BHEX5D_192244((*(*(*(*c).p).owner).typ).n, (NI)((*s).position + ((NI) 1)));
				result = newsymnode_193338((*LOC40).kindU.S4.sym, (*n).info);
				goto BeforeRet;
			}
			goto LA29;
			LA31: ;
			{
				Tsym191843* u;
				if (!((*(*(*c).p).owner).kind == ((NU8) 17))) goto LA42;
				u = searchinscopes_250205(c, (*s).name);
				{
					NIM_BOOL LOC46;
					NIM_BOOL LOC47;
					NimStringDesc* LOC52;
					LOC46 = 0;
					LOC47 = 0;
					LOC47 = !((u == NIM_NIL));
					if (!(LOC47)) goto LA48;
					LOC47 = ((*u).kind == ((NU8) 3));
					LA48: ;
					LOC46 = LOC47;
					if (!(LOC46)) goto LA49;
					LOC46 = ((*u).owner == (*s).owner);
					LA49: ;
					if (!!(LOC46)) goto LA50;
					LOC52 = 0;
					LOC52 = HEX24_166306(TMP3389);
					internalerror_166218(LOC52);
				}
				LA50: ;
				result = newsymnode_193338(u, (*n).info);
				goto BeforeRet;
			}
			goto LA29;
			LA42: ;
			LA29: ;
		}
		goto LA20;
		LA27: ;
		LA20: ;
		result = newsymnode_193338(s, (*n).info);
	}
	break;
	case ((NU8) 8):
	case ((NU8) 9):
	case ((NU8) 11):
	case ((NU8) 21):
	{
		markused_345251((*n).info, s);
		{
			if (!(((*s).flags &(1<<((((NU8) 3))&31)))!=0)) goto LA56;
			(*(*(*c).p).owner).flags |= ((NI32)1)<<((((NU8) 11))%(sizeof(NI32)*8));
		}
		LA56: ;
		result = newsymnode_193338(s, (*n).info);
	}
	break;
	case ((NU8) 4):
	{
		{
			if (!((*(*s).typ).kind == ((NU8) 59))) goto LA61;
			result = newsymnode_193338(s, (*n).info);
			asgnRefNoCycle((void**) (&(*result).typ), (*s).typ);
		}
		goto LA59;
		LA61: ;
		{
			if (!!(((*s).ast == NIM_NIL))) goto LA64;
			result = semexpr_410201(c, (*s).ast, 0);
		}
		goto LA59;
		LA64: ;
		{
			asgnRefNoCycle((void**) (&(*n).typ), (*s).typ);
			result = n;
			goto BeforeRet;
		}
		LA59: ;
	}
	break;
	case ((NU8) 7):
	{
		markused_345251((*n).info, s);
		{
			NIM_BOOL LOC70;
			LOC70 = 0;
			LOC70 = ((*(*s).typ).kind == ((NU8) 59));
			if (!(LOC70)) goto LA71;
			LOC70 = !(((*(*s).typ).n == NIM_NIL));
			LA71: ;
			if (!LOC70) goto LA72;
			result = (*(*s).typ).n;
			goto BeforeRet;
		}
		LA72: ;
		result = newsymnode_193338(s, (*n).info);
		asgnRefNoCycle((void**) (&(*result).typ), maketypedesc_245681(c, (*s).typ));
	}
	break;
	default:
	{
		markused_345251((*n).info, s);
		result = newsymnode_193338(s, (*n).info);
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

static N_INLINE(void, markindirect_246197)(Tcontext245023* c, Tsym191843* s) {
	{
		if (!((126976 &(1<<(((*s).kind)&31)))!=0)) goto LA3;
		(*s).flags |= ((NI32)1)<<((((NU8) 15))%(sizeof(NI32)*8));
	}
	LA3: ;
}

N_NIMCALL(Tnode191813*, semfieldaccess_441814)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	result = 0;
	result = builtinfieldaccess_446958(c, n, flags);
	{
		if (!(result == NIM_NIL)) goto LA3;
		result = dottransformation_447679(c, n);
	}
	LA3: ;
	return result;
}

N_NIMCALL(void, maybelifttype_443488)(Ttype191849** t, Tcontext245023* c, Tlineinfo164338 info) {
	Tscope191837* LOC1;
	Ttype191849* lifted;
	Tnode191813* LOC2;
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	LOC2 = 0;
	LOC2 = newnodei_193351(((NU8) 152), info);
	lifted = liftparamtype_420279(c, ((NU8) 7), LOC2, (*t), ((NimStringDesc*) &TMP3392), info, NIM_FALSE);
	closescope_250111(c);
	{
		if (!!((lifted == NIM_NIL))) goto LA5;
		unsureAsgnRef((void**) (&(*t)), lifted);
	}
	LA5: ;
}

N_NIMCALL(Tnode191813*, inferwithmetatype_410463)(Tcontext245023* c, Ttype191849* formal, Tnode191813* arg, NIM_BOOL coercedistincts) {
	Tnode191813* result;
	Tcandidate345209 m;
	result = 0;
	memset((void*)(&m), 0, sizeof(m));
	initcandidate_345276(c, (&m), formal);
	m.coercedistincts = coercedistincts;
	result = paramtypesmatch_350556((&m), formal, (*arg).typ, arg, NIM_NIL);
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = m.genericconverter;
		if (!(LOC3)) goto LA4;
		LOC3 = !((result == NIM_NIL));
		LA4: ;
		if (!LOC3) goto LA5;
		instgenericconvertersarg_415176(c, result, (&m));
	}
	LA5: ;
	{
		Ttype191849* LOC11;
		if (!!((result == NIM_NIL))) goto LA9;
		LOC11 = 0;
		LOC11 = skiptypes_195167(formal, IL64(18014398509481984));
		asgnRefNoCycle((void**) (&(*result).typ), generatetypeinstance_268631(c, m.bindings, (*arg).info, LOC11));
	}
	goto LA7;
	LA9: ;
	{
		typemismatch_410379(arg, formal, (*arg).typ);
		result = copytree_196028(arg);
		asgnRefNoCycle((void**) (&(*result).typ), formal);
	}
	LA7: ;
	return result;
}

N_NIMCALL(NU8, checkconversionbetweenobjects_443209)(Ttype191849* castdest, Ttype191849* src) {
	NU8 result;
{	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = inheritancediff_228064(castdest, src);
		if (!(LOC3 == ((NI) IL64(9223372036854775807)))) goto LA4;
		result = ((NU8) 2);
	}
	goto LA1;
	LA4: ;
	{
		result = ((NU8) 0);
	}
	LA1: ;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NU8, checkconvertible_443223)(Tcontext245023* c, Ttype191849* castdest, Ttype191849* src) {
	NU8 result;
	Ttype191849* d;
	Ttype191849* s;
{	result = 0;
	result = ((NU8) 0);
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = sametype_226092(castdest, src, 0);
		if (!(LOC3)) goto LA4;
		LOC3 = ((*castdest).sym == (*src).sym);
		LA4: ;
		if (!LOC3) goto LA5;
		{
			if (!!(((IL64(35182225670150) &(IL64(1)<<(((*castdest).kind)&IL64(63))))!=0))) goto LA9;
			result = ((NU8) 1);
		}
		LA9: ;
		goto BeforeRet;
	}
	LA5: ;
	d = skiptypes_195167(castdest, IL64(211106240964864));
	s = skiptypes_195167(src, IL64(211106240964608));
	{
		while (1) {
			NIM_BOOL LOC13;
			NIM_BOOL LOC14;
			LOC13 = 0;
			LOC14 = 0;
			LOC14 = !((d == NIM_NIL));
			if (!(LOC14)) goto LA15;
			LOC14 = ((6291456 &(IL64(1)<<(((*d).kind)&IL64(63))))!=0);
			LA15: ;
			LOC13 = LOC14;
			if (!(LOC13)) goto LA16;
			LOC13 = ((*d).kind == (*s).kind);
			LA16: ;
			if (!LOC13) goto LA12;
			d = lastson_194442(d);
			s = lastson_194442(s);
		} LA12: ;
	}
	{
		if (!(d == NIM_NIL)) goto LA19;
		result = ((NU8) 2);
	}
	goto LA17;
	LA19: ;
	{
		NIM_BOOL LOC22;
		LOC22 = 0;
		LOC22 = ((*d).kind == ((NU8) 17));
		if (!(LOC22)) goto LA23;
		LOC22 = ((*s).kind == ((NU8) 17));
		LA23: ;
		if (!LOC22) goto LA24;
		result = checkconversionbetweenobjects_443209(d, s);
	}
	goto LA17;
	LA24: ;
	{
		NIM_BOOL LOC27;
		Ttype191849* LOC28;
		Ttype191849* LOC30;
		LOC27 = 0;
		LOC28 = 0;
		LOC28 = skiptypes_195167(castdest, IL64(211106242013440));
		LOC27 = ((IL64(35182224621574) &(IL64(1)<<(((*LOC28).kind)&IL64(63))))!=0);
		if (!(LOC27)) goto LA29;
		LOC30 = 0;
		LOC30 = skiptypes_195167(src, IL64(211106242013184));
		LOC27 = ((IL64(35182224621574) &(IL64(1)<<(((*LOC30).kind)&IL64(63))))!=0);
		LA29: ;
		if (!LOC27) goto LA31;
	}
	goto LA17;
	LA31: ;
	{
		NU8 LOC34;
		LOC34 = 0;
		LOC34 = cmptypes_349708(c, d, s);
		switch (LOC34) {
		case ((NU8) 0):
		case ((NU8) 7):
		{
			{
				NIM_BOOL LOC38;
				LOC38 = 0;
				LOC38 = comparetypes_228047(castdest, src, ((NU8) 1), 0);
				if (!!(LOC38)) goto LA39;
				result = ((NU8) 2);
			}
			LA39: ;
		}
		break;
		default:
		{
		}
		break;
		}
	}
	LA17: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semconv_443510)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Ttype191849* targettype;
	Ttype191849* LOC6;
	Tnode191813* LOC7;
	Tnode191813* LOC8;
	Tnode191813* op;
{	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!!((LOC3 == ((NI) 2)))) goto LA4;
		localerror_166155((*n).info, ((NU16) 161), ((NimStringDesc*) &TMP2991));
		result = n;
		goto BeforeRet;
	}
	LA4: ;
	result = newnodei_193351(((NU8) 60), (*n).info);
	LOC6 = 0;
	LOC6 = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
	targettype = skiptypes_195167(LOC6, 256);
	LOC7 = 0;
	LOC7 = HEX5BHEX5D_192244(n, ((NI) 0));
	maybelifttype_443488(&targettype, c, (*LOC7).info);
	LOC8 = 0;
	LOC8 = copytree_196028((*n).kindU.S6.sons->data[((NI) 0)]);
	addson_193819(result, LOC8);
	op = semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 1)], 0);
	{
		NIM_BOOL LOC11;
		Tnode191813* final;
		LOC11 = 0;
		LOC11 = ismetatype_192821(targettype);
		if (!LOC11) goto LA12;
		final = inferwithmetatype_410463(c, targettype, op, NIM_TRUE);
		addson_193819(result, final);
		asgnRefNoCycle((void**) (&(*result).typ), (*final).typ);
		goto BeforeRet;
	}
	LA12: ;
	asgnRefNoCycle((void**) (&(*result).typ), targettype);
	addson_193819(result, op);
	{
		NIM_BOOL LOC16;
		NU8 status;
		LOC16 = 0;
		LOC16 = issymchoice_443471(op);
		if (!!(LOC16)) goto LA17;
		status = checkconvertible_443223(c, (*result).typ, (*op).typ);
		switch (status) {
		case ((NU8) 0):
		{
			{
				NIM_BOOL LOC22;
				LOC22 = 0;
				LOC22 = ((*op).kind == ((NU8) 3));
				if (!(LOC22)) goto LA23;
				LOC22 = isgenericroutine_196652((*op).kindU.S4.sym);
				LA23: ;
				if (!LOC22) goto LA24;
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), fitnode_410245(c, (*result).typ, (*result).kindU.S6.sons->data[((NI) 1)]));
			}
			LA24: ;
		}
		break;
		case ((NU8) 1):
		{
			NimStringDesc* LOC27;
			LOC27 = 0;
			LOC27 = typetostring_221032((*result).typ, ((NU8) 0));
			message_166188((*n).info, ((NU16) 266), LOC27);
		}
		break;
		case ((NU8) 2):
		{
			NimStringDesc* LOC29;
			TY155965 LOC30;
			NimStringDesc* LOC31;
			LOC29 = 0;
			LOC29 = msgkindtostring_165616(((NU16) 142));
			memset((void*)LOC30, 0, sizeof(LOC30));
			LOC30[0] = typetostring_221032((*op).typ, ((NU8) 0));
			LOC30[1] = typetostring_221032((*result).typ, ((NU8) 0));
			LOC31 = 0;
			LOC31 = nsuFormatOpenArray(LOC29, LOC30, 2);
			localerror_166155((*n).info, ((NU16) 4), LOC31);
		}
		break;
		}
	}
	goto LA14;
	LA17: ;
	{
		{
			NI i_443553;
			NI HEX3Atmp_443606;
			NI LOC34;
			NI res_443609;
			i_443553 = 0;
			HEX3Atmp_443606 = 0;
			LOC34 = 0;
			LOC34 = sonslen_194403(op);
			HEX3Atmp_443606 = (NI)(LOC34 - ((NI) 1));
			res_443609 = ((NI) 0);
			{
				while (1) {
					Tnode191813* it;
					NU8 status;
					if (!(res_443609 <= HEX3Atmp_443606)) goto LA36;
					i_443553 = res_443609;
					it = (*op).kindU.S6.sons->data[i_443553];
					status = checkconvertible_443223(c, (*result).typ, (*it).typ);
					{
						if (!((3 &(1<<((status)&7)))!=0)) goto LA39;
						markused_345251((*n).info, (*it).kindU.S4.sym);
						markindirect_246197(c, (*it).kindU.S4.sym);
						result = it;
						goto BeforeRet;
					}
					LA39: ;
					res_443609 += ((NI) 1);
				} LA36: ;
			}
		}
		localerror_166155((*n).info, ((NU16) 62), (*(*(*(*op).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).name).s);
	}
	LA14: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, checkinitialized_450320)(Tnode191813* n, Intset188056* ids, Tlineinfo164338 info) {
	switch ((*n).kind) {
	case ((NU8) 138):
	{
		{
			NI i_450337;
			NI HEX3Atmp_450435;
			NI LOC3;
			NI res_450438;
			i_450337 = 0;
			HEX3Atmp_450435 = 0;
			LOC3 = 0;
			LOC3 = sonslen_194403(n);
			HEX3Atmp_450435 = (NI)(LOC3 - ((NI) 1));
			res_450438 = ((NI) 0);
			{
				while (1) {
					if (!(res_450438 <= HEX3Atmp_450435)) goto LA5;
					i_450337 = res_450438;
					checkinitialized_450320((*n).kindU.S6.sons->data[i_450337], ids, info);
					res_450438 += ((NI) 1);
				} LA5: ;
			}
		}
	}
	break;
	case ((NU8) 139):
	{
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA9;
			internalerror_166199(info, ((NimStringDesc*) &TMP3394));
		}
		LA9: ;
		checkinitialized_450320((*n).kindU.S6.sons->data[((NI) 0)], ids, info);
	}
	break;
	case ((NU8) 3):
	{
		{
			NIM_BOOL LOC14;
			NIM_BOOL LOC16;
			NimStringDesc* LOC19;
			LOC14 = 0;
			LOC14 = !(((196608 & (*(*(*n).kindU.S4.sym).typ).flags) == 0));
			if (!(LOC14)) goto LA15;
			LOC16 = 0;
			LOC16 = contains_188829(ids, (*(*(*n).kindU.S4.sym).name).Sup.id);
			LOC14 = !(LOC16);
			LA15: ;
			if (!LOC14) goto LA17;
			LOC19 = 0;
			LOC19 = rawNewString((*(*(*n).kindU.S4.sym).name).s->Sup.len + 23);
appendString(LOC19, ((NimStringDesc*) &TMP3395));
appendString(LOC19, (*(*(*n).kindU.S4.sym).name).s);
			message_166188(info, ((NU16) 4), LOC19);
		}
		LA17: ;
	}
	break;
	default:
	{
		internalerror_166199(info, ((NimStringDesc*) &TMP3394));
	}
	break;
	}
}

N_NIMCALL(Tnode191813*, semobjconstr_446041)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Ttype191849* t;
	Ttype191849* objtype;
	Intset188056 ids;
{	result = 0;
	t = semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL);
	result = n;
	asgnRefNoCycle((void**) (&(*result).typ), t);
	(*result).kind = ((NU8) 38);
	t = skiptypes_195167(t, 2048);
	{
		if (!((*t).kind == ((NU8) 22))) goto LA3;
		t = skiptypes_195167((*t).sons->data[((NI) 0)], 2048);
	}
	LA3: ;
	{
		if (!!(((*t).kind == ((NU8) 17)))) goto LA7;
		localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3393));
		goto BeforeRet;
	}
	LA7: ;
	objtype = t;
	memset((void*)(&ids), 0, sizeof(ids));
	chckNil((void*)(&ids));
	memset((void*)(&ids), 0, sizeof(ids));
	initintset_188927((&ids));
	{
		NI i_450503;
		NI HEX3Atmp_450618;
		NI LOC10;
		NI res_450621;
		i_450503 = 0;
		HEX3Atmp_450618 = 0;
		LOC10 = 0;
		LOC10 = len_192097(n);
		HEX3Atmp_450618 = (LOC10 - 1);
		res_450621 = ((NI) 1);
		{
			while (1) {
				Tnode191813* it;
				Tident168021* id;
				Tnode191813* e;
				Tnode191813* check;
				Tsym191843* f;
				if (!(res_450621 <= HEX3Atmp_450618)) goto LA12;
				i_450503 = res_450621;
				it = (*n).kindU.S6.sons->data[i_450503];
				{
					if (!!(((*it).kind == ((NU8) 34)))) goto LA15;
					localerror_166155((*n).info, ((NU16) 170), ((NimStringDesc*) &TMP2991));
					goto LA9;
				}
				LA15: ;
				id = considerquotedident_250010((*it).kindU.S6.sons->data[((NI) 0)]);
				{
					NIM_BOOL LOC19;
					LOC19 = 0;
					LOC19 = containsorincl_188898((&ids), (*id).Sup.id);
					if (!LOC19) goto LA20;
					localerror_166155((*it).info, ((NU16) 86), (*id).s);
				}
				LA20: ;
				e = semexprwithtype_410211(c, (*it).kindU.S6.sons->data[((NI) 1)], (flags & 64));
				check = NIM_NIL;
				f = 0;
				t = objtype;
				{
					while (1) {
						check = NIM_NIL;
						f = lookupinrecordandbuildcheck_446604(c, it, (*t).n, id, &check);
						{
							if (!!((f == NIM_NIL))) goto LA26;
							goto LA22;
						}
						LA26: ;
						{
							if (!((*t).sons->data[((NI) 0)] == NIM_NIL)) goto LA30;
							goto LA22;
						}
						LA30: ;
						t = skiptypes_195167((*t).sons->data[((NI) 0)], 2048);
					}
				} LA22: ;
				{
					NIM_BOOL LOC34;
					LOC34 = 0;
					LOC34 = !((f == NIM_NIL));
					if (!(LOC34)) goto LA35;
					LOC34 = fieldvisible_352059(c, f);
					LA35: ;
					if (!LOC34) goto LA36;
					asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(f));
					e = fitnode_410245(c, (*f).typ, e);
					{
						if (!!((check == NIM_NIL))) goto LA40;
						asgnRefNoCycle((void**) (&(*check).kindU.S6.sons->data[((NI) 0)]), (*it).kindU.S6.sons->data[((NI) 0)]);
						add_192164(it, check);
					}
					LA40: ;
				}
				goto LA32;
				LA36: ;
				{
					localerror_166155((*it).info, ((NU16) 80), (*id).s);
				}
				LA32: ;
				asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[((NI) 1)]), e);
				res_450621 += ((NI) 1);
			} LA12: ;
		}
	} LA9: ;
	{
		if (!(((*objtype).flags &(1<<((((NU8) 17))&31)))!=0)) goto LA45;
		{
			while (1) {
				checkinitialized_450320((*objtype).n, (&ids), (*n).info);
				{
					if (!((*objtype).sons->data[((NI) 0)] == NIM_NIL)) goto LA51;
					goto LA47;
				}
				LA51: ;
				objtype = skiptypes_195167((*objtype).sons->data[((NI) 0)], 2048);
			}
		} LA47: ;
	}
	LA45: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tsym191843*, lookupfordefined_448661)(Tcontext245023* c, Tident168021* i, NIM_BOOL onlycurrentscope) {
	Tsym191843* result;
	result = 0;
	{
		if (!onlycurrentscope) goto LA3;
		result = localsearchinscope_250194(c, i);
	}
	goto LA1;
	LA3: ;
	{
		result = searchinscopes_250205(c, i);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tsym191843*, lookupfordefined_448670)(Tcontext245023* c, Tnode191813* n, NIM_BOOL onlycurrentscope) {
	Tsym191843* result;
{	result = 0;
	switch ((*n).kind) {
	case ((NU8) 2):
	{
		result = lookupfordefined_448661(c, (*n).kindU.S5.ident, onlycurrentscope);
	}
	break;
	case ((NU8) 45):
	{
		Tsym191843* m;
		result = NIM_NIL;
		{
			if (!onlycurrentscope) goto LA5;
			goto BeforeRet;
		}
		LA5: ;
		checksonslen_246249(n, ((NI) 2));
		m = lookupfordefined_448670(c, (*n).kindU.S6.sons->data[((NI) 0)], onlycurrentscope);
		{
			NIM_BOOL LOC9;
			Tident168021* ident;
			Tnode191813* LOC13;
			LOC9 = 0;
			LOC9 = !((m == NIM_NIL));
			if (!(LOC9)) goto LA10;
			LOC9 = ((*m).kind == ((NU8) 6));
			LA10: ;
			if (!LOC9) goto LA11;
			LOC13 = 0;
			LOC13 = HEX5BHEX5D_192244(n, ((NI) 1));
			ident = considerquotedident_250010(LOC13);
			{
				if (!(m == (*c).module)) goto LA16;
				result = strtableget_199111((*(*c).toplevelscope).symbols, ident);
			}
			goto LA14;
			LA16: ;
			{
				result = strtableget_199111((*m).kindU.S3.tab, ident);
			}
			LA14: ;
		}
		LA11: ;
	}
	break;
	case ((NU8) 53):
	{
		Tident168021* LOC20;
		LOC20 = 0;
		LOC20 = considerquotedident_250010(n);
		result = lookupfordefined_448661(c, LOC20, onlycurrentscope);
	}
	break;
	case ((NU8) 3):
	{
		result = (*n).kindU.S4.sym;
	}
	break;
	case ((NU8) 57):
	case ((NU8) 56):
	{
		result = (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
	}
	break;
	default:
	{
		NimStringDesc* LOC24;
		LOC24 = 0;
		LOC24 = rendertree_213058(n, 0);
		localerror_166155((*n).info, ((NU16) 19), LOC24);
		result = NIM_NIL;
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semdefined_448719)(Tcontext245023* c, Tnode191813* n, NIM_BOOL onlycurrentscope) {
	Tnode191813* result;
	result = 0;
	checksonslen_246249(n, ((NI) 2));
	result = newintnode_192607(((NU8) 6), IL64(0));
	{
		NIM_BOOL LOC3;
		Tnode191813* LOC5;
		Tident168021* LOC6;
		LOC3 = 0;
		LOC3 = !(onlycurrentscope);
		if (!(LOC3)) goto LA4;
		LOC5 = 0;
		LOC5 = HEX5BHEX5D_192244(n, ((NI) 0));
		LOC6 = 0;
		LOC6 = considerquotedident_250010(LOC5);
		LOC3 = eqStrings((*LOC6).s, ((NimStringDesc*) &TMP3396));
		LA4: ;
		if (!LOC3) goto LA7;
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 2)))) goto LA11;
			localerror_166166((*n).info, ((NimStringDesc*) &TMP3397));
		}
		goto LA9;
		LA11: ;
		{
			NIM_BOOL LOC14;
			LOC14 = 0;
			LOC14 = isdefined_169167((*(*n).kindU.S6.sons->data[((NI) 1)]).kindU.S5.ident);
			if (!LOC14) goto LA15;
			(*result).kindU.S1.intval = IL64(1);
		}
		goto LA9;
		LA15: ;
		LA9: ;
	}
	goto LA1;
	LA7: ;
	{
		Tsym191843* LOC18;
		LOC18 = 0;
		LOC18 = lookupfordefined_448670(c, (*n).kindU.S6.sons->data[((NI) 1)], onlycurrentscope);
		if (!!((LOC18 == NIM_NIL))) goto LA19;
		(*result).kindU.S1.intval = IL64(1);
	}
	goto LA1;
	LA19: ;
	LA1: ;
	(*result).info = (*n).info;
	asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 1)));
	return result;
}

N_NIMCALL(Tnode191813*, setms_449568)(Tnode191813* n, Tsym191843* s) {
	Tnode191813* result;
	result = 0;
	result = n;
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(s));
	(*(*n).kindU.S6.sons->data[((NI) 0)]).info = (*n).info;
	return result;
}

static N_INLINE(void, pushSafePoint)(TSafePoint* s) {
	(*s).hasRaiseAction = NIM_FALSE;
	(*s).prev = exchandler_17043;
	exchandler_17043 = s;
}

static N_INLINE(void, popSafePoint)(void) {
	exchandler_17043 = (*exchandler_17043).prev;
}

static N_INLINE(Exception*, getCurrentException)(void) {
	Exception* result;
	result = 0;
	result = currexception_17045;
	return result;
}

static N_INLINE(void, popCurrentException)(void) {
	asgnRef((void**) (&currexception_17045), (*currexception_17045).parent);
}

N_NIMCALL(Tnode191813*, tryexpr_410317)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* volatile result;
	NI olderrorcount;
	NI olderrormax;
	Tscope191837* oldscope;
	Tscope191837* LOC1;
	NI oldownerlen;
	TY245141* oldgenerics;
	NU8 olderroroutputs;
	NI oldcontextlen;
	NI oldingenericcontext;
	NI oldinunrolledcontext;
	NI oldingenericinst;
	Tproccon245011* oldproccon;
	TSafePoint TMP3398;
	result = 0;
	olderrorcount = gerrorcounter_165012;
	olderrormax = gerrormax_165015;
	(*c).incompilescontext += ((NI) 1);
	gerrormax_165015 = ((NI) IL64(9223372036854775807));
	oldscope = (*c).currentscope;
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	oldownerlen = (gowners_245288 ? gowners_245288->Sup.len : 0);
	oldgenerics = (*c).generics;
	olderroroutputs = erroroutputs_165053;
	erroroutputs_165053 = 0;
	oldcontextlen = getinfocontextlen_165153();
	oldingenericcontext = (*c).ingenericcontext;
	oldinunrolledcontext = (*c).inunrolledcontext;
	oldingenericinst = (*c).ingenericinst;
	oldproccon = (*c).p;
	if ((*c).generics) nimGCunrefNoCycle((*c).generics);
	(*c).generics = (TY245141*) newSeqRC1((&NTI245141), 0);
	pushSafePoint(&TMP3398);
	TMP3398.status = setjmp(TMP3398.context);
	if (TMP3398.status == 0) {
		result = semexpr_410201(c, n, flags);
		{
			if (!!((gerrorcounter_165012 == olderrorcount))) goto LA5;
			result = NIM_NIL;
		}
		LA5: ;
		popSafePoint();
	}
	else {
		popSafePoint();
		if (isObj(getCurrentException()->Sup.m_type, (&NTI164344))) {
			TMP3398.status = 0;
			popCurrentException();
		}
	}
	if (TMP3398.status != 0) reraiseException();
	genericSeqAssign((&(*c).generics), oldgenerics, (&NTI245141));
	(*c).ingenericcontext = oldingenericcontext;
	(*c).inunrolledcontext = oldinunrolledcontext;
	(*c).ingenericinst = oldingenericinst;
	asgnRef((void**) (&(*c).p), oldproccon);
	setinfocontextlen_165170(oldcontextlen);
	gowners_245288 = (Tsymseq191815*) setLengthSeq(&(gowners_245288)->Sup, sizeof(Tsym191843*), ((NI) (oldownerlen)));
	asgnRef((void**) (&(*c).currentscope), oldscope);
	(*c).incompilescontext -= ((NI) 1);
	erroroutputs_165053 = olderroroutputs;
	gerrorcounter_165012 = olderrorcount;
	gerrormax_165015 = olderrormax;
	return result;
}

N_NIMCALL(Tnode191813*, semcompiles_449463)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Tnode191813* LOC6;
	Tnode191813* LOC7;
{	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!!((LOC3 == ((NI) 2)))) goto LA4;
		result = semdirectop_411032(c, n, flags);
		goto BeforeRet;
	}
	LA4: ;
	LOC6 = 0;
	LOC6 = HEX5BHEX5D_192244(n, ((NI) 1));
	LOC7 = 0;
	LOC7 = tryexpr_410317(c, LOC6, flags);
	result = newintnode_192607(((NU8) 6), ((NI64) (!((LOC7 == NIM_NIL)))));
	(*result).info = (*n).info;
	asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 1)));
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semsizeof_443694)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!!((LOC3 == ((NI) 2)))) goto LA4;
		localerror_166155((*n).info, ((NU16) 69), ((NimStringDesc*) &TMP3399));
	}
	goto LA1;
	LA4: ;
	{
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 1)], 32));
	}
	LA1: ;
	asgnRefNoCycle((void**) (&(*n).typ), getsystype_239030(((NU8) 31)));
	result = n;
	return result;
}

N_NIMCALL(Tnode191813*, isopimpl_411048)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Ttype191849* t1;
	Tnode191813* LOC16;
	result = 0;
	{
		NIM_BOOL LOC3;
		NIM_BOOL LOC4;
		NIM_BOOL LOC5;
		NI LOC6;
		Tnode191813* LOC8;
		Tnode191813* LOC10;
		Tnode191813* LOC12;
		NimStringDesc* LOC15;
		LOC3 = 0;
		LOC4 = 0;
		LOC5 = 0;
		LOC6 = 0;
		LOC6 = sonslen_194403(n);
		LOC5 = (LOC6 == ((NI) 3));
		if (!(LOC5)) goto LA7;
		LOC8 = 0;
		LOC8 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC5 = !(((*LOC8).typ == NIM_NIL));
		LA7: ;
		LOC4 = LOC5;
		if (!(LOC4)) goto LA9;
		LOC10 = 0;
		LOC10 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC4 = ((*(*LOC10).typ).kind == ((NU8) 8));
		LA9: ;
		LOC3 = LOC4;
		if (!(LOC3)) goto LA11;
		LOC12 = 0;
		LOC12 = HEX5BHEX5D_192244(n, ((NI) 2));
		LOC3 = ((*LOC12).kind >= ((NU8) 20) && (*LOC12).kind <= ((NU8) 22) || (*LOC12).kind == ((NU8) 4));
		LA11: ;
		if (!!(LOC3)) goto LA13;
		LOC15 = 0;
		LOC15 = HEX24_166306(TMP3401);
		internalerror_166218(LOC15);
	}
	LA13: ;
	LOC16 = 0;
	LOC16 = HEX5BHEX5D_192244(n, ((NI) 1));
	t1 = skiptypes_195167((*LOC16).typ, IL64(2305843009213694208));
	{
		Tnode191813* LOC19;
		Tnode191813* LOC22;
		NimStringDesc* LOC23;
		LOC19 = 0;
		LOC19 = HEX5BHEX5D_192244(n, ((NI) 2));
		if (!((*LOC19).kind >= ((NU8) 20) && (*LOC19).kind <= ((NU8) 22))) goto LA20;
		LOC22 = 0;
		LOC22 = HEX5BHEX5D_192244(n, ((NI) 2));
		LOC23 = 0;
		LOC23 = nsuNormalize((*LOC22).kindU.S3.strval);
		if (eqStrings(LOC23, ((NimStringDesc*) &TMP3402))) goto LA24;
		goto LA25;
		LA24: ;
		{
			Ttype191849* t;
			NIM_BOOL LOC28;
			NIM_BOOL LOC29;
			t = skiptypes_195167(t1, IL64(211106233624832));
			LOC28 = 0;
			LOC29 = 0;
			LOC29 = ((*t).kind == ((NU8) 25));
			if (!(LOC29)) goto LA30;
			LOC29 = ((*t).callconv == ((NU8) 8));
			LA30: ;
			LOC28 = LOC29;
			if (!(LOC28)) goto LA31;
			LOC28 = !((((*t).flags &(1<<((((NU8) 14))&31)))!=0));
			LA31: ;
			result = newintnode_192607(((NU8) 6), ((NI64) (LOC28)));
		}
		goto LA26;
		LA25: ;
		{
		}
		LA26: ;
	}
	goto LA17;
	LA20: ;
	{
		Ttype191849* t2;
		Tnode191813* LOC34;
		Tcandidate345209 m;
		NIM_BOOL match;
		NU8 LOC35;
		LOC34 = 0;
		LOC34 = HEX5BHEX5D_192244(n, ((NI) 2));
		t2 = skiptypes_195167((*LOC34).typ, 256);
		maybelifttype_443488(&t2, c, (*n).info);
		memset((void*)(&m), 0, sizeof(m));
		initcandidate_345276(c, (&m), t2);
		LOC35 = 0;
		LOC35 = typerel_346064((&m), t2, t1, NIM_TRUE);
		match = (((NU8) 3) <= LOC35);
		result = newintnode_192607(((NU8) 6), ((NI64) (match)));
	}
	LA17: ;
	asgnRefNoCycle((void**) (&(*result).typ), (*n).typ);
	return result;
}

N_NIMCALL(Tnode191813*, semis_443917)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* LOC6;
	Ttype191849* lhstype;
	Tnode191813* LOC14;
{	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!!((LOC3 == ((NI) 3)))) goto LA4;
		localerror_166155((*n).info, ((NU16) 204), ((NimStringDesc*) &TMP3400));
	}
	LA4: ;
	result = n;
	asgnRefNoCycle((void**) (&(*n).typ), getsystype_239030(((NU8) 1)));
	LOC6 = 0;
	LOC6 = HEX5BHEX5D_192244(n, ((NI) 1));
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), semexprwithtype_410211(c, LOC6, 34));
	{
		Tnode191813* LOC9;
		Ttype191849* t2;
		Tnode191813* LOC12;
		Tnode191813* LOC13;
		LOC9 = 0;
		LOC9 = HEX5BHEX5D_192244(n, ((NI) 2));
		if (!!(((*LOC9).kind >= ((NU8) 20) && (*LOC9).kind <= ((NU8) 22)))) goto LA10;
		LOC12 = 0;
		LOC12 = HEX5BHEX5D_192244(n, ((NI) 2));
		t2 = semtypenode_410269(c, LOC12, NIM_NIL);
		LOC13 = 0;
		LOC13 = HEX5BHEX5D_192244(n, ((NI) 2));
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), newnodeit_193807(((NU8) 4), (*LOC13).info, t2));
	}
	LA10: ;
	LOC14 = 0;
	LOC14 = HEX5BHEX5D_192244(n, ((NI) 1));
	lhstype = (*LOC14).typ;
	{
		Tnode191813* LOC19;
		if (!!(((*lhstype).kind == ((NU8) 8)))) goto LA17;
		LOC19 = 0;
		LOC19 = HEX5BHEX5D_192244(n, ((NI) 1));
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), maketypesymnode_245711(c, lhstype, (*LOC19).info));
	}
	goto LA15;
	LA17: ;
	{
		Ttype191849* LOC21;
		LOC21 = 0;
		LOC21 = base_221039(lhstype);
		if (!((*LOC21).kind == ((NU8) 0))) goto LA22;
		goto BeforeRet;
	}
	goto LA15;
	LA22: ;
	LA15: ;
	{
		Tnode191813* LOC26;
		Ttype191849* LOC27;
		NIM_BOOL LOC28;
		LOC26 = 0;
		LOC26 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC27 = 0;
		LOC27 = base_221039((*LOC26).typ);
		LOC28 = 0;
		LOC28 = containsgenerictype_230310(LOC27);
		if (!!(LOC28)) goto LA29;
		result = isopimpl_411048(c, n);
	}
	LA29: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semof_443705)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
{	result = 0;
	{
		NI LOC3;
		Ttype191849* a;
		Ttype191849* b;
		Ttype191849* x;
		Ttype191849* y;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 3))) goto LA4;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 1)], 0));
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 2)], 32));
		a = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 1)]).typ, IL64(211106247256320));
		b = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 2)]).typ, IL64(211106247256320));
		x = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 1)]).typ, IL64(211106247256064));
		y = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 2)]).typ, IL64(211106247256064));
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = ((*x).kind == ((NU8) 8));
			if (LOC8) goto LA9;
			LOC8 = !(((*y).kind == ((NU8) 8)));
			LA9: ;
			if (!LOC8) goto LA10;
			localerror_166155((*n).info, ((NU16) 205), ((NimStringDesc*) &TMP3403));
		}
		goto LA6;
		LA10: ;
		{
			NIM_BOOL LOC13;
			LOC13 = 0;
			LOC13 = !(((*b).kind == ((NU8) 17)));
			if (LOC13) goto LA14;
			LOC13 = !(((*a).kind == ((NU8) 17)));
			LA14: ;
			if (!LOC13) goto LA15;
			localerror_166155((*n).info, ((NU16) 205), ((NimStringDesc*) &TMP3403));
		}
		goto LA6;
		LA15: ;
		{
			NI diff;
			diff = inheritancediff_228064(a, b);
			{
				NimStringDesc* LOC22;
				if (!(diff <= ((NI) 0))) goto LA20;
				LOC22 = 0;
				LOC22 = rendertree_213058(n, 0);
				message_166188((*n).info, ((NU16) 274), LOC22);
				result = newintnode_192607(((NU8) 6), IL64(1));
				(*result).info = (*n).info;
				asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 1)));
				goto BeforeRet;
			}
			goto LA18;
			LA20: ;
			{
				NimStringDesc* LOC26;
				if (!(diff == ((NI) IL64(9223372036854775807)))) goto LA24;
				LOC26 = 0;
				LOC26 = typetostring_221032(a, ((NU8) 0));
				localerror_166155((*n).info, ((NU16) 206), LOC26);
			}
			goto LA18;
			LA24: ;
			LA18: ;
		}
		LA6: ;
	}
	goto LA1;
	LA4: ;
	{
		localerror_166155((*n).info, ((NU16) 204), ((NimStringDesc*) &TMP3403));
	}
	LA1: ;
	asgnRefNoCycle((void**) (&(*n).typ), getsystype_239030(((NU8) 1)));
	result = n;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tsym191843*, expectmacroortemplatecall_411025)(Tcontext245023* c, Tnode191813* n) {
	Tsym191843* result;
{	result = 0;
	{
		NIM_BOOL LOC3;
		Tsym191843* expandedsym;
		Tnode191813* LOC6;
		LOC3 = 0;
		LOC3 = iscallexpr_192071(n);
		if (!LOC3) goto LA4;
		LOC6 = 0;
		LOC6 = HEX5BHEX5D_192244(n, ((NI) 0));
		expandedsym = qualifiedlookup_250864(c, LOC6, 2);
		{
			Tnode191813* LOC11;
			NimStringDesc* LOC12;
			Tnode191813* LOC13;
			if (!(expandedsym == NIM_NIL)) goto LA9;
			LOC11 = 0;
			LOC11 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC12 = 0;
			LOC12 = rendertree_213058(LOC11, 0);
			localerror_166155((*n).info, ((NU16) 61), LOC12);
			LOC13 = 0;
			LOC13 = HEX5BHEX5D_192244(n, ((NI) 0));
			result = errorsym_250372(c, LOC13);
			goto BeforeRet;
		}
		LA9: ;
		{
			Tnode191813* LOC18;
			if (!!(((393216 &(1<<(((*expandedsym).kind)&31)))!=0))) goto LA16;
			localerror_166155((*n).info, ((NU16) 216), (*(*expandedsym).name).s);
			LOC18 = 0;
			LOC18 = HEX5BHEX5D_192244(n, ((NI) 0));
			result = errorsym_250372(c, LOC18);
			goto BeforeRet;
		}
		LA16: ;
		result = expandedsym;
	}
	goto LA1;
	LA4: ;
	{
		NimStringDesc* LOC20;
		LOC20 = 0;
		LOC20 = rendertree_213058(n, 0);
		localerror_166155((*n).info, ((NU16) 216), LOC20);
		result = errorsym_250372(c, n);
	}
	LA1: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semexpandtoast_448913)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* macrocall;
	Tsym191843* expandedsym;
{	result = 0;
	macrocall = HEX5BHEX5D_192244(n, ((NI) 1));
	expandedsym = expectmacroortemplatecall_411025(c, macrocall);
	{
		if (!((*expandedsym).kind == ((NU8) 0))) goto LA3;
		result = n;
		goto BeforeRet;
	}
	LA3: ;
	asgnRefNoCycle((void**) (&(*macrocall).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(expandedsym, (*macrocall).info));
	markused_345251((*n).info, expandedsym);
	{
		NI i_449014;
		NI HEX3Atmp_449050;
		NI LOC6;
		NI res_449053;
		i_449014 = 0;
		HEX3Atmp_449050 = 0;
		LOC6 = 0;
		LOC6 = len_192097(macrocall);
		HEX3Atmp_449050 = (NI)(LOC6 - ((NI) 1));
		res_449053 = ((NI) 1);
		{
			while (1) {
				Tnode191813* LOC9;
				if (!(res_449053 <= HEX3Atmp_449050)) goto LA8;
				i_449014 = res_449053;
				LOC9 = 0;
				LOC9 = HEX5BHEX5D_192244(macrocall, i_449014);
				asgnRefNoCycle((void**) (&(*macrocall).kindU.S6.sons->data[i_449014]), semexprwithtype_410211(c, LOC9, 0));
				res_449053 += ((NI) 1);
			} LA8: ;
		}
	}
	{
		NimStringDesc* LOC14;
		if (!!(((*(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).magic == ((NU16) 20)))) goto LA12;
		LOC14 = 0;
		LOC14 = HEX24_166306(TMP3404);
		internalerror_166218(LOC14);
	}
	LA12: ;
	{
		Tsym191843* LOC17;
		LOC17 = 0;
		LOC17 = getcompilerproc_239036(((NimStringDesc*) &TMP3028));
		if (!!((LOC17 == NIM_NIL))) goto LA18;
		asgnRefNoCycle((void**) (&(*n).typ), systypefromname_239213(((NimStringDesc*) &TMP3029)));
	}
	goto LA15;
	LA18: ;
	{
		asgnRefNoCycle((void**) (&(*n).typ), systypefromname_239213(((NimStringDesc*) &TMP3030)));
	}
	LA15: ;
	result = n;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semexpandtoast_449069)(Tcontext245023* c, Tnode191813* n, Tsym191843* magicsym, NU16 flags) {
	Tnode191813* result;
	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 2))) goto LA4;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(magicsym, (*n).info));
		result = semexpandtoast_448913(c, n);
	}
	goto LA1;
	LA4: ;
	{
		result = semdirectop_411032(c, n, flags);
	}
	LA1: ;
	return result;
}

N_NIMCALL(NimStringDesc*, expectstring_448791)(Tcontext245023* c, Tnode191813* n_448794) {
	NimStringDesc* result;
	Tnode191813* n;
{	result = 0;
	n = semconstexpr_411485(c, n_448794);
	{
		if (!((*n).kind >= ((NU8) 20) && (*n).kind <= ((NU8) 22))) goto LA3;
		result = copyString((*n).kindU.S3.strval);
		goto BeforeRet;
	}
	goto LA1;
	LA3: ;
	{
		localerror_166155((*n).info, ((NU16) 6), ((NimStringDesc*) &TMP2991));
	}
	LA1: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, processquotations_449082)(Tnode191813** n, NimStringDesc* op, Tnodeseq191807** quotes, Tnodeseq191807** ids) {
{	{
		if (!((*(*n)).kind == ((NU8) 30))) goto LA3;
		checksonslen_246249((*n), ((NI) 2));
		{
			Tnode191813* LOC7;
			NimStringDesc* examinedop;
			Tnode191813* LOC10;
			LOC7 = 0;
			LOC7 = HEX5BHEX5D_192244((*n), ((NI) 0));
			if (!((*LOC7).kind == ((NU8) 2))) goto LA8;
			LOC10 = 0;
			LOC10 = HEX5BHEX5D_192244((*n), ((NI) 0));
			examinedop = copyString((*(*LOC10).kindU.S5.ident).s);
			{
				Tnode191813* LOC15;
				NimStringDesc* LOC16;
				Tident168021* LOC17;
				if (!eqStrings(examinedop, op)) goto LA13;
				LOC15 = 0;
				LOC15 = HEX5BHEX5D_192244((*n), ((NI) 1));
				(*quotes) = (Tnodeseq191807*) incrSeq(&((*quotes))->Sup, sizeof(Tnode191813*));
				asgnRefNoCycle((void**) (&(*quotes)->data[(*quotes)->Sup.len-1]), LOC15);
				LOC16 = 0;
				LOC16 = nimIntToStr(((*quotes) ? (*quotes)->Sup.len : 0));
				LOC17 = 0;
				LOC17 = getident_168463(LOC16);
				unsureAsgnRef((void**) (&(*n)), newidentnode_193313(LOC17, (*(*n)).info));
				(*ids) = (Tnodeseq191807*) incrSeq(&((*ids))->Sup, sizeof(Tnode191813*));
				asgnRefNoCycle((void**) (&(*ids)->data[(*ids)->Sup.len-1]), (*n));
				goto BeforeRet;
			}
			goto LA11;
			LA13: ;
			{
				NIM_BOOL LOC19;
				NimStringDesc* LOC22;
				Tident168021* LOC23;
				LOC19 = 0;
				LOC19 = nsuStartsWith(examinedop, op);
				if (!LOC19) goto LA20;
				LOC22 = 0;
				LOC22 = copyStr(examinedop, (op ? op->Sup.len : 0));
				LOC23 = 0;
				LOC23 = getident_168463(LOC22);
				asgnRefNoCycle((void**) (&(*(*n)).kindU.S6.sons->data[((NI) 0)]), newidentnode_193313(LOC23, (*(*n)).info));
			}
			goto LA11;
			LA20: ;
			LA11: ;
		}
		LA8: ;
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC25;
		Tnode191813* LOC29;
		NimStringDesc* LOC30;
		Tident168021* LOC31;
		LOC25 = 0;
		LOC25 = ((*(*n)).kind == ((NU8) 53));
		if (!(LOC25)) goto LA26;
		LOC25 = eqStrings(op, ((NimStringDesc*) &TMP3406));
		LA26: ;
		if (!LOC25) goto LA27;
		LOC29 = 0;
		LOC29 = HEX5BHEX5D_192244((*n), ((NI) 0));
		(*quotes) = (Tnodeseq191807*) incrSeq(&((*quotes))->Sup, sizeof(Tnode191813*));
		asgnRefNoCycle((void**) (&(*quotes)->data[(*quotes)->Sup.len-1]), LOC29);
		LOC30 = 0;
		LOC30 = nimIntToStr(((*quotes) ? (*quotes)->Sup.len : 0));
		LOC31 = 0;
		LOC31 = getident_168463(LOC30);
		unsureAsgnRef((void**) (&(*n)), newidentnode_193313(LOC31, (*(*n)).info));
		(*ids) = (Tnodeseq191807*) incrSeq(&((*ids))->Sup, sizeof(Tnode191813*));
		asgnRefNoCycle((void**) (&(*ids)->data[(*ids)->Sup.len-1]), (*n));
		goto BeforeRet;
	}
	goto LA1;
	LA27: ;
	LA1: ;
	{
		NI i_449208;
		NI HEX3Atmp_449212;
		NI LOC33;
		NI res_449215;
		i_449208 = 0;
		HEX3Atmp_449212 = 0;
		LOC33 = 0;
		LOC33 = safelen_192125((*n));
		HEX3Atmp_449212 = (LOC33 - 1);
		res_449215 = ((NI) 0);
		{
			while (1) {
				if (!(res_449215 <= HEX3Atmp_449212)) goto LA35;
				i_449208 = res_449215;
				processquotations_449082(&(*(*n)).kindU.S6.sons->data[i_449208], op, quotes, ids);
				res_449215 += ((NI) 1);
			} LA35: ;
		}
	}
	}BeforeRet: ;
}

N_NIMCALL(Tsym191843*, newanonsym_448826)(NU8 kind, Tlineinfo164338 info, Tsym191843* owner) {
	Tsym191843* result;
	result = 0;
	result = newsym_192655(kind, idanon_168495, owner, info);
	(*result).flags = IL64(2147483648);
	return result;
}

N_NIMCALL(Tnode191813*, semtemplbodydirty_426220)(Templctx423582* c, Tnode191813* n) {
	Tnode191813* result;
{	result = 0;
	result = n;
	switch ((*n).kind) {
	case ((NU8) 2):
	{
		Tsym191843* s;
		s = qualifiedlookup_250864((*c).c, n, 0);
		{
			if (!!((s == NIM_NIL))) goto LA4;
			{
				NIM_BOOL LOC8;
				LOC8 = 0;
				LOC8 = ((*s).owner == (*c).owner);
				if (!(LOC8)) goto LA9;
				LOC8 = ((*s).kind == ((NU8) 3));
				LA9: ;
				if (!LOC8) goto LA10;
				result = newsymnode_193338(s, (*n).info);
			}
			goto LA6;
			LA10: ;
			{
				NIM_BOOL LOC13;
				LOC13 = 0;
				LOC13 = contains_188829((&(*c).tobind), (*s).Sup.id);
				if (!LOC13) goto LA14;
				result = symchoice_423316((*c).c, n, s, ((NU8) 0));
			}
			goto LA6;
			LA14: ;
			LA6: ;
		}
		LA4: ;
	}
	break;
	case ((NU8) 55):
	{
		result = semtemplbodydirty_426220(c, (*n).kindU.S6.sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 122):
	{
		result = sembindstmt_423421((*c).c, n, (&(*c).tobind));
	}
	break;
	case ((NU8) 1):
	case ((NU8) 3) ... ((NU8) 23):
	{
	}
	break;
	default:
	{
		{
			NIM_BOOL LOC22;
			Tsym191843* s;
			LOC22 = 0;
			LOC22 = ((*n).kind == ((NU8) 45));
			if (LOC22) goto LA23;
			LOC22 = ((*n).kind == ((NU8) 53));
			LA23: ;
			if (!LOC22) goto LA24;
			s = qualifiedlookup_250864((*c).c, n, 0);
			{
				NIM_BOOL LOC28;
				LOC28 = 0;
				LOC28 = !((s == NIM_NIL));
				if (!(LOC28)) goto LA29;
				LOC28 = contains_188829((&(*c).tobind), (*s).Sup.id);
				LA29: ;
				if (!LOC28) goto LA30;
				result = symchoice_423316((*c).c, n, s, ((NU8) 0));
				goto BeforeRet;
			}
			LA30: ;
		}
		LA24: ;
		result = n;
		{
			NI i_426486;
			NI HEX3Atmp_426490;
			NI LOC33;
			NI res_426493;
			i_426486 = 0;
			HEX3Atmp_426490 = 0;
			LOC33 = 0;
			LOC33 = sonslen_194403(n);
			HEX3Atmp_426490 = (NI)(LOC33 - ((NI) 1));
			res_426493 = ((NI) 0);
			{
				while (1) {
					if (!(res_426493 <= HEX3Atmp_426490)) goto LA35;
					i_426486 = res_426493;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_426486]), semtemplbodydirty_426220(c, (*n).kindU.S6.sons->data[i_426486]));
					res_426493 += ((NI) 1);
				} LA35: ;
			}
		}
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semtemplsymbol_424011)(Tcontext245023* c, Tnode191813* n, Tsym191843* s) {
	Tnode191813* result;
	result = 0;
	(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
	switch ((*s).kind) {
	case ((NU8) 0):
	{
		result = n;
	}
	break;
	case ((NU8) 12):
	case ((NU8) 13):
	case ((NU8) 14):
	case ((NU8) 15):
	case ((NU8) 16):
	case ((NU8) 6):
	case ((NU8) 18):
	case ((NU8) 17):
	{
		result = symchoice_423316(c, n, s, ((NU8) 1));
	}
	break;
	case ((NU8) 4):
	{
		result = newsymnodetypedesc_258736(s, (*n).info);
	}
	break;
	case ((NU8) 3):
	{
		result = n;
	}
	break;
	case ((NU8) 7):
	{
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = !(((*s).typ == NIM_NIL));
			if (!(LOC8)) goto LA9;
			LOC8 = !(((*(*s).typ).kind == ((NU8) 12)));
			LA9: ;
			if (!LOC8) goto LA10;
			result = newsymnodetypedesc_258736(s, (*n).info);
		}
		goto LA6;
		LA10: ;
		{
			result = n;
		}
		LA6: ;
	}
	break;
	default:
	{
		result = newsymnode_193338(s, (*n).info);
	}
	break;
	}
	return result;
}

N_NIMCALL(void, openscope_423693)(Templctx423582* c) {
	Tscope191837* LOC1;
	LOC1 = 0;
	LOC1 = openscope_250091((*c).c);
}

N_NIMCALL(void, closescope_423700)(Templctx423582* c) {
	closescope_250111((*c).c);
}

N_NIMCALL(Tnode191813*, semtemplbodyscope_423707)(Templctx423582* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	openscope_423693(c);
	result = semtemplbody_423688(c, n);
	closescope_423700(c);
	return result;
}

N_NIMCALL(NU8, symbinding_423251)(Tnode191813* n) {
	NU8 result;
{	result = 0;
	{
		NI i_423267;
		NI HEX3Atmp_423292;
		NI LOC2;
		NI res_423295;
		i_423267 = 0;
		HEX3Atmp_423292 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_423292 = (NI)(LOC2 - ((NI) 1));
		res_423295 = ((NI) 0);
		{
			while (1) {
				Tnode191813* it;
				Tnode191813* key;
				if (!(res_423295 <= HEX3Atmp_423292)) goto LA4;
				i_423267 = res_423295;
				it = (*n).kindU.S6.sons->data[i_423267];
				{
					if (!((*it).kind == ((NU8) 34))) goto LA7;
					key = (*it).kindU.S6.sons->data[((NI) 0)];
				}
				goto LA5;
				LA7: ;
				{
					key = it;
				}
				LA5: ;
				{
					NU16 LOC14;
					if (!((*key).kind == ((NU8) 2))) goto LA12;
					LOC14 = 0;
					LOC14 = whichkeyword_173386((*key).kindU.S5.ident);
					switch (LOC14) {
					case ((NU16) 181):
					{
						result = ((NU8) 1);
						goto BeforeRet;
					}
					break;
					case ((NU16) 182):
					{
						result = ((NU8) 2);
						goto BeforeRet;
					}
					break;
					default:
					{
					}
					break;
					}
				}
				LA12: ;
				res_423295 += ((NI) 1);
			} LA4: ;
		}
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, onlyreplaceparams_423716)(Templctx423582* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = n;
	{
		Tsym191843* s;
		if (!((*n).kind == ((NU8) 2))) goto LA3;
		s = qualifiedlookup_250864((*c).c, n, 0);
		{
			if (!!((s == NIM_NIL))) goto LA7;
			{
				NIM_BOOL LOC11;
				LOC11 = 0;
				LOC11 = ((*s).owner == (*c).owner);
				if (!(LOC11)) goto LA12;
				LOC11 = ((*s).kind == ((NU8) 3));
				LA12: ;
				if (!LOC11) goto LA13;
				(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
				result = newsymnode_193338(s, (*n).info);
			}
			LA13: ;
		}
		LA7: ;
	}
	goto LA1;
	LA3: ;
	{
		{
			NI i_423820;
			NI HEX3Atmp_423824;
			NI LOC17;
			NI res_423827;
			i_423820 = 0;
			HEX3Atmp_423824 = 0;
			LOC17 = 0;
			LOC17 = safelen_192125(n);
			HEX3Atmp_423824 = (LOC17 - 1);
			res_423827 = ((NI) 0);
			{
				while (1) {
					if (!(res_423827 <= HEX3Atmp_423824)) goto LA19;
					i_423820 = res_423827;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_423820]), onlyreplaceparams_423716(c, (*n).kindU.S6.sons->data[i_423820]));
					res_423827 += ((NI) 1);
				} LA19: ;
			}
		}
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, getidentnode_423589)(Templctx423582* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	switch ((*n).kind) {
	case ((NU8) 31):
	{
		result = getidentnode_423589(c, (*n).kindU.S6.sons->data[((NI) 1)]);
	}
	break;
	case ((NU8) 43):
	{
		result = getidentnode_423589(c, (*n).kindU.S6.sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 2):
	{
		Tsym191843* s;
		result = n;
		s = qualifiedlookup_250864((*c).c, n, 0);
		{
			if (!!((s == NIM_NIL))) goto LA6;
			{
				NIM_BOOL LOC10;
				LOC10 = 0;
				LOC10 = ((*s).owner == (*c).owner);
				if (!(LOC10)) goto LA11;
				LOC10 = ((*s).kind == ((NU8) 3));
				LA11: ;
				if (!LOC10) goto LA12;
				result = newsymnode_193338(s, (*n).info);
			}
			LA12: ;
		}
		LA6: ;
	}
	break;
	case ((NU8) 53):
	case ((NU8) 3):
	{
		result = n;
	}
	break;
	default:
	{
		illformedast_246229(n);
		result = n;
	}
	break;
	}
	return result;
}

static N_INLINE(NIM_BOOL, istemplparam_423636)(Templctx423582* c, Tnode191813* n) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	NIM_BOOL LOC2;
	NIM_BOOL LOC3;
	result = 0;
	LOC1 = 0;
	LOC2 = 0;
	LOC3 = 0;
	LOC3 = ((*n).kind == ((NU8) 3));
	if (!(LOC3)) goto LA4;
	LOC3 = ((*(*n).kindU.S4.sym).kind == ((NU8) 3));
	LA4: ;
	LOC2 = LOC3;
	if (!(LOC2)) goto LA5;
	LOC2 = ((*(*n).kindU.S4.sym).owner == (*c).owner);
	LA5: ;
	LOC1 = LOC2;
	if (!(LOC1)) goto LA6;
	LOC1 = !((((*(*n).kindU.S4.sym).flags &(1<<((((NU8) 31))&31)))!=0));
	LA6: ;
	result = LOC1;
	return result;
}

N_NIMCALL(void, replaceidentbysym_423569)(Tnode191813** n, Tnode191813* s) {
	switch ((*(*n)).kind) {
	case ((NU8) 31):
	{
		replaceidentbysym_423569(&(*(*n)).kindU.S6.sons->data[((NI) 1)], s);
	}
	break;
	case ((NU8) 43):
	{
		replaceidentbysym_423569(&(*(*n)).kindU.S6.sons->data[((NI) 0)], s);
	}
	break;
	case ((NU8) 2):
	case ((NU8) 53):
	case ((NU8) 3):
	{
		unsureAsgnRef((void**) (&(*n)), s);
	}
	break;
	default:
	{
		illformedast_246229((*n));
	}
	break;
	}
}

N_NIMCALL(Tsym191843*, newgensym_423843)(NU8 kind, Tnode191813* n, Templctx423582* c) {
	Tsym191843* result;
	Tident168021* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = considerquotedident_250010(n);
	result = newsym_192655(kind, LOC1, (*c).owner, (*n).info);
	(*result).flags |= ((NI32)1)<<((((NU8) 31))%(sizeof(NI32)*8));
	(*result).flags |= ((NI32)1)<<((((NU8) 21))%(sizeof(NI32)*8));
	return result;
}

N_NIMCALL(void, addlocaldecl_423875)(Templctx423582* c, Tnode191813** n, NU8 k) {
{	{
		NIM_BOOL LOC3;
		NU8 LOC5;
		Tnode191813* x;
		Tnode191813* ident;
		LOC3 = 0;
		LOC3 = ((*(*n)).kind == ((NU8) 43));
		if (!(LOC3)) goto LA4;
		LOC5 = 0;
		LOC5 = symbinding_423251((*(*n)).kindU.S6.sons->data[((NI) 1)]);
		LOC3 = (LOC5 == ((NU8) 2));
		LA4: ;
		if (!LOC3) goto LA6;
		x = HEX5BHEX5D_192244((*n), ((NI) 0));
		{
			while (1) {
				switch ((*x).kind) {
				case ((NU8) 31):
				{
					x = HEX5BHEX5D_192244(x, ((NI) 1));
				}
				break;
				case ((NU8) 43):
				{
					x = HEX5BHEX5D_192244(x, ((NI) 0));
				}
				break;
				case ((NU8) 2):
				{
					goto LA8;
				}
				break;
				case ((NU8) 53):
				{
					unsureAsgnRef((void**) (&(*n)), onlyreplaceparams_423716(c, (*n)));
					goto BeforeRet;
				}
				break;
				default:
				{
					illformedast_246229(x);
				}
				break;
				}
			}
		} LA8: ;
		ident = getidentnode_423589(c, x);
		{
			NIM_BOOL LOC17;
			LOC17 = 0;
			LOC17 = istemplparam_423636((&(*c)), ident);
			if (!!(LOC17)) goto LA18;
			incl_188856((&(*c).toinject), (*(*x).kindU.S5.ident).Sup.id);
		}
		goto LA15;
		LA18: ;
		{
			replaceidentbysym_423569(n, ident);
		}
		LA15: ;
	}
	goto LA1;
	LA6: ;
	{
		Tnode191813* ident;
		ident = getidentnode_423589(c, (*n));
		{
			NIM_BOOL LOC24;
			Tsym191843* local;
			Tnode191813* LOC27;
			LOC24 = 0;
			LOC24 = istemplparam_423636((&(*c)), ident);
			if (!!(LOC24)) goto LA25;
			local = newgensym_423843(k, ident, c);
			addprelimdecl_250619((*c).c, local);
			LOC27 = 0;
			LOC27 = newsymnode_193338(local, (*(*n)).info);
			replaceidentbysym_423569(n, LOC27);
		}
		goto LA22;
		LA25: ;
		{
			replaceidentbysym_423569(n, ident);
		}
		LA22: ;
	}
	LA1: ;
	}BeforeRet: ;
}

N_NIMCALL(void, semtemplsomedecl_424438)(Templctx423582* c, Tnode191813* n, NU8 symkind, NI start) {
	{
		NI i_424457;
		NI HEX3Atmp_424517;
		NI LOC2;
		NI res_424520;
		i_424457 = 0;
		HEX3Atmp_424517 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_424517 = (NI)(LOC2 - ((NI) 1));
		res_424520 = start;
		{
			while (1) {
				if (!(res_424520 <= HEX3Atmp_424517)) goto LA4;
				i_424457 = res_424520;
				{
					Tnode191813* a;
					NI L;
					a = (*n).kindU.S6.sons->data[i_424457];
					{
						if (!((*a).kind == ((NU8) 125))) goto LA8;
						goto LA5;
					}
					LA8: ;
					{
						NIM_BOOL LOC12;
						LOC12 = 0;
						LOC12 = !(((*a).kind == ((NU8) 35)));
						if (!(LOC12)) goto LA13;
						LOC12 = !(((*a).kind == ((NU8) 36)));
						LA13: ;
						if (!LOC12) goto LA14;
						illformedast_246229(a);
					}
					LA14: ;
					checkminsonslen_246259(a, ((NI) 3));
					L = sonslen_194403(a);
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 2))]), semtemplbody_423688(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 2))]));
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), semtemplbody_423688(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]));
					{
						NI j_424504;
						NI HEX3Atmp_424510;
						NI res_424513;
						j_424504 = 0;
						HEX3Atmp_424510 = 0;
						HEX3Atmp_424510 = (NI)(L - ((NI) 3));
						res_424513 = ((NI) 0);
						{
							while (1) {
								if (!(res_424513 <= HEX3Atmp_424510)) goto LA18;
								j_424504 = res_424513;
								addlocaldecl_423875(c, &(*a).kindU.S6.sons->data[j_424504], symkind);
								res_424513 += ((NI) 1);
							} LA18: ;
						}
					}
				} LA5: ;
				res_424520 += ((NI) 1);
			} LA4: ;
		}
	}
}

N_NIMCALL(Tnode191813*, semroutineintemplname_424054)(Templctx423582* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = n;
	{
		Tsym191843* s;
		if (!((*n).kind == ((NU8) 2))) goto LA3;
		s = qualifiedlookup_250864((*c).c, n, 0);
		{
			if (!!((s == NIM_NIL))) goto LA7;
			{
				NIM_BOOL LOC11;
				NIM_BOOL LOC13;
				LOC11 = 0;
				LOC11 = ((*s).owner == (*c).owner);
				if (!(LOC11)) goto LA12;
				LOC13 = 0;
				LOC13 = ((*s).kind == ((NU8) 3));
				if (LOC13) goto LA14;
				LOC13 = (((*s).flags &(1<<((((NU8) 31))&31)))!=0);
				LA14: ;
				LOC11 = LOC13;
				LA12: ;
				if (!LOC11) goto LA15;
				(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
				result = newsymnode_193338(s, (*n).info);
			}
			LA15: ;
		}
		LA7: ;
	}
	goto LA1;
	LA3: ;
	{
		{
			NI i_424213;
			NI HEX3Atmp_424217;
			NI LOC19;
			NI res_424220;
			i_424213 = 0;
			HEX3Atmp_424217 = 0;
			LOC19 = 0;
			LOC19 = safelen_192125(n);
			HEX3Atmp_424217 = (NI)(LOC19 - ((NI) 1));
			res_424220 = ((NI) 0);
			{
				while (1) {
					if (!(res_424220 <= HEX3Atmp_424217)) goto LA21;
					i_424213 = res_424220;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_424213]), semroutineintemplname_424054(c, (*n).kindU.S6.sons->data[i_424213]));
					res_424220 += ((NI) 1);
				} LA21: ;
			}
		}
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semroutineintemplbody_424236)(Templctx423582* c, Tnode191813* n, NU8 k) {
	Tnode191813* result;
	result = 0;
	result = n;
	checksonslen_246249(n, ((NI) 7));
	{
		NIM_BOOL LOC3;
		NU8 LOC5;
		Tnode191813* ident;
		LOC3 = 0;
		LOC3 = !(((*n).kind == ((NU8) 51) || (*n).kind == ((NU8) 52)));
		if (!(LOC3)) goto LA4;
		LOC5 = 0;
		LOC5 = symbinding_423251((*n).kindU.S6.sons->data[((NI) 4)]);
		LOC3 = (LOC5 == ((NU8) 1));
		LA4: ;
		if (!LOC3) goto LA6;
		ident = getidentnode_423589(c, (*n).kindU.S6.sons->data[((NI) 0)]);
		{
			NIM_BOOL LOC10;
			Tsym191843* s;
			LOC10 = 0;
			LOC10 = istemplparam_423636((&(*c)), ident);
			if (!!(LOC10)) goto LA11;
			s = newgensym_423843(k, ident, c);
			asgnRefNoCycle((void**) (&(*s).ast), n);
			addprelimdecl_250619((*c).c, s);
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(s, (*(*n).kindU.S6.sons->data[((NI) 0)]).info));
		}
		goto LA8;
		LA11: ;
		{
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), ident);
		}
		LA8: ;
	}
	goto LA1;
	LA6: ;
	{
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semroutineintemplname_424054(c, (*n).kindU.S6.sons->data[((NI) 0)]));
	}
	LA1: ;
	openscope_423693(c);
	{
		NI i_424416;
		NI res_424422;
		i_424416 = 0;
		res_424422 = ((NI) 1);
		{
			while (1) {
				if (!(res_424422 <= ((NI) 6))) goto LA17;
				i_424416 = res_424422;
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_424416]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[i_424416]));
				res_424422 += ((NI) 1);
			} LA17: ;
		}
	}
	closescope_423700(c);
	return result;
}

N_NIMCALL(Tnode191813*, semtemplbody_423688)(Templctx423582* c, Tnode191813* n) {
	Tnode191813* result;
{	result = 0;
	result = n;
	switch ((*n).kind) {
	case ((NU8) 2):
	{
		Tsym191843* s;
		{
			NIM_BOOL LOC4;
			LOC4 = 0;
			LOC4 = contains_188829((&(*c).toinject), (*(*n).kindU.S5.ident).Sup.id);
			if (!LOC4) goto LA5;
			result = n;
			goto BeforeRet;
		}
		LA5: ;
		s = qualifiedlookup_250864((*c).c, n, 0);
		{
			if (!!((s == NIM_NIL))) goto LA9;
			{
				NIM_BOOL LOC13;
				LOC13 = 0;
				LOC13 = ((*s).owner == (*c).owner);
				if (!(LOC13)) goto LA14;
				LOC13 = ((*s).kind == ((NU8) 3));
				LA14: ;
				if (!LOC13) goto LA15;
				(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
				result = newsymnode_193338(s, (*n).info);
			}
			goto LA11;
			LA15: ;
			{
				NIM_BOOL LOC18;
				LOC18 = 0;
				LOC18 = contains_188829((&(*c).tobind), (*s).Sup.id);
				if (!LOC18) goto LA19;
				result = symchoice_423316((*c).c, n, s, ((NU8) 0));
			}
			goto LA11;
			LA19: ;
			{
				NIM_BOOL LOC22;
				LOC22 = 0;
				LOC22 = contains_188829((&(*c).tomixin), (*(*s).name).Sup.id);
				if (!LOC22) goto LA23;
				result = symchoice_423316((*c).c, n, s, ((NU8) 2));
			}
			goto LA11;
			LA23: ;
			{
				NIM_BOOL LOC26;
				LOC26 = 0;
				LOC26 = ((*s).owner == (*c).owner);
				if (!(LOC26)) goto LA27;
				LOC26 = (((*s).flags &(1<<((((NU8) 31))&31)))!=0);
				LA27: ;
				if (!LOC26) goto LA28;
				(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
				result = newsymnode_193338(s, (*n).info);
			}
			goto LA11;
			LA28: ;
			{
				result = semtemplsymbol_424011((*c).c, n, s);
			}
			LA11: ;
		}
		LA9: ;
	}
	break;
	case ((NU8) 55):
	{
		result = semtemplbody_423688(c, (*n).kindU.S6.sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 122):
	{
		result = sembindstmt_423421((*c).c, n, (&(*c).tobind));
	}
	break;
	case ((NU8) 123):
	{
		result = semmixinstmt_423521((*c).c, n, (&(*c).tomixin));
	}
	break;
	case ((NU8) 1):
	case ((NU8) 3) ... ((NU8) 23):
	{
	}
	break;
	case ((NU8) 92):
	{
		{
			NI i_425016;
			NI HEX3Atmp_426019;
			NI LOC37;
			NI res_426022;
			i_425016 = 0;
			HEX3Atmp_426019 = 0;
			LOC37 = 0;
			LOC37 = sonslen_194403(n);
			HEX3Atmp_426019 = (NI)(LOC37 - ((NI) 1));
			res_426022 = ((NI) 0);
			{
				while (1) {
					Tnode191813* it;
					if (!(res_426022 <= HEX3Atmp_426019)) goto LA39;
					i_425016 = res_426022;
					it = (*n).kindU.S6.sons->data[i_425016];
					{
						NI LOC42;
						LOC42 = 0;
						LOC42 = len_192097(it);
						if (!(LOC42 == ((NI) 2))) goto LA43;
						openscope_423693(c);
						asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[((NI) 0)]), semtemplbody_423688(c, (*it).kindU.S6.sons->data[((NI) 0)]));
						asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[((NI) 1)]), semtemplbody_423688(c, (*it).kindU.S6.sons->data[((NI) 1)]));
						closescope_423700(c);
					}
					goto LA40;
					LA43: ;
					{
						asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_425016]), semtemplbodyscope_423707(c, it));
					}
					LA40: ;
					res_426022 += ((NI) 1);
				} LA39: ;
			}
		}
	}
	break;
	case ((NU8) 96):
	{
		openscope_423693(c);
		{
			NI i_425416;
			NI HEX3Atmp_426027;
			NI LOC48;
			NI res_426030;
			i_425416 = 0;
			HEX3Atmp_426027 = 0;
			LOC48 = 0;
			LOC48 = sonslen_194403(n);
			HEX3Atmp_426027 = (NI)(LOC48 - ((NI) 1));
			res_426030 = ((NI) 0);
			{
				while (1) {
					if (!(res_426030 <= HEX3Atmp_426027)) goto LA50;
					i_425416 = res_426030;
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_425416]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[i_425416]));
					res_426030 += ((NI) 1);
				} LA50: ;
			}
		}
		closescope_423700(c);
	}
	break;
	case ((NU8) 97):
	{
		openscope_423693(c);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[((NI) 0)]));
		{
			NI i_425433;
			NI HEX3Atmp_426043;
			NI LOC53;
			NI res_426046;
			i_425433 = 0;
			HEX3Atmp_426043 = 0;
			LOC53 = 0;
			LOC53 = sonslen_194403(n);
			HEX3Atmp_426043 = (NI)(LOC53 - ((NI) 1));
			res_426046 = ((NI) 1);
			{
				while (1) {
					Tnode191813* a;
					NI L;
					if (!(res_426046 <= HEX3Atmp_426043)) goto LA55;
					i_425433 = res_426046;
					a = (*n).kindU.S6.sons->data[i_425433];
					checkminsonslen_246259(a, ((NI) 1));
					L = sonslen_194403(a);
					{
						NI j_425449;
						NI HEX3Atmp_426036;
						NI res_426039;
						j_425449 = 0;
						HEX3Atmp_426036 = 0;
						HEX3Atmp_426036 = (NI)(L - ((NI) 2));
						res_426039 = ((NI) 0);
						{
							while (1) {
								if (!(res_426039 <= HEX3Atmp_426036)) goto LA58;
								j_425449 = res_426039;
								asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[j_425449]), semtemplbody_423688(c, (*a).kindU.S6.sons->data[j_425449]));
								res_426039 += ((NI) 1);
							} LA58: ;
						}
					}
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), semtemplbodyscope_423707(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]));
					res_426046 += ((NI) 1);
				} LA55: ;
			}
		}
		closescope_423700(c);
	}
	break;
	case ((NU8) 94):
	case ((NU8) 95):
	{
		NI L;
		L = sonslen_194403(n);
		openscope_423693(c);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[(NI)(L - ((NI) 2))]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[(NI)(L - ((NI) 2))]));
		{
			NI i_425469;
			NI HEX3Atmp_426051;
			NI res_426054;
			i_425469 = 0;
			HEX3Atmp_426051 = 0;
			HEX3Atmp_426051 = (NI)(L - ((NI) 3));
			res_426054 = ((NI) 0);
			{
				while (1) {
					if (!(res_426054 <= HEX3Atmp_426051)) goto LA62;
					i_425469 = res_426054;
					addlocaldecl_423875(c, &(*n).kindU.S6.sons->data[i_425469], ((NU8) 21));
					res_426054 += ((NI) 1);
				} LA62: ;
			}
		}
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[(NI)(L - ((NI) 1))]));
		closescope_423700(c);
	}
	break;
	case ((NU8) 112):
	case ((NU8) 127):
	case ((NU8) 129):
	{
		checksonslen_246249(n, ((NI) 2));
		openscope_423693(c);
		{
			Tsym191843* s;
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA66;
			s = newgensym_423843(((NU8) 22), (*n).kindU.S6.sons->data[((NI) 0)], c);
			addprelimdecl_250619((*c).c, s);
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(s, (*(*n).kindU.S6.sons->data[((NI) 0)]).info));
		}
		LA66: ;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[((NI) 1)]));
		closescope_423700(c);
	}
	break;
	case ((NU8) 106):
	{
		checkminsonslen_246259(n, ((NI) 2));
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semtemplbodyscope_423707(c, (*n).kindU.S6.sons->data[((NI) 0)]));
		{
			NI i_425619;
			NI HEX3Atmp_426067;
			NI LOC70;
			NI res_426070;
			i_425619 = 0;
			HEX3Atmp_426067 = 0;
			LOC70 = 0;
			LOC70 = sonslen_194403(n);
			HEX3Atmp_426067 = (NI)(LOC70 - ((NI) 1));
			res_426070 = ((NI) 1);
			{
				while (1) {
					Tnode191813* a;
					NI L;
					if (!(res_426070 <= HEX3Atmp_426067)) goto LA72;
					i_425619 = res_426070;
					a = (*n).kindU.S6.sons->data[i_425619];
					checkminsonslen_246259(a, ((NI) 1));
					L = sonslen_194403(a);
					{
						NI j_425635;
						NI HEX3Atmp_426060;
						NI res_426063;
						j_425635 = 0;
						HEX3Atmp_426060 = 0;
						HEX3Atmp_426060 = (NI)(L - ((NI) 2));
						res_426063 = ((NI) 0);
						{
							while (1) {
								if (!(res_426063 <= HEX3Atmp_426060)) goto LA75;
								j_425635 = res_426063;
								asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[j_425635]), semtemplbody_423688(c, (*a).kindU.S6.sons->data[j_425635]));
								res_426063 += ((NI) 1);
							} LA75: ;
						}
					}
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), semtemplbodyscope_423707(c, (*a).kindU.S6.sons->data[(NI)(L - ((NI) 1))]));
					res_426070 += ((NI) 1);
				} LA72: ;
			}
		}
	}
	break;
	case ((NU8) 99):
	{
		semtemplsomedecl_424438(c, n, ((NU8) 8), ((NI) 0));
	}
	break;
	case ((NU8) 100):
	{
		semtemplsomedecl_424438(c, n, ((NU8) 9), ((NI) 0));
	}
	break;
	case ((NU8) 76):
	{
		checkminsonslen_246259(n, ((NI) 1));
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[((NI) 0)]));
		semtemplsomedecl_424438(c, n, ((NU8) 3), ((NI) 1));
	}
	break;
	case ((NU8) 101):
	{
		{
			NI i_425654;
			NI HEX3Atmp_426076;
			NI LOC81;
			NI res_426079;
			i_425654 = 0;
			HEX3Atmp_426076 = 0;
			LOC81 = 0;
			LOC81 = sonslen_194403(n);
			HEX3Atmp_426076 = (NI)(LOC81 - ((NI) 1));
			res_426079 = ((NI) 0);
			{
				while (1) {
					if (!(res_426079 <= HEX3Atmp_426076)) goto LA83;
					i_425654 = res_426079;
					{
						Tnode191813* a;
						a = (*n).kindU.S6.sons->data[i_425654];
						{
							if (!((*a).kind == ((NU8) 125))) goto LA87;
							goto LA84;
						}
						LA87: ;
						{
							if (!!(((*a).kind == ((NU8) 102)))) goto LA91;
							illformedast_246229(a);
						}
						LA91: ;
						checksonslen_246249(a, ((NI) 3));
						addlocaldecl_423875(c, &(*a).kindU.S6.sons->data[((NI) 0)], ((NU8) 10));
						asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 1)]), semtemplbody_423688(c, (*a).kindU.S6.sons->data[((NI) 1)]));
						asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 2)]), semtemplbody_423688(c, (*a).kindU.S6.sons->data[((NI) 2)]));
					} LA84: ;
					res_426079 += ((NI) 1);
				} LA83: ;
			}
		}
	}
	break;
	case ((NU8) 98):
	{
		{
			NI i_425693;
			NI HEX3Atmp_426085;
			NI LOC95;
			NI res_426088;
			i_425693 = 0;
			HEX3Atmp_426085 = 0;
			LOC95 = 0;
			LOC95 = sonslen_194403(n);
			HEX3Atmp_426085 = (NI)(LOC95 - ((NI) 1));
			res_426088 = ((NI) 0);
			{
				while (1) {
					if (!(res_426088 <= HEX3Atmp_426085)) goto LA97;
					i_425693 = res_426088;
					{
						Tnode191813* a;
						a = (*n).kindU.S6.sons->data[i_425693];
						{
							if (!((*a).kind == ((NU8) 125))) goto LA101;
							goto LA98;
						}
						LA101: ;
						{
							if (!!(((*a).kind == ((NU8) 103)))) goto LA105;
							illformedast_246229(a);
						}
						LA105: ;
						checksonslen_246249(a, ((NI) 3));
						addlocaldecl_423875(c, &(*a).kindU.S6.sons->data[((NI) 0)], ((NU8) 7));
					} LA98: ;
					res_426088 += ((NI) 1);
				} LA97: ;
			}
		}
		{
			NI i_425728;
			NI HEX3Atmp_426094;
			NI LOC108;
			NI res_426097;
			i_425728 = 0;
			HEX3Atmp_426094 = 0;
			LOC108 = 0;
			LOC108 = sonslen_194403(n);
			HEX3Atmp_426094 = (NI)(LOC108 - ((NI) 1));
			res_426097 = ((NI) 0);
			{
				while (1) {
					if (!(res_426097 <= HEX3Atmp_426094)) goto LA110;
					i_425728 = res_426097;
					{
						Tnode191813* a;
						a = (*n).kindU.S6.sons->data[i_425728];
						{
							if (!((*a).kind == ((NU8) 125))) goto LA114;
							goto LA111;
						}
						LA114: ;
						{
							if (!!(((*a).kind == ((NU8) 103)))) goto LA118;
							illformedast_246229(a);
						}
						LA118: ;
						checksonslen_246249(a, ((NI) 3));
						{
							if (!!(((*(*a).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1)))) goto LA122;
							openscope_423693(c);
							asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 1)]), semtemplbody_423688(c, (*a).kindU.S6.sons->data[((NI) 1)]));
							asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 2)]), semtemplbody_423688(c, (*a).kindU.S6.sons->data[((NI) 2)]));
							closescope_423700(c);
						}
						goto LA120;
						LA122: ;
						{
							asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 2)]), semtemplbody_423688(c, (*a).kindU.S6.sons->data[((NI) 2)]));
						}
						LA120: ;
					} LA111: ;
					res_426097 += ((NI) 1);
				} LA110: ;
			}
		}
	}
	break;
	case ((NU8) 79):
	case ((NU8) 51):
	case ((NU8) 52):
	{
		result = semroutineintemplbody_424236(c, n, ((NU8) 12));
	}
	break;
	case ((NU8) 80):
	{
		result = semroutineintemplbody_424236(c, n, ((NU8) 13));
	}
	break;
	case ((NU8) 84):
	{
		NU8 kind;
		{
			Tnode191813* LOC130;
			NIM_BOOL LOC131;
			LOC130 = 0;
			LOC130 = HEX5BHEX5D_192244(n, ((NI) 4));
			LOC131 = 0;
			LOC131 = haspragma_264698(LOC130, ((NU16) 137));
			if (!LOC131) goto LA132;
			kind = ((NU8) 15);
		}
		goto LA128;
		LA132: ;
		{
			kind = ((NU8) 14);
		}
		LA128: ;
		result = semroutineintemplbody_424236(c, n, kind);
	}
	break;
	case ((NU8) 83):
	{
		result = semroutineintemplbody_424236(c, n, ((NU8) 18));
	}
	break;
	case ((NU8) 82):
	{
		result = semroutineintemplbody_424236(c, n, ((NU8) 17));
	}
	break;
	case ((NU8) 81):
	{
		result = semroutineintemplbody_424236(c, n, ((NU8) 16));
	}
	break;
	case ((NU8) 43):
	{
		asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[((NI) 0)]));
	}
	break;
	case ((NU8) 31):
	{
		asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[((NI) 1)]));
	}
	break;
	case ((NU8) 90):
	{
		result = onlyreplaceparams_423716(c, n);
	}
	break;
	default:
	{
		{
			NIM_BOOL LOC144;
			Tsym191843* s;
			LOC144 = 0;
			LOC144 = ((*n).kind == ((NU8) 45));
			if (LOC144) goto LA145;
			LOC144 = ((*n).kind == ((NU8) 53));
			LA145: ;
			if (!LOC144) goto LA146;
			s = qualifiedlookup_250864((*c).c, n, 0);
			{
				if (!!((s == NIM_NIL))) goto LA150;
				{
					NIM_BOOL LOC154;
					NIM_BOOL LOC155;
					NIM_BOOL LOC156;
					NI LOC160;
					LOC154 = 0;
					LOC155 = 0;
					LOC156 = 0;
					LOC156 = ((*s).owner == (*c).owner);
					if (!(LOC156)) goto LA157;
					LOC156 = ((*s).kind == ((NU8) 3));
					LA157: ;
					LOC155 = LOC156;
					if (!(LOC155)) goto LA158;
					LOC155 = ((*n).kind == ((NU8) 53));
					LA158: ;
					LOC154 = LOC155;
					if (!(LOC154)) goto LA159;
					LOC160 = 0;
					LOC160 = len_192097(n);
					LOC154 = (LOC160 == ((NI) 1));
					LA159: ;
					if (!LOC154) goto LA161;
					(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
					result = newsymnode_193338(s, (*n).info);
					goto BeforeRet;
				}
				goto LA152;
				LA161: ;
				{
					NIM_BOOL LOC164;
					LOC164 = 0;
					LOC164 = contains_188829((&(*c).tobind), (*s).Sup.id);
					if (!LOC164) goto LA165;
					result = symchoice_423316((*c).c, n, s, ((NU8) 0));
					goto BeforeRet;
				}
				goto LA152;
				LA165: ;
				{
					NIM_BOOL LOC168;
					LOC168 = 0;
					LOC168 = contains_188829((&(*c).tomixin), (*(*s).name).Sup.id);
					if (!LOC168) goto LA169;
					result = symchoice_423316((*c).c, n, s, ((NU8) 2));
					goto BeforeRet;
				}
				goto LA152;
				LA169: ;
				{
					result = symchoice_423316((*c).c, n, s, ((NU8) 1));
					goto BeforeRet;
				}
				LA152: ;
			}
			LA150: ;
		}
		LA146: ;
		result = n;
		{
			NI i_426015;
			NI HEX3Atmp_426102;
			NI LOC173;
			NI res_426105;
			i_426015 = 0;
			HEX3Atmp_426102 = 0;
			LOC173 = 0;
			LOC173 = sonslen_194403(n);
			HEX3Atmp_426102 = (NI)(LOC173 - ((NI) 1));
			res_426105 = ((NI) 0);
			{
				while (1) {
					if (!(res_426105 <= HEX3Atmp_426102)) goto LA175;
					i_426015 = res_426105;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_426015]), semtemplbody_423688(c, (*n).kindU.S6.sons->data[i_426015]));
					res_426105 += ((NI) 1);
				} LA175: ;
			}
		}
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, transformtoexpr_426509)(Tnode191813* n) {
	Tnode191813* result;
	NI realstmt;
	result = 0;
	realstmt = 0;
	result = n;
	switch ((*n).kind) {
	case ((NU8) 115):
	{
		realstmt = ((NI) -1);
		{
			NI i_426526;
			NI HEX3Atmp_426531;
			NI LOC3;
			NI res_426534;
			i_426526 = 0;
			HEX3Atmp_426531 = 0;
			LOC3 = 0;
			LOC3 = sonslen_194403(n);
			HEX3Atmp_426531 = (NI)(LOC3 - ((NI) 1));
			res_426534 = ((NI) 0);
			{
				while (1) {
					if (!(res_426534 <= HEX3Atmp_426531)) goto LA5;
					i_426526 = res_426534;
					switch ((*(*n).kindU.S6.sons->data[i_426526]).kind) {
					case ((NU8) 125):
					case ((NU8) 1):
					case ((NU8) 23):
					{
					}
					break;
					default:
					{
						{
							if (!(realstmt == ((NI) -1))) goto LA10;
							realstmt = i_426526;
						}
						goto LA8;
						LA10: ;
						{
							realstmt = ((NI) -2);
						}
						LA8: ;
					}
					break;
					}
					res_426534 += ((NI) 1);
				} LA5: ;
			}
		}
		{
			if (!(((NI) 0) <= realstmt)) goto LA15;
			result = transformtoexpr_426509((*n).kindU.S6.sons->data[realstmt]);
		}
		goto LA13;
		LA15: ;
		{
			(*n).kind = ((NU8) 126);
		}
		LA13: ;
	}
	break;
	case ((NU8) 112):
	{
		(*n).kind = ((NU8) 127);
	}
	break;
	default:
	{
	}
	break;
	}
	return result;
}

N_NIMCALL(Tnode191813*, semtemplatedef_426550)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tsym191843* s;
	Tscope191837* LOC6;
	Tnode191813* gp;
	Templctx423582 ctx;
	Tsym191843* proto;
	result = 0;
	s = 0;
	{
		if (!((*(*(*c).p).owner).kind == ((NU8) 6))) goto LA3;
		s = semidentvis_410955(c, ((NU8) 18), (*n).kindU.S6.sons->data[((NI) 0)], 2);
		(*s).flags |= ((NI32)1)<<((((NU8) 3))%(sizeof(NI32)*8));
	}
	goto LA1;
	LA3: ;
	{
		s = semidentvis_410955(c, ((NU8) 18), (*n).kindU.S6.sons->data[((NI) 0)], 0);
	}
	LA1: ;
	pushowner_245260(s);
	LOC6 = 0;
	LOC6 = openscope_250091(c);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(s, (*(*n).kindU.S6.sons->data[((NI) 0)]).info));
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 4)]).kind == ((NU8) 1)))) goto LA9;
		pragma_261069(c, s, (*n).kindU.S6.sons->data[((NI) 4)], TMP3410);
	}
	LA9: ;
	gp = 0;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1)))) goto LA13;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), semgenericparamlist_422951(c, (*n).kindU.S6.sons->data[((NI) 2)], NIM_NIL));
		gp = (*n).kindU.S6.sons->data[((NI) 2)];
	}
	goto LA11;
	LA13: ;
	{
		gp = newnodei_193351(((NU8) 75), (*n).info);
	}
	LA11: ;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 3)]).kind == ((NU8) 1)))) goto LA18;
		semparamlist_410284(c, (*n).kindU.S6.sons->data[((NI) 3)], gp, s);
		{
			NI i_426651;
			NI HEX3Atmp_426850;
			NI LOC21;
			NI res_426853;
			i_426651 = 0;
			HEX3Atmp_426850 = 0;
			LOC21 = 0;
			LOC21 = len_192097((*(*s).typ).n);
			HEX3Atmp_426850 = (NI)(LOC21 - ((NI) 1));
			res_426853 = ((NI) 1);
			{
				while (1) {
					if (!(res_426853 <= HEX3Atmp_426850)) goto LA23;
					i_426651 = res_426853;
					(*(*(*(*(*s).typ).n).kindU.S6.sons->data[i_426651]).kindU.S4.sym).flags &= ~(((NI32)1) << ((((NU8) 31)) % (sizeof(NI32)*8)));
					res_426853 += ((NI) 1);
				} LA23: ;
			}
		}
		{
			NI LOC26;
			LOC26 = 0;
			LOC26 = sonslen_194403(gp);
			if (!(((NI) 0) < LOC26)) goto LA27;
			{
				if (!((*(*n).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1))) goto LA31;
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), gp);
			}
			LA31: ;
		}
		LA27: ;
		{
			if (!((*(*(*n).kindU.S6.sons->data[((NI) 3)]).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1))) goto LA35;
			asgnRefNoCycle((void**) (&(*(*s).typ).sons->data[((NI) 0)]), newtypes_245218(((NU8) 7), c));
			asgnRefNoCycle((void**) (&(*(*(*s).typ).n).kindU.S6.sons->data[((NI) 0)]), newnodeit_193807(((NU8) 4), (*n).info, (*(*s).typ).sons->data[((NI) 0)]));
		}
		LA35: ;
	}
	goto LA16;
	LA18: ;
	{
		Ttype191849* LOC38;
		Tnode191813* LOC39;
		asgnRefNoCycle((void**) (&(*s).typ), newtypes_245218(((NU8) 25), c));
		asgnRefNoCycle((void**) (&(*(*s).typ).n), newnodei_193351(((NU8) 76), (*n).info));
		LOC38 = 0;
		LOC38 = newtypes_245218(((NU8) 7), c);
		rawaddson_195478((*s).typ, LOC38);
		LOC39 = 0;
		LOC39 = newnodeit_193807(((NU8) 4), (*n).info, (*(*s).typ).sons->data[((NI) 0)]);
		addson_193819((*(*s).typ).n, LOC39);
	}
	LA16: ;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1)))) goto LA42;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), sempattern_424548(c, (*n).kindU.S6.sons->data[((NI) 1)]));
	}
	LA42: ;
	memset((void*)(&ctx), 0, sizeof(ctx));
	initintset_188927((&ctx.tobind));
	initintset_188927((&ctx.tomixin));
	initintset_188927((&ctx.toinject));
	ctx.c = c;
	ctx.owner = s;
	{
		if (!(((*s).flags &(1<<((((NU8) 9))&31)))!=0)) goto LA46;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), semtemplbodydirty_426220((&ctx), (*n).kindU.S6.sons->data[((NI) 6)]));
	}
	goto LA44;
	LA46: ;
	{
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), semtemplbody_423688((&ctx), (*n).kindU.S6.sons->data[((NI) 6)]));
	}
	LA44: ;
	{
		if (!!(((384 &(IL64(1)<<(((*(*(*s).typ).sons->data[((NI) 0)]).kind)&IL64(63))))!=0))) goto LA51;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), transformtoexpr_426509((*n).kindU.S6.sons->data[((NI) 6)]));
	}
	LA51: ;
	closescope_250111(c);
	popowner_245266();
	asgnRefNoCycle((void**) (&(*s).ast), n);
	result = n;
	{
		if (!((*(*n).kindU.S6.sons->data[((NI) 6)]).kind == ((NU8) 1))) goto LA55;
		localerror_166155((*n).info, ((NU16) 138), (*(*s).name).s);
	}
	LA55: ;
	proto = searchforproc_260278(c, (*c).currentscope, s);
	{
		if (!(proto == NIM_NIL)) goto LA59;
		addinterfaceoverloadablesymat_250746(c, (*c).currentscope, s);
	}
	goto LA57;
	LA59: ;
	{
		symtabreplace_203415((&(*(*c).currentscope).symbols), proto, s);
	}
	LA57: ;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1)))) goto LA64;
		(*c).patterns = (Tsymseq191815*) incrSeq(&((*c).patterns)->Sup, sizeof(Tsym191843*));
		asgnRefNoCycle((void**) (&(*c).patterns->data[(*c).patterns->Sup.len-1]), s);
	}
	LA64: ;
	return result;
}

N_NIMCALL(Tsym191843*, getmagicsym_448811)(NU16 magic) {
	Tsym191843* result;
	Tident168021* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = getident_168463(reprEnum(magic, (&NTI191529)));
	result = newsym_192655(((NU8) 12), LOC1, systemmodule_239019, gcodegenlineinfo_164959);
	(*result).magic = magic;
	return result;
}

N_NIMCALL(Tnode191813*, semquoteast_410334)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* doblk;
	NI LOC10;
	NimStringDesc* op;
	Tnodeseq191807* quotes;
	Tnodeseq191807* ids;
	Tsym191843* LOC28;
	Tsym191843* LOC29;
	Tnode191813* tmpl;
	Tnodeseq191807* LOC41;
	TY246103 LOC42;
	Tsym191843* LOC43;
	result = 0;
	{
		NIM_BOOL LOC3;
		NI LOC4;
		NI LOC6;
		NimStringDesc* LOC9;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = len_192097(n);
		LOC3 = (LOC4 == ((NI) 2));
		if (LOC3) goto LA5;
		LOC6 = 0;
		LOC6 = len_192097(n);
		LOC3 = (LOC6 == ((NI) 3));
		LA5: ;
		if (!!(LOC3)) goto LA7;
		LOC9 = 0;
		LOC9 = HEX24_166306(TMP3405);
		internalerror_166218(LOC9);
	}
	LA7: ;
	LOC10 = 0;
	{
		if (!NIM_FALSE) goto LA13;
		LOC10 = ((NI) -1);
	}
	goto LA11;
	LA13: ;
	{
		NI LOC16;
		LOC16 = 0;
		LOC16 = len_192097(n);
		LOC10 = (NI)(LOC16 + ((NI) -1));
	}
	LA11: ;
	doblk = HEX5BHEX5D_192244(n, LOC10);
	{
		NI LOC19;
		Tnode191813* LOC22;
		LOC19 = 0;
		LOC19 = len_192097(n);
		if (!(LOC19 == ((NI) 3))) goto LA20;
		LOC22 = 0;
		LOC22 = HEX5BHEX5D_192244(n, ((NI) 1));
		op = expectstring_448791(c, LOC22);
	}
	goto LA17;
	LA20: ;
	{
		op = copyString(((NimStringDesc*) &TMP3406));
	}
	LA17: ;
	quotes = newseq_449261(((NI) 1));
	ids = newseq_449261(((NI) 0));
	{
		if (!!(((*doblk).kind == ((NU8) 52)))) goto LA26;
		localerror_166155((*n).info, ((NU16) 188), ((NimStringDesc*) &TMP3407));
	}
	LA26: ;
	processquotations_449082(&(*doblk).kindU.S6.sons->data[((NI) 6)], op, (&quotes), (&ids));
	LOC28 = 0;
	LOC28 = getcurrowner_245255();
	LOC29 = 0;
	LOC29 = newanonsym_448826(((NU8) 18), (*n).info, LOC28);
	asgnRefNoCycle((void**) (&(*doblk).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(LOC29));
	{
		Tnode191813* LOC34;
		Tsym191843* LOC35;
		Tnode191813* LOC36;
		Tsym191843* LOC37;
		Tnode191813* LOC38;
		Tnode191813* LOC39;
		Tnode191813* LOC40;
		if (!(((NI) 0) < (ids ? ids->Sup.len : 0))) goto LA32;
		asgnRefNoCycle((void**) (&(*doblk).kindU.S6.sons->data[((NI) 3)]), newnodei_193351(((NU8) 76), (*n).info));
		LOC34 = 0;
		LOC34 = HEX5BHEX5D_192244(doblk, ((NI) 3));
		LOC35 = 0;
		LOC35 = getsyssym_239054(((NimStringDesc*) &TMP3408));
		LOC36 = 0;
		LOC36 = newsymnode_193325(LOC35);
		add_192164(LOC34, LOC36);
		LOC37 = 0;
		LOC37 = getsyssym_239054(((NimStringDesc*) &TMP3409));
		LOC38 = 0;
		LOC38 = newsymnode_193325(LOC37);
		ids = (Tnodeseq191807*) incrSeq(&(ids)->Sup, sizeof(Tnode191813*));
		asgnRefNoCycle((void**) (&ids->data[ids->Sup.len-1]), LOC38);
		ids = (Tnodeseq191807*) incrSeq(&(ids)->Sup, sizeof(Tnode191813*));
		asgnRefNoCycle((void**) (&ids->data[ids->Sup.len-1]), emptynode_192807);
		LOC39 = 0;
		LOC39 = HEX5BHEX5D_192244(doblk, ((NI) 3));
		LOC40 = 0;
		LOC40 = newnode_193607(((NU8) 35), (*n).info, ids, NIM_NIL);
		add_192164(LOC39, LOC40);
	}
	LA32: ;
	tmpl = semtemplatedef_426550(c, doblk);
	asgnRefNoCycle((void**) (&quotes->data[((NI) 0)]), HEX5BHEX5D_192244(tmpl, ((NI) 0)));
	LOC41 = 0;
	LOC41 = (Tnodeseq191807*) newSeq((&NTI191807), 2);
	memset((void*)LOC42, 0, sizeof(LOC42));
	LOC43 = 0;
	LOC43 = getmagicsym_448811(((NU16) 20));
	LOC42[0] = newsymnode_193325(LOC43);
	LOC42[1] = newnode_193607(((NU8) 27), (*n).info, quotes, NIM_NIL);
	asgnRefNoCycle((void**) (&LOC41->data[0]), LOC42[0]);
	asgnRefNoCycle((void**) (&LOC41->data[1]), LOC42[1]);
	result = newnode_193607(((NU8) 27), (*n).info, LOC41, NIM_NIL);
	result = semexpandtoast_448913(c, result);
	return result;
}

N_NIMCALL(Ttype191849*, createflowvar_449503)(Tcontext245023* c, Ttype191849* t, Tlineinfo164338 info) {
	Ttype191849* result;
	Tsym191843* LOC1;
	result = 0;
	result = newtype_194140(((NU8) 9), (*c).module);
	LOC1 = 0;
	LOC1 = getcompilerproc_239036(((NimStringDesc*) &TMP3413));
	addsonskipintlit_239731(result, (*LOC1).typ);
	addsonskipintlit_239731(result, t);
	result = instgenericcontainer_413151(c, info, result, NIM_FALSE);
	return result;
}

N_NIMCALL(Tsym191843*, instantiatecreateflowvarcall_449513)(Tcontext245023* c, Ttype191849* t, Tlineinfo164338 info) {
	Tsym191843* result;
	Tsym191843* sym;
	Tidtable191861 bindings;
	Tnode191813* LOC5;
	Tidobj168015* LOC6;
	TNimObject* LOC7;
	result = 0;
	sym = getcompilerproc_239036(((NimStringDesc*) &TMP3414));
	{
		if (!(sym == NIM_NIL)) goto LA3;
		localerror_166155(info, ((NU16) 64), ((NimStringDesc*) &TMP3414));
	}
	LA3: ;
	memset((void*)(&bindings), 0, sizeof(bindings));
	initidtable_195057((&bindings));
	LOC5 = 0;
	LOC5 = HEX5BHEX5D_192244((*sym).ast, ((NI) 2));
	LOC6 = 0;
	LOC6 = &(*(*LOC5).kindU.S6.sons->data[((NI) 0)]).typ->Sup;
	LOC7 = 0;
	LOC7 = &t->Sup.Sup;
	idtableput_199196((&bindings), LOC6, LOC7);
	result = (*c).semgenerateinstance.ClEnv? (*c).semgenerateinstance.ClPrc(c, sym, bindings, info, (*c).semgenerateinstance.ClEnv):((TMP3415)((*c).semgenerateinstance.ClPrc))(c, sym, bindings, info);
	{
		if (!(((*result).flags &(1<<((((NU8) 16))&31)))!=0)) goto LA10;
		(*result).flags = ((*result).flags & ~ 65632);
		asgnRefNoCycle((void**) (&(*result).loc.r), NIM_NIL);
	}
	LA10: ;
	return result;
}

N_NIMCALL(Tnode191813*, semmagic_449578)(Tcontext245023* c, Tnode191813* n, Tsym191843* s, NU16 flags) {
	Tnode191813* result;
	result = 0;
	result = n;
	switch ((*s).magic) {
	case ((NU16) 10):
	{
		checksonslen_246249(n, ((NI) 2));
		result = semaddr_445049(c, (*n).kindU.S6.sons->data[((NI) 1)]);
	}
	break;
	case ((NU16) 11):
	{
		checksonslen_246249(n, ((NI) 2));
		result = semtypeof_445070(c, (*n).kindU.S6.sons->data[((NI) 1)]);
	}
	break;
	case ((NU16) 1):
	{
		Tnode191813* LOC4;
		LOC4 = 0;
		LOC4 = setms_449568(n, s);
		result = semdefined_448719(c, LOC4, NIM_FALSE);
	}
	break;
	case ((NU16) 2):
	{
		Tnode191813* LOC6;
		LOC6 = 0;
		LOC6 = setms_449568(n, s);
		result = semdefined_448719(c, LOC6, NIM_TRUE);
	}
	break;
	case ((NU16) 3):
	{
		Tnode191813* LOC8;
		LOC8 = 0;
		LOC8 = setms_449568(n, s);
		result = semcompiles_449463(c, LOC8, flags);
	}
	break;
	case ((NU16) 4):
	{
		Tnode191813* LOC10;
		LOC10 = 0;
		LOC10 = setms_449568(n, s);
		result = semlowhigh_443647(c, LOC10, ((NU16) 4));
	}
	break;
	case ((NU16) 5):
	{
		Tnode191813* LOC12;
		LOC12 = 0;
		LOC12 = setms_449568(n, s);
		result = semlowhigh_443647(c, LOC12, ((NU16) 5));
	}
	break;
	case ((NU16) 6):
	{
		Tnode191813* LOC14;
		LOC14 = 0;
		LOC14 = setms_449568(n, s);
		result = semsizeof_443694(c, LOC14);
	}
	break;
	case ((NU16) 8):
	{
		Tnode191813* LOC16;
		LOC16 = 0;
		LOC16 = setms_449568(n, s);
		result = semis_443917(c, LOC16);
	}
	break;
	case ((NU16) 9):
	{
		Tnode191813* LOC18;
		LOC18 = 0;
		LOC18 = setms_449568(n, s);
		result = semof_443705(c, LOC18);
	}
	break;
	case ((NU16) 15):
	{
		result = semshallowcopy_445277(c, n, flags);
	}
	break;
	case ((NU16) 20):
	{
		result = semexpandtoast_449069(c, n, s, flags);
	}
	break;
	case ((NU16) 21):
	{
		result = semquoteast_410334(c, n);
	}
	break;
	case ((NU16) 165):
	{
		Tnode191813* LOC23;
		NimStringDesc* LOC24;
		checksonslen_246249(n, ((NI) 2));
		LOC23 = 0;
		LOC23 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC24 = 0;
		LOC24 = rendertree_213058(LOC23, 4);
		result = newstrnodet_257042(LOC24, n);
		asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 28)));
	}
	break;
	case ((NU16) 166):
	{
		Tnode191813* x;
		result = setms_449568(n, s);
		x = lastson_194431(n);
		{
			if (!((*x).kind == ((NU8) 52))) goto LA28;
			x = (*x).kindU.S6.sons->data[((NI) 6)];
		}
		LA28: ;
		(*c).inparallelstmt += ((NI) 1);
		asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), semstmt_410277(c, x));
		(*c).inparallelstmt -= ((NI) 1);
	}
	break;
	case ((NU16) 213):
	{
		result = setms_449568(n, s);
		asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), semexpr_410201(c, (*n).kindU.S6.sons->data[((NI) 1)], 0));
		{
			Tnode191813* LOC33;
			NIM_BOOL LOC34;
			Tnode191813* LOC46;
			Tsym191843* LOC47;
			Tnode191813* LOC48;
			LOC33 = 0;
			LOC33 = HEX5BHEX5D_192244(result, ((NI) 1));
			LOC34 = 0;
			LOC34 = isemptytype_196934((*LOC33).typ);
			if (!!(LOC34)) goto LA35;
			{
				Tnode191813* LOC39;
				NU8 LOC40;
				Tnode191813* LOC43;
				LOC39 = 0;
				LOC39 = HEX5BHEX5D_192244(result, ((NI) 1));
				LOC40 = 0;
				LOC40 = spawnresult_359965((*LOC39).typ, (((NI) 0) < (*c).inparallelstmt));
				if (!(LOC40 == ((NU8) 1))) goto LA41;
				LOC43 = 0;
				LOC43 = HEX5BHEX5D_192244(result, ((NI) 1));
				asgnRefNoCycle((void**) (&(*result).typ), createflowvar_449503(c, (*LOC43).typ, (*n).info));
			}
			goto LA37;
			LA41: ;
			{
				Tnode191813* LOC45;
				LOC45 = 0;
				LOC45 = HEX5BHEX5D_192244(result, ((NI) 1));
				asgnRefNoCycle((void**) (&(*result).typ), (*LOC45).typ);
			}
			LA37: ;
			LOC46 = 0;
			LOC46 = HEX5BHEX5D_192244(result, ((NI) 1));
			LOC47 = 0;
			LOC47 = instantiatecreateflowvarcall_449513(c, (*LOC46).typ, (*n).info);
			LOC48 = 0;
			LOC48 = newsymnode_193325(LOC47);
			add_192164(result, LOC48);
		}
		LA35: ;
	}
	break;
	case ((NU16) 218):
	{
		Tnode191813* LOC50;
		result = setms_449568(n, s);
		asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), semexpr_410201(c, (*n).kindU.S6.sons->data[((NI) 1)], 0));
		LOC50 = 0;
		LOC50 = HEX5BHEX5D_192244(n, ((NI) 1));
		asgnRefNoCycle((void**) (&(*result).typ), (*LOC50).typ);
	}
	break;
	default:
	{
		result = semdirectop_411032(c, n, flags);
	}
	break;
	}
	return result;
}

N_NIMCALL(void, semopaux_443960)(Tcontext245023* c, Tnode191813* n) {
	{
		NI i_443979;
		NI HEX3Atmp_444000;
		NI LOC2;
		NI res_444003;
		i_443979 = 0;
		HEX3Atmp_444000 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_444000 = (NI)(LOC2 - ((NI) 1));
		res_444003 = ((NI) 1);
		{
			while (1) {
				Tnode191813* a;
				if (!(res_444003 <= HEX3Atmp_444000)) goto LA4;
				i_443979 = res_444003;
				a = (*n).kindU.S6.sons->data[i_443979];
				{
					NIM_BOOL LOC7;
					NI LOC9;
					Tlineinfo164338 info;
					Tident168021* LOC12;
					LOC7 = 0;
					LOC7 = ((*a).kind == ((NU8) 33));
					if (!(LOC7)) goto LA8;
					LOC9 = 0;
					LOC9 = sonslen_194403(a);
					LOC7 = (LOC9 == ((NI) 2));
					LA8: ;
					if (!LOC7) goto LA10;
					info = (*(*a).kindU.S6.sons->data[((NI) 0)]).info;
					LOC12 = 0;
					LOC12 = considerquotedident_250010((*a).kindU.S6.sons->data[((NI) 0)]);
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 0)]), newidentnode_193313(LOC12, info));
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 1)]), semexprwithtype_410211(c, (*a).kindU.S6.sons->data[((NI) 1)], 32));
					asgnRefNoCycle((void**) (&(*a).typ), (*(*a).kindU.S6.sons->data[((NI) 1)]).typ);
				}
				goto LA5;
				LA10: ;
				{
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_443979]), semexprwithtype_410211(c, a, 32));
				}
				LA5: ;
				res_444003 += ((NI) 1);
			} LA4: ;
		}
	}
}

N_NIMCALL(void, resolveindirectcall_446046)(Tcontext245023* c, Tnode191813* n, Tnode191813* norig, Ttype191849* t, Tcandidate345209* Result) {
	initcandidate_345276(c, Result, t);
	matches_351449(c, n, norig, Result);
	{
		if (!!(((*Result).state == ((NU8) 1)))) goto LA3;
		{
			NIM_BOOL LOC7;
			LOC7 = 0;
			LOC7 = experimentalmode_246279(c);
			if (!(LOC7)) goto LA8;
			LOC7 = canderef_415851(n);
			LA8: ;
			if (!LOC7) goto LA9;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), tryderef_415884((*n).kindU.S6.sons->data[((NI) 1)]));
			initcandidate_345276(c, Result, t);
			matches_351449(c, n, norig, Result);
		}
		LA9: ;
	}
	LA3: ;
}

N_NIMCALL(Tnode191813*, overloadedcallopr_444019)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tident168021* par;
	result = 0;
	par = getident_168463(((NimStringDesc*) &TMP3106));
	{
		Tsym191843* LOC3;
		LOC3 = 0;
		LOC3 = searchinscopes_250205(c, par);
		if (!(LOC3 == NIM_NIL)) goto LA4;
		result = NIM_NIL;
	}
	goto LA1;
	LA4: ;
	{
		Tnode191813* LOC7;
		result = newnodei_193351(((NU8) 27), (*n).info);
		LOC7 = 0;
		LOC7 = newidentnode_193313(par, (*n).info);
		addson_193819(result, LOC7);
		{
			NI i_444049;
			NI HEX3Atmp_444052;
			NI LOC9;
			NI res_444055;
			i_444049 = 0;
			HEX3Atmp_444052 = 0;
			LOC9 = 0;
			LOC9 = sonslen_194403(n);
			HEX3Atmp_444052 = (NI)(LOC9 - ((NI) 1));
			res_444055 = ((NI) 0);
			{
				while (1) {
					if (!(res_444055 <= HEX3Atmp_444052)) goto LA11;
					i_444049 = res_444055;
					addson_193819(result, (*n).kindU.S6.sons->data[i_444049]);
					res_444055 += ((NI) 1);
				} LA11: ;
			}
		}
		result = semexpr_410201(c, result, 0);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semindirectop_446072)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Tnode191813* prc;
	Tnode191813* norig;
	Ttype191849* t;
{	result = 0;
	result = NIM_NIL;
	checkminsonslen_246259(n, ((NI) 1));
	prc = (*n).kindU.S6.sons->data[((NI) 0)];
	{
		if (!((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 45))) goto LA3;
		checksonslen_246249((*n).kindU.S6.sons->data[((NI) 0)], ((NI) 2));
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semfieldaccess_441814(c, (*n).kindU.S6.sons->data[((NI) 0)], 0));
		{
			if (!((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 25))) goto LA7;
			result = (*n).kindU.S6.sons->data[((NI) 0)];
			(*result).kind = ((NU8) 27);
			(*result).flags |= ((NI16)1)<<((((NU8) 10))%(sizeof(NI16)*8));
			{
				NI i_446126;
				NI HEX3Atmp_446330;
				NI LOC10;
				NI res_446333;
				i_446126 = 0;
				HEX3Atmp_446330 = 0;
				LOC10 = 0;
				LOC10 = sonslen_194403(n);
				HEX3Atmp_446330 = (NI)(LOC10 - ((NI) 1));
				res_446333 = ((NI) 1);
				{
					while (1) {
						if (!(res_446333 <= HEX3Atmp_446330)) goto LA12;
						i_446126 = res_446333;
						addson_193819(result, (*n).kindU.S6.sons->data[i_446126]);
						res_446333 += ((NI) 1);
					} LA12: ;
				}
			}
			result = semexpr_410201(c, result, flags);
			goto BeforeRet;
		}
		LA7: ;
	}
	goto LA1;
	LA3: ;
	{
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexpr_410201(c, (*n).kindU.S6.sons->data[((NI) 0)], 0));
	}
	LA1: ;
	norig = copytree_196028(n);
	semopaux_443960(c, n);
	t = NIM_NIL;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).typ == NIM_NIL))) goto LA16;
		t = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 0)]).typ, IL64(211106232576000));
	}
	LA16: ;
	{
		NIM_BOOL LOC20;
		Tcandidate345209 m;
		LOC20 = 0;
		LOC20 = !((t == NIM_NIL));
		if (!(LOC20)) goto LA21;
		LOC20 = ((*t).kind == ((NU8) 25));
		LA21: ;
		if (!LOC20) goto LA22;
		memset((void*)(&m), 0, sizeof(m));
		chckNil((void*)(&m));
		memset((void*)(&m), 0, sizeof(m));
		resolveindirectcall_446046(c, n, norig, t, (&m));
		{
			if (!!((m.state == ((NU8) 1)))) goto LA26;
			{
				if (!(((NI) 0) < (*c).incompilescontext)) goto LA30;
				globalerror_166134((*n).info, ((NU16) 129), ((NimStringDesc*) &TMP2991));
				result = emptynode_192807;
				goto BeforeRet;
			}
			goto LA28;
			LA30: ;
			{
				NIM_BOOL haserrortype;
				NimStringDesc* msg;
				haserrortype = NIM_FALSE;
				msg = msgkindtostring_165616(((NU16) 129));
				{
					NI i_446205;
					NI HEX3Atmp_446339;
					NI LOC34;
					NI res_446342;
					i_446205 = 0;
					HEX3Atmp_446339 = 0;
					LOC34 = 0;
					LOC34 = sonslen_194403(n);
					HEX3Atmp_446339 = (NI)(LOC34 - ((NI) 1));
					res_446342 = ((NI) 1);
					{
						while (1) {
							Ttype191849* nt;
							NimStringDesc* LOC41;
							if (!(res_446342 <= HEX3Atmp_446339)) goto LA36;
							i_446205 = res_446342;
							{
								if (!(((NI) 1) < i_446205)) goto LA39;
								msg = resizeString(msg, 2);
appendString(msg, ((NimStringDesc*) &TMP3359));
							}
							LA39: ;
							nt = (*(*n).kindU.S6.sons->data[i_446205]).typ;
							LOC41 = 0;
							LOC41 = typetostring_221032(nt, ((NU8) 0));
							msg = resizeString(msg, LOC41->Sup.len + 0);
appendString(msg, LOC41);
							{
								if (!((*nt).kind == ((NU8) 50))) goto LA44;
								haserrortype = NIM_TRUE;
								goto LA33;
							}
							LA44: ;
							res_446342 += ((NI) 1);
						} LA36: ;
					}
				} LA33: ;
				{
					NimStringDesc* LOC50;
					NimStringDesc* LOC51;
					NimStringDesc* LOC52;
					if (!!(haserrortype)) goto LA48;
					LOC50 = 0;
					LOC51 = 0;
					LOC51 = msgkindtostring_165616(((NU16) 130));
					LOC52 = 0;
					LOC52 = typetostring_221032((*(*n).kindU.S6.sons->data[((NI) 0)]).typ, ((NU8) 0));
					LOC50 = rawNewString(LOC51->Sup.len + LOC52->Sup.len + 3);
appendString(LOC50, ((NimStringDesc*) &TMP3416));
appendString(LOC50, LOC51);
appendString(LOC50, ((NimStringDesc*) &TMP3361));
appendString(LOC50, LOC52);
					msg = resizeString(msg, LOC50->Sup.len + 0);
appendString(msg, LOC50);
					localerror_166155((*n).info, ((NU16) 4), msg);
				}
				LA48: ;
				result = errornode_246160(c, n);
				goto BeforeRet;
			}
			LA28: ;
			result = NIM_NIL;
		}
		goto LA24;
		LA26: ;
		{
			result = m.call;
			instgenericconverterssons_415212(c, result, (&m));
		}
		LA24: ;
		{
			if (!!((((*t).flags &(1<<((((NU8) 1))&31)))!=0))) goto LA56;
			(*(*(*c).p).owner).flags |= ((NI32)1)<<((((NU8) 11))%(sizeof(NI32)*8));
		}
		LA56: ;
	}
	goto LA18;
	LA22: ;
	{
		NIM_BOOL LOC59;
		LOC59 = 0;
		LOC59 = !((t == NIM_NIL));
		if (!(LOC59)) goto LA60;
		LOC59 = ((*t).kind == ((NU8) 8));
		LA60: ;
		if (!LOC59) goto LA61;
		{
			NI LOC65;
			LOC65 = 0;
			LOC65 = len_192097(n);
			if (!(LOC65 == ((NI) 1))) goto LA66;
			result = semobjconstr_446041(c, n, flags);
			goto BeforeRet;
		}
		LA66: ;
		result = semconv_443510(c, n);
		goto BeforeRet;
	}
	goto LA18;
	LA61: ;
	{
		result = overloadedcallopr_444019(c, n);
		{
			if (!(result == NIM_NIL)) goto LA71;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), prc);
			asgnRefNoCycle((void**) (&(*norig).kindU.S6.sons->data[((NI) 0)]), prc);
			(*n).flags |= ((NI16)1)<<((((NU8) 11))%(sizeof(NI16)*8));
			result = semoverloadedcallanalyseeffects_445901(c, n, norig, flags);
			{
				if (!(result == NIM_NIL)) goto LA75;
				result = errornode_246160(c, n);
				goto BeforeRet;
			}
			LA75: ;
		}
		goto LA69;
		LA71: ;
		{
			if (!!(((*result).kind == ((NU8) 27) || (*result).kind == ((NU8) 29) || (*result).kind == ((NU8) 30) || (*result).kind == ((NU8) 31) || (*result).kind == ((NU8) 26) || (*result).kind == ((NU8) 28) || (*result).kind == ((NU8) 32)))) goto LA78;
			goto BeforeRet;
		}
		goto LA69;
		LA78: ;
		LA69: ;
	}
	LA18: ;
	fixabstracttype_444407(c, result);
	analyseifaddresstakenincall_444851(c, result);
	{
		NIM_BOOL LOC82;
		LOC82 = 0;
		LOC82 = ((*(*result).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3));
		if (!(LOC82)) goto LA83;
		LOC82 = !(((*(*(*result).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).magic == ((NU16) 0)));
		LA83: ;
		if (!LOC82) goto LA84;
		result = magicsafteroverloadresolution_445354(c, result, flags);
	}
	LA84: ;
	result = evalatcompiletime_445429(c, result);
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, setgenericparams_451037)(Tcontext245023* c, Tnode191813* n) {
	{
		NI i_451060;
		NI HEX3Atmp_451062;
		NI LOC2;
		NI res_451065;
		i_451060 = 0;
		HEX3Atmp_451062 = 0;
		LOC2 = 0;
		LOC2 = len_192097(n);
		HEX3Atmp_451062 = (LOC2 - 1);
		res_451065 = ((NI) 1);
		{
			while (1) {
				Tnode191813* LOC5;
				Tnode191813* LOC6;
				if (!(res_451065 <= HEX3Atmp_451062)) goto LA4;
				i_451060 = res_451065;
				LOC5 = 0;
				LOC5 = HEX5BHEX5D_192244(n, i_451060);
				LOC6 = 0;
				LOC6 = HEX5BHEX5D_192244(n, i_451060);
				asgnRefNoCycle((void**) (&(*LOC5).typ), semtypenode_410269(c, LOC6, NIM_NIL));
				res_451065 += ((NI) 1);
			} LA4: ;
		}
	}
}

N_NIMCALL(Tnode191813*, semsymgenericinstantiation_442019)(Tcontext245023* c, Tnode191813* n, Tsym191843* s) {
	Tnode191813* result;
	result = 0;
	result = symchoice_423316(c, n, s, ((NU8) 0));
	return result;
}

N_NIMCALL(Tnode191813*, explicitgenericsym_415939)(Tcontext245023* c, Tnode191813* n, Tsym191843* s) {
	Tnode191813* result;
	Tcandidate345209 m;
	Tsym191843* newinst;
	result = 0;
	memset((void*)(&m), 0, sizeof(m));
	initcandidate_345301(c, (&m), s, n, ((NI) -1));
	newinst = generateinstance_413450(c, s, m.bindings, (*n).info);
	markused_345251((*n).info, s);
	result = newsymnode_193338(newinst, (*n).info);
	return result;
}

N_NIMCALL(Tnode191813*, explicitgenericinsterror_415932)(Tnode191813* n) {
	Tnode191813* result;
	NimStringDesc* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = rendertree_213058(n, 0);
	localerror_166155((*n).info, ((NU16) 124), LOC1);
	result = n;
	return result;
}

N_NIMCALL(Tnode191813*, explicitgenericinstantiation_416005)(Tcontext245023* c, Tnode191813* n, Tsym191843* s_416009) {
	Tnode191813* result;
	Tsym191843* s;
	Tnode191813* a;
{	result = 0;
	{
		NI i_416211;
		NI HEX3Atmp_416286;
		NI LOC2;
		NI res_416289;
		i_416211 = 0;
		HEX3Atmp_416286 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_416286 = (NI)(LOC2 - ((NI) 1));
		res_416289 = ((NI) 1);
		{
			while (1) {
				if (!(res_416289 <= HEX3Atmp_416286)) goto LA4;
				i_416211 = res_416289;
				asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[i_416211]).typ), semtypenode_410269(c, (*n).kindU.S6.sons->data[i_416211], NIM_NIL));
				res_416289 += ((NI) 1);
			} LA4: ;
		}
	}
	s = s_416009;
	a = (*n).kindU.S6.sons->data[((NI) 0)];
	{
		if (!((*a).kind == ((NU8) 3))) goto LA7;
		{
			NI LOC11;
			NI LOC12;
			NI expected;
			NimStringDesc* LOC15;
			NimStringDesc* LOC16;
			NI LOC17;
			NimStringDesc* LOC18;
			NimStringDesc* LOC19;
			LOC11 = 0;
			LOC11 = safelen_192125((*(*s).ast).kindU.S6.sons->data[((NI) 2)]);
			LOC12 = 0;
			LOC12 = len_192097(n);
			if (!!((LOC11 == (NI)(LOC12 - ((NI) 1))))) goto LA13;
			expected = safelen_192125((*(*s).ast).kindU.S6.sons->data[((NI) 2)]);
			LOC15 = 0;
			LOC16 = 0;
			LOC16 = rendertree_213058(n, 0);
			LOC17 = 0;
			LOC17 = len_192097(n);
			LOC18 = 0;
			LOC18 = nimIntToStr((NI)(LOC17 - ((NI) 1)));
			LOC19 = 0;
			LOC19 = nimIntToStr(expected);
			LOC15 = rawNewString(LOC16->Sup.len + LOC18->Sup.len + LOC19->Sup.len + 48);
appendString(LOC15, ((NimStringDesc*) &TMP3417));
appendString(LOC15, LOC16);
appendString(LOC15, ((NimStringDesc*) &TMP3418));
appendString(LOC15, LOC18);
appendString(LOC15, ((NimStringDesc*) &TMP3419));
appendString(LOC15, LOC19);
			localerror_166155((*n).info, ((NU16) 4), LOC15);
			result = n;
			goto BeforeRet;
		}
		LA13: ;
		result = explicitgenericsym_415939(c, n, s);
	}
	goto LA5;
	LA7: ;
	{
		if (!((*a).kind == ((NU8) 56) || (*a).kind == ((NU8) 57))) goto LA21;
		result = newnodei_193351((*a).kind, (*n).info);
		{
			NI i_416256;
			NI HEX3Atmp_416294;
			NI LOC24;
			NI res_416297;
			i_416256 = 0;
			HEX3Atmp_416294 = 0;
			LOC24 = 0;
			LOC24 = len_192097(a);
			HEX3Atmp_416294 = (NI)(LOC24 - ((NI) 1));
			res_416297 = ((NI) 0);
			{
				while (1) {
					Tsym191843* candidate;
					if (!(res_416297 <= HEX3Atmp_416294)) goto LA26;
					i_416256 = res_416297;
					candidate = (*(*a).kindU.S6.sons->data[i_416256]).kindU.S4.sym;
					{
						if (!((126976 &(1<<(((*candidate).kind)&31)))!=0)) goto LA29;
						{
							NI LOC33;
							NI LOC34;
							Tnode191813* LOC37;
							LOC33 = 0;
							LOC33 = safelen_192125((*(*candidate).ast).kindU.S6.sons->data[((NI) 2)]);
							LOC34 = 0;
							LOC34 = len_192097(n);
							if (!(LOC33 == (NI)(LOC34 - ((NI) 1)))) goto LA35;
							LOC37 = 0;
							LOC37 = explicitgenericsym_415939(c, n, candidate);
							add_192164(result, LOC37);
						}
						LA35: ;
					}
					LA29: ;
					res_416297 += ((NI) 1);
				} LA26: ;
			}
		}
		{
			NIM_BOOL LOC40;
			NI LOC41;
			LOC40 = 0;
			LOC41 = 0;
			LOC41 = len_192097(result);
			LOC40 = (LOC41 == ((NI) 1));
			if (!(LOC40)) goto LA42;
			LOC40 = ((*a).kind == ((NU8) 56));
			LA42: ;
			if (!LOC40) goto LA43;
			result = HEX5BHEX5D_192244(result, ((NI) 0));
		}
		LA43: ;
	}
	goto LA5;
	LA21: ;
	{
		result = explicitgenericinsterror_415932(n);
	}
	LA5: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semarrayaccess_447898)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Tnode191813* oldbracketexpr;
	result = 0;
	oldbracketexpr = (*(*c).p).bracketexpr;
	result = semsubscript_447774(c, n, flags);
	{
		Tident168021* LOC5;
		Tnode191813* LOC6;
		if (!(result == NIM_NIL)) goto LA3;
		LOC5 = 0;
		LOC5 = getident_168463(((NimStringDesc*) &TMP3420));
		LOC6 = 0;
		LOC6 = buildoverloadedsubscripts_447722(n, LOC5);
		result = semexpr_410201(c, LOC6, 0);
	}
	LA3: ;
	asgnRefNoCycle((void**) (&(*(*c).p).bracketexpr), oldbracketexpr);
	return result;
}

N_NIMCALL(NU8, checkpar_449990)(Tnode191813* n) {
	NU8 result;
	NI length;
{	result = 0;
	length = sonslen_194403(n);
	{
		if (!(length == ((NI) 0))) goto LA3;
		result = ((NU8) 3);
	}
	goto LA1;
	LA3: ;
	{
		if (!(length == ((NI) 1))) goto LA6;
		{
			if (!((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 34))) goto LA10;
			result = ((NU8) 2);
		}
		goto LA8;
		LA10: ;
		{
			result = ((NU8) 1);
		}
		LA8: ;
	}
	goto LA1;
	LA6: ;
	{
		{
			if (!((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 34))) goto LA16;
			result = ((NU8) 2);
		}
		goto LA14;
		LA16: ;
		{
			result = ((NU8) 3);
		}
		LA14: ;
		{
			NI i_450027;
			NI HEX3Atmp_450073;
			NI res_450076;
			i_450027 = 0;
			HEX3Atmp_450073 = 0;
			HEX3Atmp_450073 = (NI)(length - ((NI) 1));
			res_450076 = ((NI) 0);
			{
				while (1) {
					if (!(res_450076 <= HEX3Atmp_450073)) goto LA21;
					i_450027 = res_450076;
					{
						if (!(result == ((NU8) 2))) goto LA24;
						{
							NIM_BOOL LOC28;
							LOC28 = 0;
							LOC28 = !(((*(*n).kindU.S6.sons->data[i_450027]).kind == ((NU8) 34)));
							if (LOC28) goto LA29;
							LOC28 = !(((*(*(*n).kindU.S6.sons->data[i_450027]).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3) || (*(*(*n).kindU.S6.sons->data[i_450027]).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 2)));
							LA29: ;
							if (!LOC28) goto LA30;
							localerror_166155((*(*n).kindU.S6.sons->data[i_450027]).info, ((NU16) 170), ((NimStringDesc*) &TMP2991));
							result = ((NU8) 0);
							goto BeforeRet;
						}
						LA30: ;
					}
					goto LA22;
					LA24: ;
					{
						{
							if (!((*(*n).kindU.S6.sons->data[i_450027]).kind == ((NU8) 34))) goto LA35;
							localerror_166155((*(*n).kindU.S6.sons->data[i_450027]).info, ((NU16) 171), ((NimStringDesc*) &TMP2991));
							result = ((NU8) 0);
							goto BeforeRet;
						}
						LA35: ;
					}
					LA22: ;
					res_450076 += ((NI) 1);
				} LA21: ;
			}
		}
	}
	LA1: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semtuplepositionsconstr_450204)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Ttype191849* typ;
	result = 0;
	result = n;
	typ = newtypes_245218(((NU8) 18), c);
	{
		NI i_450223;
		NI HEX3Atmp_450241;
		NI LOC2;
		NI res_450244;
		i_450223 = 0;
		HEX3Atmp_450241 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_450241 = (NI)(LOC2 - ((NI) 1));
		res_450244 = ((NI) 0);
		{
			while (1) {
				if (!(res_450244 <= HEX3Atmp_450241)) goto LA4;
				i_450223 = res_450244;
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_450223]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[i_450223], (flags & 64)));
				addsonskipintlit_239731(typ, (*(*n).kindU.S6.sons->data[i_450223]).typ);
				res_450244 += ((NI) 1);
			} LA4: ;
		}
	}
	asgnRefNoCycle((void**) (&(*result).typ), typ);
	return result;
}

N_NIMCALL(NIM_BOOL, istupletype_450260)(Tnode191813* n) {
	NIM_BOOL result;
{	result = 0;
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = len_192097(n);
		if (!(LOC3 == ((NI) 0))) goto LA4;
		result = NIM_FALSE;
		goto BeforeRet;
	}
	LA4: ;
	{
		NI i_450278;
		NI HEX3Atmp_450301;
		NI LOC7;
		NI res_450304;
		i_450278 = 0;
		HEX3Atmp_450301 = 0;
		LOC7 = 0;
		LOC7 = len_192097(n);
		HEX3Atmp_450301 = (NI)(LOC7 - ((NI) 1));
		res_450304 = ((NI) 0);
		{
			while (1) {
				if (!(res_450304 <= HEX3Atmp_450301)) goto LA9;
				i_450278 = res_450304;
				{
					NIM_BOOL LOC12;
					Tnode191813* LOC13;
					Tnode191813* LOC15;
					LOC12 = 0;
					LOC13 = 0;
					LOC13 = HEX5BHEX5D_192244(n, i_450278);
					LOC12 = ((*LOC13).typ == NIM_NIL);
					if (LOC12) goto LA14;
					LOC15 = 0;
					LOC15 = HEX5BHEX5D_192244(n, i_450278);
					LOC12 = !(((*(*LOC15).typ).kind == ((NU8) 8)));
					LA14: ;
					if (!LOC12) goto LA16;
					result = NIM_FALSE;
					goto BeforeRet;
				}
				LA16: ;
				res_450304 += ((NI) 1);
			} LA9: ;
		}
	}
	result = NIM_TRUE;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semtuplefieldsconstr_450092)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Ttype191849* typ;
	Intset188056 ids;
	result = 0;
	result = newnodei_193351(((NU8) 37), (*n).info);
	typ = newtypes_245218(((NU8) 18), c);
	asgnRefNoCycle((void**) (&(*typ).n), newnodei_193351(((NU8) 138), (*n).info));
	memset((void*)(&ids), 0, sizeof(ids));
	chckNil((void*)(&ids));
	memset((void*)(&ids), 0, sizeof(ids));
	initintset_188927((&ids));
	{
		NI i_450112;
		NI HEX3Atmp_450185;
		NI LOC2;
		NI res_450188;
		i_450112 = 0;
		HEX3Atmp_450185 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_450185 = (NI)(LOC2 - ((NI) 1));
		res_450188 = ((NI) 0);
		{
			while (1) {
				Tident168021* id;
				Tsym191843* f;
				Tnode191813* LOC24;
				if (!(res_450188 <= HEX3Atmp_450185)) goto LA4;
				i_450112 = res_450188;
				{
					NIM_BOOL LOC7;
					Tnode191813* LOC8;
					Tnode191813* LOC10;
					Tnode191813* LOC11;
					LOC7 = 0;
					LOC8 = 0;
					LOC8 = HEX5BHEX5D_192244(n, i_450112);
					LOC7 = !(((*LOC8).kind == ((NU8) 34)));
					if (LOC7) goto LA9;
					LOC10 = 0;
					LOC10 = HEX5BHEX5D_192244(n, i_450112);
					LOC11 = 0;
					LOC11 = HEX5BHEX5D_192244(LOC10, ((NI) 0));
					LOC7 = !(((*LOC11).kind == ((NU8) 3) || (*LOC11).kind == ((NU8) 2)));
					LA9: ;
					if (!LOC7) goto LA12;
					illformedast_246229((*n).kindU.S6.sons->data[i_450112]);
				}
				LA12: ;
				id = 0;
				{
					if (!((*(*(*n).kindU.S6.sons->data[i_450112]).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 2))) goto LA16;
					id = (*(*(*n).kindU.S6.sons->data[i_450112]).kindU.S6.sons->data[((NI) 0)]).kindU.S5.ident;
				}
				goto LA14;
				LA16: ;
				{
					id = (*(*(*(*n).kindU.S6.sons->data[i_450112]).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).name;
				}
				LA14: ;
				{
					NIM_BOOL LOC21;
					LOC21 = 0;
					LOC21 = containsorincl_188898((&ids), (*id).Sup.id);
					if (!LOC21) goto LA22;
					localerror_166155((*(*n).kindU.S6.sons->data[i_450112]).info, ((NU16) 86), (*id).s);
				}
				LA22: ;
				asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[i_450112]).kindU.S6.sons->data[((NI) 1)]), semexprwithtype_410211(c, (*(*n).kindU.S6.sons->data[i_450112]).kindU.S6.sons->data[((NI) 1)], (flags & 64)));
				f = newsyms_410904(((NU8) 19), (*(*n).kindU.S6.sons->data[i_450112]).kindU.S6.sons->data[((NI) 0)], c);
				asgnRefNoCycle((void**) (&(*f).typ), skipintlit_239698((*(*(*n).kindU.S6.sons->data[i_450112]).kindU.S6.sons->data[((NI) 1)]).typ));
				(*f).position = i_450112;
				rawaddson_195478(typ, (*f).typ);
				LOC24 = 0;
				LOC24 = newsymnode_193325(f);
				addson_193819((*typ).n, LOC24);
				asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[i_450112]).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(f));
				addson_193819(result, (*n).kindU.S6.sons->data[i_450112]);
				res_450188 += ((NI) 1);
			} LA4: ;
		}
	}
	asgnRefNoCycle((void**) (&(*result).typ), typ);
	return result;
}

N_NIMCALL(Tnode191813*, semsetconstr_449734)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = newnodei_193351(((NU8) 39), (*n).info);
	asgnRefNoCycle((void**) (&(*result).typ), newtypes_245218(((NU8) 19), c));
	{
		NI LOC3;
		Ttype191849* LOC6;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 0))) goto LA4;
		LOC6 = 0;
		LOC6 = newtypes_245218(((NU8) 3), c);
		rawaddson_195478((*result).typ, LOC6);
	}
	goto LA1;
	LA4: ;
	{
		Ttype191849* typ;
		typ = NIM_NIL;
		{
			NI i_449752;
			NI HEX3Atmp_449858;
			NI LOC9;
			NI res_449861;
			i_449752 = 0;
			HEX3Atmp_449858 = 0;
			LOC9 = 0;
			LOC9 = sonslen_194403(n);
			HEX3Atmp_449858 = (NI)(LOC9 - ((NI) 1));
			res_449861 = ((NI) 0);
			{
				while (1) {
					if (!(res_449861 <= HEX3Atmp_449858)) goto LA11;
					i_449752 = res_449861;
					{
						NIM_BOOL LOC14;
						LOC14 = 0;
						LOC14 = isrange_220612((*n).kindU.S6.sons->data[i_449752]);
						if (!LOC14) goto LA15;
						checksonslen_246249((*n).kindU.S6.sons->data[i_449752], ((NI) 3));
						asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[i_449752]).kindU.S6.sons->data[((NI) 1)]), semexprwithtype_410211(c, (*(*n).kindU.S6.sons->data[i_449752]).kindU.S6.sons->data[((NI) 1)], 0));
						asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[i_449752]).kindU.S6.sons->data[((NI) 2)]), semexprwithtype_410211(c, (*(*n).kindU.S6.sons->data[i_449752]).kindU.S6.sons->data[((NI) 2)], 0));
						{
							if (!(typ == NIM_NIL)) goto LA19;
							typ = skiptypes_195167((*(*(*n).kindU.S6.sons->data[i_449752]).kindU.S6.sons->data[((NI) 1)]).typ, 8423424);
						}
						LA19: ;
						asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[i_449752]).typ), (*(*(*n).kindU.S6.sons->data[i_449752]).kindU.S6.sons->data[((NI) 2)]).typ);
					}
					goto LA12;
					LA15: ;
					{
						if (!((*(*n).kindU.S6.sons->data[i_449752]).kind == ((NU8) 44))) goto LA22;
						{
							if (!(typ == NIM_NIL)) goto LA26;
							typ = skiptypes_195167((*(*(*n).kindU.S6.sons->data[i_449752]).kindU.S6.sons->data[((NI) 0)]).typ, 8423424);
						}
						LA26: ;
					}
					goto LA12;
					LA22: ;
					{
						asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_449752]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[i_449752], 0));
						{
							if (!(typ == NIM_NIL)) goto LA31;
							typ = skiptypes_195167((*(*n).kindU.S6.sons->data[i_449752]).typ, 8423424);
						}
						LA31: ;
					}
					LA12: ;
					res_449861 += ((NI) 1);
				} LA11: ;
			}
		}
		{
			NIM_BOOL LOC35;
			Ttype191849* LOC38;
			LOC35 = 0;
			LOC35 = isordinaltype_221093(typ);
			if (!!(LOC35)) goto LA36;
			localerror_166155((*n).info, ((NU16) 74), ((NimStringDesc*) &TMP2991));
			LOC38 = 0;
			LOC38 = getsystype_239030(((NU8) 31));
			typ = makerangetype_246182(c, IL64(0), IL64(65535), (*n).info, LOC38);
		}
		goto LA33;
		LA36: ;
		{
			NI64 LOC40;
			Ttype191849* LOC43;
			LOC40 = 0;
			LOC40 = lengthord_221016(typ);
			if (!(IL64(65536) < LOC40)) goto LA41;
			LOC43 = 0;
			LOC43 = getsystype_239030(((NU8) 31));
			typ = makerangetype_246182(c, IL64(0), IL64(65535), (*n).info, LOC43);
		}
		goto LA33;
		LA41: ;
		LA33: ;
		addsonskipintlit_239731((*result).typ, typ);
		{
			NI i_449836;
			NI HEX3Atmp_449867;
			NI LOC45;
			NI res_449870;
			i_449836 = 0;
			HEX3Atmp_449867 = 0;
			LOC45 = 0;
			LOC45 = sonslen_194403(n);
			HEX3Atmp_449867 = (NI)(LOC45 - ((NI) 1));
			res_449870 = ((NI) 0);
			{
				while (1) {
					Tnode191813* m;
					if (!(res_449870 <= HEX3Atmp_449867)) goto LA47;
					i_449836 = res_449870;
					m = 0;
					{
						NIM_BOOL LOC50;
						Tnode191813* LOC53;
						Tnode191813* LOC54;
						LOC50 = 0;
						LOC50 = isrange_220612((*n).kindU.S6.sons->data[i_449836]);
						if (!LOC50) goto LA51;
						m = newnodei_193351(((NU8) 44), (*(*n).kindU.S6.sons->data[i_449836]).info);
						LOC53 = 0;
						LOC53 = fitnode_410245(c, typ, (*(*n).kindU.S6.sons->data[i_449836]).kindU.S6.sons->data[((NI) 1)]);
						addson_193819(m, LOC53);
						LOC54 = 0;
						LOC54 = fitnode_410245(c, typ, (*(*n).kindU.S6.sons->data[i_449836]).kindU.S6.sons->data[((NI) 2)]);
						addson_193819(m, LOC54);
					}
					goto LA48;
					LA51: ;
					{
						if (!((*(*n).kindU.S6.sons->data[i_449836]).kind == ((NU8) 44))) goto LA56;
						m = (*n).kindU.S6.sons->data[i_449836];
					}
					goto LA48;
					LA56: ;
					{
						m = fitnode_410245(c, typ, (*n).kindU.S6.sons->data[i_449836]);
					}
					LA48: ;
					addson_193819(result, m);
					res_449870 += ((NI) 1);
				} LA47: ;
			}
		}
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, commontype_410477)(Ttype191849* x, Ttype191849* y) {
	Ttype191849* result;
	Ttype191849* a;
	Ttype191849* b;
{	result = 0;
	{
		if (!(x == NIM_NIL)) goto LA3;
		result = x;
		goto BeforeRet;
	}
	LA3: ;
	{
		if (!(y == NIM_NIL)) goto LA7;
		result = y;
		goto BeforeRet;
	}
	LA7: ;
	a = skiptypes_195167(x, 2048);
	b = skiptypes_195167(y, 2048);
	result = x;
	{
		if (!((96 &(IL64(1)<<(((*a).kind)&IL64(63))))!=0)) goto LA11;
		result = y;
	}
	goto LA9;
	LA11: ;
	{
		if (!((96 &(IL64(1)<<(((*b).kind)&IL64(63))))!=0)) goto LA14;
		result = x;
	}
	goto LA9;
	LA14: ;
	{
		if (!((*a).kind == ((NU8) 7))) goto LA17;
		result = a;
	}
	goto LA9;
	LA17: ;
	{
		if (!((*b).kind == ((NU8) 7))) goto LA20;
		result = b;
	}
	goto LA9;
	LA20: ;
	{
		if (!((*a).kind == ((NU8) 8))) goto LA23;
		{
			NIM_BOOL LOC27;
			LOC27 = 0;
			LOC27 = HEX3DHEX3D_230739((*a).sons, NIM_NIL);
			if (!LOC27) goto LA28;
			result = a;
		}
		goto LA25;
		LA28: ;
		{
			Ttype191849* LOC31;
			result = newtype_194140(((NU8) 8), (*a).owner);
			LOC31 = 0;
			LOC31 = newtype_194140(((NU8) 0), (*a).owner);
			rawaddson_195478(result, LOC31);
		}
		LA25: ;
	}
	goto LA9;
	LA23: ;
	{
		NIM_BOOL LOC33;
		NI idx;
		LOC33 = 0;
		LOC33 = ((17367056 &(IL64(1)<<(((*b).kind)&IL64(63))))!=0);
		if (!(LOC33)) goto LA34;
		LOC33 = ((*a).kind == (*b).kind);
		LA34: ;
		if (!LOC33) goto LA35;
		idx = ((65552 &(IL64(1)<<(((*b).kind)&IL64(63))))!=0);
		{
			if (!((*(*a).sons->data[idx]).kind == ((NU8) 3))) goto LA39;
			result = y;
			goto BeforeRet;
		}
		LA39: ;
	}
	goto LA9;
	LA35: ;
	{
		NIM_BOOL LOC42;
		NIM_BOOL LOC43;
		NI LOC46;
		NI LOC47;
		Ttype191849* nt;
		LOC42 = 0;
		LOC43 = 0;
		LOC43 = ((*a).kind == ((NU8) 18));
		if (!(LOC43)) goto LA44;
		LOC43 = ((*b).kind == ((NU8) 18));
		LA44: ;
		LOC42 = LOC43;
		if (!(LOC42)) goto LA45;
		LOC46 = 0;
		LOC46 = len_194377(a);
		LOC47 = 0;
		LOC47 = len_194377(b);
		LOC42 = (LOC46 == LOC47);
		LA45: ;
		if (!LOC42) goto LA48;
		nt = 0;
		{
			NI i_410657;
			NI HEX3Atmp_410882;
			NI LOC51;
			NI res_410885;
			i_410657 = 0;
			HEX3Atmp_410882 = 0;
			LOC51 = 0;
			LOC51 = len_194377(a);
			HEX3Atmp_410882 = (LOC51 - 1);
			res_410885 = ((NI) 0);
			{
				while (1) {
					NIM_BOOL aempty;
					NIM_BOOL bempty;
					if (!(res_410885 <= HEX3Atmp_410882)) goto LA53;
					i_410657 = res_410885;
					aempty = isemptycontainer_230978((*a).sons->data[i_410657]);
					bempty = isemptycontainer_230978((*b).sons->data[i_410657]);
					{
						if (!!((aempty == bempty))) goto LA56;
						{
							if (!nt == 0) goto LA60;
							nt = copytype_194549(a, (*a).owner, NIM_FALSE);
						}
						LA60: ;
						{
							if (!aempty) goto LA64;
							asgnRefNoCycle((void**) (&(*nt).sons->data[i_410657]), (*b).sons->data[i_410657]);
						}
						goto LA62;
						LA64: ;
						{
							asgnRefNoCycle((void**) (&(*nt).sons->data[i_410657]), (*a).sons->data[i_410657]);
						}
						LA62: ;
					}
					LA56: ;
					res_410885 += ((NI) 1);
				} LA53: ;
			}
		}
		{
			if (!!(nt == 0)) goto LA69;
			result = nt;
		}
		LA69: ;
	}
	goto LA9;
	LA48: ;
	{
		NIM_BOOL LOC72;
		LOC72 = 0;
		LOC72 = ((*a).kind == ((NU8) 20));
		if (!(LOC72)) goto LA73;
		LOC72 = ((*b).kind == ((NU8) 20));
		LA73: ;
		if (!LOC72) goto LA74;
		{
			NIM_BOOL LOC78;
			Ttype191849* LOC81;
			LOC78 = 0;
			LOC78 = sametype_226092(a, b, 0);
			if (!!(LOC78)) goto LA79;
			LOC81 = 0;
			LOC81 = skiptypes_195167(a, 1048576);
			result = skipintlit_239698(LOC81);
		}
		LA79: ;
	}
	goto LA9;
	LA74: ;
	{
		NU8 k;
		k = ((NU8) 0);
		{
			if (!((6291456 &(IL64(1)<<(((*a).kind)&IL64(63))))!=0)) goto LA85;
			k = (*a).kind;
			{
				if (!!(((*b).kind == (*a).kind))) goto LA89;
				result = x;
				goto BeforeRet;
			}
			LA89: ;
			a = lastson_194442(a);
			b = lastson_194442(b);
		}
		LA85: ;
		{
			NIM_BOOL LOC93;
			LOC93 = 0;
			LOC93 = ((*a).kind == ((NU8) 17));
			if (!(LOC93)) goto LA94;
			LOC93 = ((*b).kind == ((NU8) 17));
			LA94: ;
			if (!LOC93) goto LA95;
			result = commonsuperclass_228468(a, b);
			{
				NIM_BOOL LOC99;
				LOC99 = 0;
				LOC99 = result == 0;
				if (LOC99) goto LA100;
				LOC99 = (result == a);
				LA100: ;
				if (!LOC99) goto LA101;
				result = x;
				goto BeforeRet;
			}
			LA101: ;
			{
				if (!(result == b)) goto LA105;
				result = y;
				goto BeforeRet;
			}
			LA105: ;
			{
				Ttype191849* r;
				if (!!((k == ((NU8) 0)))) goto LA109;
				r = result;
				result = newtype_194140(k, (*r).owner);
				addsonskipintlit_239731(result, r);
			}
			LA109: ;
		}
		LA95: ;
	}
	LA9: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semarrayconstr_444273)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	NI LOC35;
	Ttype191849* LOC36;
	result = 0;
	result = newnodei_193351(((NU8) 41), (*n).info);
	asgnRefNoCycle((void**) (&(*result).typ), newtypes_245218(((NU8) 4), c));
	rawaddson_195478((*result).typ, NIM_NIL);
	{
		NI LOC3;
		Ttype191849* LOC6;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		if (!(LOC3 == ((NI) 0))) goto LA4;
		LOC6 = 0;
		LOC6 = newtypes_245218(((NU8) 3), c);
		rawaddson_195478((*result).typ, LOC6);
	}
	goto LA1;
	LA4: ;
	{
		Tnode191813* x;
		NI64 lastindex;
		Ttype191849* indextype;
		Tnode191813* yy;
		Ttype191849* typ;
		x = (*n).kindU.S6.sons->data[((NI) 0)];
		lastindex = IL64(0);
		indextype = getsystype_239030(((NU8) 31));
		{
			NIM_BOOL LOC10;
			NI LOC12;
			Tnode191813* idx;
			LOC10 = 0;
			LOC10 = ((*x).kind == ((NU8) 34));
			if (!(LOC10)) goto LA11;
			LOC12 = 0;
			LOC12 = sonslen_194403(x);
			LOC10 = (LOC12 == ((NI) 2));
			LA11: ;
			if (!LOC10) goto LA13;
			idx = semconstexpr_411485(c, (*x).kindU.S6.sons->data[((NI) 0)]);
			lastindex = getordvalue_221178(idx);
			indextype = (*idx).typ;
			x = (*x).kindU.S6.sons->data[((NI) 1)];
		}
		LA13: ;
		yy = semexprwithtype_410211(c, x, 0);
		typ = (*yy).typ;
		addson_193819(result, yy);
		{
			NI i_444309;
			NI HEX3Atmp_444371;
			NI LOC16;
			NI res_444374;
			i_444309 = 0;
			HEX3Atmp_444371 = 0;
			LOC16 = 0;
			LOC16 = sonslen_194403(n);
			HEX3Atmp_444371 = (NI)(LOC16 - ((NI) 1));
			res_444374 = ((NI) 1);
			{
				while (1) {
					Tnode191813* xx;
					if (!(res_444374 <= HEX3Atmp_444371)) goto LA18;
					i_444309 = res_444374;
					x = (*n).kindU.S6.sons->data[i_444309];
					{
						NIM_BOOL LOC21;
						NI LOC23;
						Tnode191813* idx;
						LOC21 = 0;
						LOC21 = ((*x).kind == ((NU8) 34));
						if (!(LOC21)) goto LA22;
						LOC23 = 0;
						LOC23 = sonslen_194403(x);
						LOC21 = (LOC23 == ((NI) 2));
						LA22: ;
						if (!LOC21) goto LA24;
						idx = semconstexpr_411485(c, (*x).kindU.S6.sons->data[((NI) 0)]);
						idx = fitnode_410245(c, indextype, idx);
						{
							NI64 LOC28;
							LOC28 = 0;
							LOC28 = getordvalue_221178(idx);
							if (!!(((NI64)(lastindex + IL64(1)) == LOC28))) goto LA29;
							localerror_166155((*x).info, ((NU16) 144), ((NimStringDesc*) &TMP2991));
						}
						LA29: ;
						x = (*x).kindU.S6.sons->data[((NI) 1)];
					}
					LA24: ;
					xx = semexprwithtype_410211(c, x, (flags & 64));
					add_192164(result, xx);
					typ = commontype_410477(typ, (*xx).typ);
					lastindex += ((NI) 1);
					res_444374 += ((NI) 1);
				} LA18: ;
			}
		}
		addsonskipintlit_239731((*result).typ, typ);
		{
			NI i_444366;
			NI HEX3Atmp_444379;
			NI LOC32;
			NI res_444382;
			i_444366 = 0;
			HEX3Atmp_444379 = 0;
			LOC32 = 0;
			LOC32 = len_192097(result);
			HEX3Atmp_444379 = (LOC32 - 1);
			res_444382 = ((NI) 0);
			{
				while (1) {
					if (!(res_444382 <= HEX3Atmp_444379)) goto LA34;
					i_444366 = res_444382;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_444366]), fitnode_410245(c, typ, (*result).kindU.S6.sons->data[i_444366]));
					res_444382 += ((NI) 1);
				} LA34: ;
			}
		}
	}
	LA1: ;
	LOC35 = 0;
	LOC35 = sonslen_194403(result);
	LOC36 = 0;
	LOC36 = getsystype_239030(((NU8) 31));
	asgnRefNoCycle((void**) (&(*(*result).typ).sons->data[((NI) 0)]), makerangetype_246182(c, IL64(0), ((NI64) ((NI)(LOC35 - ((NI) 1)))), (*n).info, LOC36));
	return result;
}

N_NIMCALL(Tnode191813*, semlambda_410261)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	Tsym191843* s;
	Tscope191837* LOC13;
	Tnode191813* gp;
{	result = 0;
	result = semprocannotation_439127(c, n, TMP3423);
	{
		if (!!((result == NIM_NIL))) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	result = n;
	checksonslen_246249(n, ((NI) 7));
	s = 0;
	{
		Tnode191813* LOC7;
		Tsym191843* LOC10;
		LOC7 = 0;
		LOC7 = HEX5BHEX5D_192244(n, ((NI) 0));
		if (!!(((*LOC7).kind == ((NU8) 3)))) goto LA8;
		LOC10 = 0;
		LOC10 = getcurrowner_245255();
		s = newsym_192655(((NU8) 12), idanon_168495, LOC10, (*n).info);
		asgnRefNoCycle((void**) (&(*s).ast), n);
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(s));
	}
	goto LA5;
	LA8: ;
	{
		Tnode191813* LOC12;
		LOC12 = 0;
		LOC12 = HEX5BHEX5D_192244(n, ((NI) 0));
		s = (*LOC12).kindU.S4.sym;
	}
	LA5: ;
	pushowner_245260(s);
	LOC13 = 0;
	LOC13 = openscope_250091(c);
	gp = 0;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1)))) goto LA16;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), semgenericparamlist_422951(c, (*n).kindU.S6.sons->data[((NI) 2)], NIM_NIL));
		gp = (*n).kindU.S6.sons->data[((NI) 2)];
	}
	goto LA14;
	LA16: ;
	{
		gp = newnodei_193351(((NU8) 75), (*n).info);
	}
	LA14: ;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 3)]).kind == ((NU8) 1)))) goto LA21;
		semparamlist_410284(c, (*n).kindU.S6.sons->data[((NI) 3)], gp, s);
		{
			NIM_BOOL LOC25;
			NI LOC26;
			LOC25 = 0;
			LOC26 = 0;
			LOC26 = sonslen_194403(gp);
			LOC25 = (((NI) 0) < LOC26);
			if (!(LOC25)) goto LA27;
			LOC25 = ((*(*n).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1));
			LA27: ;
			if (!LOC25) goto LA28;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), gp);
		}
		LA28: ;
	}
	goto LA19;
	LA21: ;
	{
		asgnRefNoCycle((void**) (&(*s).typ), newproctype_421342(c, (*n).info, NIM_NIL));
	}
	LA19: ;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 4)]).kind == ((NU8) 1)))) goto LA33;
		pragma_261069(c, s, (*n).kindU.S6.sons->data[((NI) 4)], TMP3423);
	}
	LA33: ;
	(*s).options = goptions_155126;
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 6)]).kind == ((NU8) 1)))) goto LA37;
		{
			if (!(((*s).flags &(1<<((((NU8) 5))&31)))!=0)) goto LA41;
			localerror_166155((*(*n).kindU.S6.sons->data[((NI) 6)]).info, ((NU16) 137), (*(*s).name).s);
		}
		LA41: ;
		{
			NIM_BOOL LOC45;
			NI LOC46;
			NIM_BOOL LOC48;
			NI LOC49;
			Tnode191813* LOC51;
			Tnode191813* sembody;
			Tnode191813* LOC54;
			LOC45 = 0;
			LOC46 = 0;
			LOC46 = len_192097(gp);
			LOC45 = (LOC46 == ((NI) 0));
			if (LOC45) goto LA47;
			LOC48 = 0;
			LOC49 = 0;
			LOC49 = len_192097(gp);
			LOC48 = (LOC49 == ((NI) 1));
			if (!(LOC48)) goto LA50;
			LOC51 = 0;
			LOC51 = HEX5BHEX5D_192244(gp, ((NI) 0));
			LOC48 = (((*(*LOC51).typ).flags &(1<<((((NU8) 10))&31)))!=0);
			LA50: ;
			LOC45 = LOC48;
			LA47: ;
			if (!LOC45) goto LA52;
			pushproccon_245358(c, s);
			addresult_438997(c, (*(*s).typ).sons->data[((NI) 0)], (*n).info, ((NU8) 12));
			addresultnode_439031(c, n);
			LOC54 = 0;
			LOC54 = semprocbody_410238(c, (*n).kindU.S6.sons->data[((NI) 6)]);
			sembody = hlobody_412161(c, LOC54);
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), transformbody_371118((*c).module, sembody, s));
			popproccon_245390(c);
		}
		goto LA43;
		LA52: ;
		{
			if (!!(((flags &(1<<((((NU8) 8))&15)))!=0))) goto LA56;
			localerror_166155((*n).info, ((NU16) 227), ((NimStringDesc*) &TMP2991));
		}
		goto LA43;
		LA56: ;
		LA43: ;
		sideeffectscheck_413116(c, s);
	}
	goto LA35;
	LA37: ;
	{
		localerror_166155((*n).info, ((NU16) 138), (*(*s).name).s);
	}
	LA35: ;
	closescope_250111(c);
	popowner_245266();
	asgnRefNoCycle((void**) (&(*result).typ), (*s).typ);
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semdo_439430)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		Tnode191813* LOC4;
		Tnode191813* LOC6;
		Tnode191813* LOC9;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = HEX5BHEX5D_192244(n, ((NI) 2));
		LOC3 = ((*LOC4).kind == ((NU8) 1));
		if (!(LOC3)) goto LA5;
		LOC6 = 0;
		LOC6 = HEX5BHEX5D_192244(n, ((NI) 3));
		LOC3 = ((*LOC6).kind == ((NU8) 1));
		LA5: ;
		if (!LOC3) goto LA7;
		LOC9 = 0;
		LOC9 = HEX5BHEX5D_192244(n, ((NI) 6));
		result = semstmt_410277(c, LOC9);
	}
	goto LA1;
	LA7: ;
	{
		result = semlambda_410261(c, n, flags);
	}
	LA1: ;
	return result;
}

N_NIMCALL(NIM_BOOL, iscastable_443383)(Ttype191849* dst, Ttype191849* src) {
	NIM_BOOL result;
	NI64 dstsize;
	NI64 srcsize;
{	result = 0;
	{
		Ttype191849* LOC3;
		LOC3 = 0;
		LOC3 = skiptypes_195167(dst, IL64(211106232576256));
		if (!((*LOC3).kind == ((NU8) 27))) goto LA4;
		result = NIM_FALSE;
		goto BeforeRet;
	}
	LA4: ;
	dstsize = 0;
	srcsize = 0;
	dstsize = computesize_221184(dst);
	srcsize = computesize_221184(src);
	{
		if (!(dstsize < IL64(0))) goto LA8;
		result = NIM_FALSE;
	}
	goto LA6;
	LA8: ;
	{
		if (!(srcsize < IL64(0))) goto LA11;
		result = NIM_FALSE;
	}
	goto LA6;
	LA11: ;
	{
		Ttype191849* LOC14;
		LOC14 = 0;
		LOC14 = typeallowed_229654(dst, ((NU8) 3));
		if (!!((LOC14 == NIM_NIL))) goto LA15;
		result = NIM_FALSE;
	}
	goto LA6;
	LA15: ;
	{
		NIM_BOOL LOC18;
		NIM_BOOL LOC19;
		Ttype191849* LOC21;
		Ttype191849* LOC23;
		LOC18 = 0;
		LOC19 = 0;
		LOC19 = (srcsize <= dstsize);
		if (LOC19) goto LA20;
		LOC21 = 0;
		LOC21 = skiptypes_195167(dst, IL64(211106232576256));
		LOC19 = ((IL64(35182224621574) &(IL64(1)<<(((*LOC21).kind)&IL64(63))))!=0);
		LA20: ;
		LOC18 = LOC19;
		if (LOC18) goto LA22;
		LOC23 = 0;
		LOC23 = skiptypes_195167(src, IL64(211106232576000));
		LOC18 = ((IL64(35182224621574) &(IL64(1)<<(((*LOC23).kind)&IL64(63))))!=0);
		LA22: ;
		result = LOC18;
	}
	LA6: ;
	{
		NIM_BOOL LOC26;
		LOC26 = 0;
		LOC26 = result;
		if (!(LOC26)) goto LA27;
		LOC26 = ((*src).kind == ((NU8) 5));
		LA27: ;
		if (!LOC26) goto LA28;
		result = ((*dst).size <= ((NI64) (ptrsize_160625)));
	}
	LA28: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semcast_443625)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* LOC5;
	Tnode191813* LOC6;
	result = 0;
	{
		if (!((gglobaloptions_155128 &(1<<((((NU8) 6))&31)))!=0)) goto LA3;
		localerror_166155((*n).info, ((NU16) 91), ((NimStringDesc*) &TMP2991));
	}
	LA3: ;
	checksonslen_246249(n, ((NI) 2));
	result = newnodei_193351(((NU8) 61), (*n).info);
	asgnRefNoCycle((void**) (&(*result).typ), semtypenode_410269(c, (*n).kindU.S6.sons->data[((NI) 0)], NIM_NIL));
	LOC5 = 0;
	LOC5 = copytree_196028((*n).kindU.S6.sons->data[((NI) 0)]);
	addson_193819(result, LOC5);
	LOC6 = 0;
	LOC6 = semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 1)], 0);
	addson_193819(result, LOC6);
	{
		NIM_BOOL LOC9;
		NimStringDesc* LOC12;
		LOC9 = 0;
		LOC9 = iscastable_443383((*result).typ, (*(*result).kindU.S6.sons->data[((NI) 1)]).typ);
		if (!!(LOC9)) goto LA10;
		LOC12 = 0;
		LOC12 = typetostring_221032((*result).typ, ((NU8) 0));
		localerror_166155((*result).info, ((NU16) 92), LOC12);
	}
	LA10: ;
	return result;
}

static N_INLINE(void, semdestructorcheck_433440)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = !(((flags &(1<<((((NU8) 6))&15)))!=0));
		if (!(LOC3)) goto LA4;
		LOC3 = ((*n).kind >= ((NU8) 26) && (*n).kind <= ((NU8) 32) || (*n).kind == ((NU8) 38) || (*n).kind == ((NU8) 41));
		LA4: ;
		if (!LOC3) goto LA5;
		{
			Ttype191849* LOC9;
			LOC9 = 0;
			LOC9 = instantiatedestructor_432423(c, (*n).typ);
			if (!!((LOC9 == NIM_NIL))) goto LA10;
			localerror_166155((*n).info, ((NU16) 257), ((NimStringDesc*) &TMP2991));
		}
		LA10: ;
	}
	LA5: ;
}

N_NIMCALL(Tnode191813*, semexprbranch_433604)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = semexpr_410201(c, n, 0);
	{
		if (!!(((*result).typ == NIM_NIL))) goto LA3;
		semprocvarcheck_432366(c, result);
		{
			if (!((*(*result).typ).kind == ((NU8) 23))) goto LA7;
			result = newderef_358024(result);
		}
		LA7: ;
		semdestructorcheck_433440(c, result, 0);
	}
	LA3: ;
	return result;
}

N_NIMCALL(Tnode191813*, semexprbranchscope_433635)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tscope191837* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	result = semexprbranch_433604(c, n);
	closescope_250111(c);
	return result;
}

N_NIMCALL(Tnode191813*, semif_433860)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Ttype191849* typ;
	NIM_BOOL haselse;
	result = 0;
	result = n;
	typ = commontypebegin_410472;
	haselse = NIM_FALSE;
	{
		NI i_433879;
		NI HEX3Atmp_434236;
		NI LOC2;
		NI res_434239;
		i_433879 = 0;
		HEX3Atmp_434236 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_434236 = (NI)(LOC2 - ((NI) 1));
		res_434239 = ((NI) 0);
		{
			while (1) {
				Tnode191813* it;
				if (!(res_434239 <= HEX3Atmp_434236)) goto LA4;
				i_433879 = res_434239;
				it = (*n).kindU.S6.sons->data[i_433879];
				{
					NI LOC7;
					Tscope191837* LOC10;
					Tnode191813* LOC11;
					LOC7 = 0;
					LOC7 = len_192097(it);
					if (!(LOC7 == ((NI) 2))) goto LA8;
					LOC10 = 0;
					LOC10 = openscope_250091(c);
					LOC11 = 0;
					LOC11 = semexprwithtype_410211(c, (*it).kindU.S6.sons->data[((NI) 0)], 0);
					asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[((NI) 0)]), forcebool_416629(c, LOC11));
					asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[((NI) 1)]), semexprbranch_433604(c, (*it).kindU.S6.sons->data[((NI) 1)]));
					typ = commontype_410477(typ, (*(*it).kindU.S6.sons->data[((NI) 1)]).typ);
					closescope_250111(c);
				}
				goto LA5;
				LA8: ;
				{
					NI LOC13;
					LOC13 = 0;
					LOC13 = len_192097(it);
					if (!(LOC13 == ((NI) 1))) goto LA14;
					haselse = NIM_TRUE;
					asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[((NI) 0)]), semexprbranchscope_433635(c, (*it).kindU.S6.sons->data[((NI) 0)]));
					typ = commontype_410477(typ, (*(*it).kindU.S6.sons->data[((NI) 0)]).typ);
				}
				goto LA5;
				LA14: ;
				{
					illformedast_246229(it);
				}
				LA5: ;
				res_434239 += ((NI) 1);
			} LA4: ;
		}
	}
	{
		NIM_BOOL LOC19;
		NIM_BOOL LOC20;
		LOC19 = 0;
		LOC20 = 0;
		LOC20 = isemptytype_196934(typ);
		if (LOC20) goto LA21;
		LOC20 = ((*typ).kind == ((NU8) 5));
		LA21: ;
		LOC19 = LOC20;
		if (LOC19) goto LA22;
		LOC19 = !(haselse);
		LA22: ;
		if (!LOC19) goto LA23;
		{
			Tnode191813* it_434217;
			it_434217 = 0;
			{
				NI i_434247;
				NI HEX3Atmp_434249;
				NI LOC27;
				NI res_434251;
				i_434247 = 0;
				HEX3Atmp_434249 = 0;
				LOC27 = 0;
				LOC27 = len_192097(n);
				HEX3Atmp_434249 = (LOC27 - 1);
				res_434251 = ((NI) 0);
				{
					while (1) {
						Tnode191813* LOC30;
						if (!(res_434251 <= HEX3Atmp_434249)) goto LA29;
						i_434247 = res_434251;
						it_434217 = (*n).kindU.S6.sons->data[i_434247];
						LOC30 = 0;
						LOC30 = lastson_194431(it_434217);
						discardcheck_433756(c, LOC30);
						res_434251 += ((NI) 1);
					} LA29: ;
				}
			}
		}
		(*result).kind = ((NU8) 92);
		{
			if (!(typ == enforcevoidcontext_432005)) goto LA33;
			asgnRefNoCycle((void**) (&(*result).typ), enforcevoidcontext_432005);
		}
		LA33: ;
	}
	goto LA17;
	LA23: ;
	{
		{
			Tnode191813* it_434230;
			it_434230 = 0;
			{
				NI i_434258;
				NI HEX3Atmp_434260;
				NI LOC38;
				NI res_434262;
				i_434258 = 0;
				HEX3Atmp_434260 = 0;
				LOC38 = 0;
				LOC38 = len_192097(n);
				HEX3Atmp_434260 = (LOC38 - 1);
				res_434262 = ((NI) 0);
				{
					while (1) {
						NI j;
						NI LOC41;
						if (!(res_434262 <= HEX3Atmp_434260)) goto LA40;
						i_434258 = res_434262;
						it_434230 = (*n).kindU.S6.sons->data[i_434258];
						LOC41 = 0;
						LOC41 = len_192097(it_434230);
						j = (NI)(LOC41 - ((NI) 1));
						asgnRefNoCycle((void**) (&(*it_434230).kindU.S6.sons->data[j]), fitnode_410245(c, typ, (*it_434230).kindU.S6.sons->data[j]));
						res_434262 += ((NI) 1);
					} LA40: ;
				}
			}
		}
		(*result).kind = ((NU8) 48);
		asgnRefNoCycle((void**) (&(*result).typ), typ);
	}
	LA17: ;
	return result;
}

N_NIMCALL(Tnode191813*, semtableconstr_449895)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	NI lastkey;
	result = 0;
	result = newnodei_193351(((NU8) 41), (*n).info);
	lastkey = ((NI) 0);
	{
		NI i_449912;
		NI HEX3Atmp_449956;
		NI LOC2;
		NI res_449959;
		i_449912 = 0;
		HEX3Atmp_449956 = 0;
		LOC2 = 0;
		LOC2 = len_192097(n);
		HEX3Atmp_449956 = (NI)(LOC2 - ((NI) 1));
		res_449959 = ((NI) 0);
		{
			while (1) {
				Tnode191813* x;
				if (!(res_449959 <= HEX3Atmp_449956)) goto LA4;
				i_449912 = res_449959;
				x = (*n).kindU.S6.sons->data[i_449912];
				{
					NIM_BOOL LOC7;
					NI LOC9;
					Tnode191813* pair;
					Tnode191813* LOC16;
					Tnode191813* LOC17;
					LOC7 = 0;
					LOC7 = ((*x).kind == ((NU8) 34));
					if (!(LOC7)) goto LA8;
					LOC9 = 0;
					LOC9 = sonslen_194403(x);
					LOC7 = (LOC9 == ((NI) 2));
					LA8: ;
					if (!LOC7) goto LA10;
					{
						NI j_449936;
						NI HEX3Atmp_449949;
						NI res_449952;
						j_449936 = 0;
						HEX3Atmp_449949 = 0;
						HEX3Atmp_449949 = (NI)(i_449912 - ((NI) 1));
						res_449952 = lastkey;
						{
							while (1) {
								Tnode191813* pair;
								Tnode191813* LOC15;
								if (!(res_449952 <= HEX3Atmp_449949)) goto LA14;
								j_449936 = res_449952;
								pair = newnodei_193351(((NU8) 37), (*x).info);
								add_192164(pair, (*n).kindU.S6.sons->data[j_449936]);
								LOC15 = 0;
								LOC15 = HEX5BHEX5D_192244(x, ((NI) 1));
								add_192164(pair, LOC15);
								add_192164(result, pair);
								res_449952 += ((NI) 1);
							} LA14: ;
						}
					}
					pair = newnodei_193351(((NU8) 37), (*x).info);
					LOC16 = 0;
					LOC16 = HEX5BHEX5D_192244(x, ((NI) 0));
					add_192164(pair, LOC16);
					LOC17 = 0;
					LOC17 = HEX5BHEX5D_192244(x, ((NI) 1));
					add_192164(pair, LOC17);
					add_192164(result, pair);
					lastkey = (NI)(i_449912 + ((NI) 1));
				}
				LA10: ;
				res_449959 += ((NI) 1);
			} LA4: ;
		}
	}
	{
		NI LOC20;
		LOC20 = 0;
		LOC20 = len_192097(n);
		if (!!((lastkey == LOC20))) goto LA21;
		illformedast_246229(n);
	}
	LA21: ;
	result = semexpr_410201(c, result, 0);
	return result;
}

N_NIMCALL(Tnode191813*, semstaticexpr_445882)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* a;
	result = 0;
	a = semexpr_410201(c, (*n).kindU.S6.sons->data[((NI) 0)], 0);
	result = evalstaticexpr_398832((*c).module, a, (*(*c).p).owner);
	{
		NimStringDesc* LOC5;
		if (!result == 0) goto LA3;
		LOC5 = 0;
		LOC5 = rendertree_213058(n, 0);
		localerror_166155((*n).info, ((NU16) 208), LOC5);
		result = emptynode_192807;
	}
	goto LA1;
	LA3: ;
	{
		result = fixuptypeaftereval_411201(c, result, a);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semblock_450650)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tscope191837* LOC1;
	result = 0;
	result = n;
	(*(*c).p).nestedblockcounter += ((NI) 1);
	checksonslen_246249(n, ((NI) 2));
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	{
		Tsym191843* labl;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA4;
		labl = newsymg_410916(((NU8) 22), (*n).kindU.S6.sons->data[((NI) 0)], c);
		{
			if (!!((((*labl).flags &(1<<((((NU8) 31))&31)))!=0))) goto LA8;
			adddecl_250607(c, labl);
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(labl, (*(*n).kindU.S6.sons->data[((NI) 0)]).info));
		}
		LA8: ;
		suggestsym_354960((*(*n).kindU.S6.sons->data[((NI) 0)]).info, labl);
	}
	LA4: ;
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), semexpr_410201(c, (*n).kindU.S6.sons->data[((NI) 1)], 0));
	asgnRefNoCycle((void**) (&(*n).typ), (*(*n).kindU.S6.sons->data[((NI) 1)]).typ);
	{
		NIM_BOOL LOC12;
		LOC12 = 0;
		LOC12 = isemptytype_196934((*n).typ);
		if (!LOC12) goto LA13;
		(*n).kind = ((NU8) 112);
	}
	goto LA10;
	LA13: ;
	{
		(*n).kind = ((NU8) 127);
	}
	LA10: ;
	closescope_250111(c);
	(*(*c).p).nestedblockcounter -= ((NI) 1);
	return result;
}

N_NIMCALL(Tnode191813*, semtry_434715)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Ttype191849* typ_434729;
	Intset188056 check;
	NI last;
	NI LOC1;
	result = 0;
	result = n;
	(*(*c).p).intrystmt += ((NI) 1);
	checkminsonslen_246259(n, ((NI) 2));
	typ_434729 = commontypebegin_410472;
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexprbranchscope_433635(c, (*n).kindU.S6.sons->data[((NI) 0)]));
	typ_434729 = commontype_410477(typ_434729, (*(*n).kindU.S6.sons->data[((NI) 0)]).typ);
	memset((void*)(&check), 0, sizeof(check));
	chckNil((void*)(&check));
	memset((void*)(&check), 0, sizeof(check));
	initintset_188927((&check));
	LOC1 = 0;
	LOC1 = sonslen_194403(n);
	last = (NI)(LOC1 - ((NI) 1));
	{
		NI i_434747;
		NI res_434955;
		i_434747 = 0;
		res_434955 = ((NI) 1);
		{
			while (1) {
				Tnode191813* a;
				NI length;
				if (!(res_434955 <= last)) goto LA4;
				i_434747 = res_434955;
				a = (*n).kindU.S6.sons->data[i_434747];
				checkminsonslen_246259(a, ((NI) 1));
				length = sonslen_194403(a);
				{
					if (!((*a).kind == ((NU8) 87))) goto LA7;
					{
						NIM_BOOL LOC11;
						Slice85773 LOC15;
						LOC11 = 0;
						LOC11 = (length == ((NI) 2));
						if (!(LOC11)) goto LA12;
						LOC11 = ((*(*a).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 41));
						LA12: ;
						if (!LOC11) goto LA13;
						LOC15 = HEX2EHEX2E_105273(((NI) 0), ((NI) 0));
						HEX5BHEX5DHEX3D_414619((&(*a).kindU.S6.sons), LOC15, (*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data, (*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->Sup.len);
						length = sonslen_194403(a);
					}
					LA13: ;
					{
						NI j_434812;
						NI HEX3Atmp_434946;
						NI res_434949;
						j_434812 = 0;
						HEX3Atmp_434946 = 0;
						HEX3Atmp_434946 = (NI)(length - ((NI) 2));
						res_434949 = ((NI) 0);
						{
							while (1) {
								Ttype191849* typ;
								if (!(res_434949 <= HEX3Atmp_434946)) goto LA18;
								j_434812 = res_434949;
								typ = semtypenode_410269(c, (*a).kindU.S6.sons->data[j_434812], NIM_NIL);
								{
									if (!((*typ).kind == ((NU8) 22))) goto LA21;
									typ = (*typ).sons->data[((NI) 0)];
								}
								LA21: ;
								{
									if (!!(((*typ).kind == ((NU8) 17)))) goto LA25;
									localerror_166155((*(*a).kindU.S6.sons->data[j_434812]).info, ((NU16) 112), ((NimStringDesc*) &TMP2991));
								}
								LA25: ;
								asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[j_434812]), newnodei_193351(((NU8) 4), (*(*a).kindU.S6.sons->data[j_434812]).info));
								asgnRefNoCycle((void**) (&(*(*a).kindU.S6.sons->data[j_434812]).typ), typ);
								{
									NIM_BOOL LOC29;
									LOC29 = 0;
									LOC29 = containsorincl_188898((&check), (*typ).Sup.id);
									if (!LOC29) goto LA30;
									localerror_166155((*(*a).kindU.S6.sons->data[j_434812]).info, ((NU16) 35), ((NimStringDesc*) &TMP2991));
								}
								LA30: ;
								res_434949 += ((NI) 1);
							} LA18: ;
						}
					}
				}
				goto LA5;
				LA7: ;
				{
					if (!!(((*a).kind == ((NU8) 107)))) goto LA33;
					illformedast_246229(n);
				}
				goto LA5;
				LA33: ;
				LA5: ;
				asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[(NI)(length - ((NI) 1))]), semexprbranchscope_433635(c, (*a).kindU.S6.sons->data[(NI)(length - ((NI) 1))]));
				{
					if (!!(((*a).kind == ((NU8) 107)))) goto LA37;
					typ_434729 = commontype_410477(typ_434729, (*(*a).kindU.S6.sons->data[(NI)(length - ((NI) 1))]).typ);
				}
				goto LA35;
				LA37: ;
				{
					last -= ((NI) 1);
				}
				LA35: ;
				res_434955 += ((NI) 1);
			} LA4: ;
		}
	}
	(*(*c).p).intrystmt -= ((NI) 1);
	{
		NIM_BOOL LOC42;
		LOC42 = 0;
		LOC42 = isemptytype_196934(typ_434729);
		if (LOC42) goto LA43;
		LOC42 = ((*typ_434729).kind == ((NU8) 5));
		LA43: ;
		if (!LOC42) goto LA44;
		discardcheck_433756(c, (*n).kindU.S6.sons->data[((NI) 0)]);
		{
			NI i_434899;
			NI HEX3Atmp_434960;
			NI LOC47;
			NI res_434963;
			i_434899 = 0;
			HEX3Atmp_434960 = 0;
			LOC47 = 0;
			LOC47 = len_192097(n);
			HEX3Atmp_434960 = (NI)(LOC47 - ((NI) 1));
			res_434963 = ((NI) 1);
			{
				while (1) {
					Tnode191813* LOC50;
					if (!(res_434963 <= HEX3Atmp_434960)) goto LA49;
					i_434899 = res_434963;
					LOC50 = 0;
					LOC50 = lastson_194431((*n).kindU.S6.sons->data[i_434899]);
					discardcheck_433756(c, LOC50);
					res_434963 += ((NI) 1);
				} LA49: ;
			}
		}
		{
			if (!(typ_434729 == enforcevoidcontext_432005)) goto LA53;
			asgnRefNoCycle((void**) (&(*result).typ), enforcevoidcontext_432005);
		}
		LA53: ;
	}
	goto LA40;
	LA44: ;
	{
		{
			Tnode191813* LOC58;
			Tnode191813* LOC61;
			Tnode191813* LOC62;
			LOC58 = 0;
			LOC58 = lastson_194431(n);
			if (!((*LOC58).kind == ((NU8) 107))) goto LA59;
			LOC61 = 0;
			LOC61 = lastson_194431(n);
			LOC62 = 0;
			LOC62 = lastson_194431(LOC61);
			discardcheck_433756(c, LOC62);
		}
		LA59: ;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), fitnode_410245(c, typ_434729, (*n).kindU.S6.sons->data[((NI) 0)]));
		{
			NI i_434937;
			NI res_434970;
			i_434937 = 0;
			res_434970 = ((NI) 1);
			{
				while (1) {
					Tnode191813* it;
					NI j;
					NI LOC66;
					if (!(res_434970 <= last)) goto LA65;
					i_434937 = res_434970;
					it = (*n).kindU.S6.sons->data[i_434937];
					LOC66 = 0;
					LOC66 = len_192097(it);
					j = (NI)(LOC66 - ((NI) 1));
					asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[j]), fitnode_410245(c, typ_434729, (*it).kindU.S6.sons->data[j]));
					res_434970 += ((NI) 1);
				} LA65: ;
			}
		}
		asgnRefNoCycle((void**) (&(*result).typ), typ_434729);
	}
	LA40: ;
	return result;
}

N_NIMCALL(NIM_BOOL, usesresult_441004)(Tnode191813* n) {
	NIM_BOOL result;
{	result = 0;
	{
		if (!!(((*n).kind >= ((NU8) 51) && (*n).kind <= ((NU8) 52) || (*n).kind >= ((NU8) 79) && (*n).kind <= ((NU8) 84) || (*n).kind == ((NU8) 115) || (*n).kind == ((NU8) 126)))) goto LA3;
		{
			NIM_BOOL LOC7;
			NIM_BOOL LOC10;
			LOC7 = 0;
			LOC7 = isatom_196906(n);
			if (!LOC7) goto LA8;
			LOC10 = 0;
			LOC10 = ((*n).kind == ((NU8) 3));
			if (!(LOC10)) goto LA11;
			LOC10 = ((*(*n).kindU.S4.sym).kind == ((NU8) 11));
			LA11: ;
			result = LOC10;
		}
		goto LA5;
		LA8: ;
		{
			if (!((*n).kind == ((NU8) 109))) goto LA13;
			result = NIM_TRUE;
		}
		goto LA5;
		LA13: ;
		{
			{
				Tnode191813* c_441059;
				c_441059 = 0;
				{
					NI i_441064;
					NI HEX3Atmp_441066;
					NI LOC18;
					NI res_441068;
					i_441064 = 0;
					HEX3Atmp_441066 = 0;
					LOC18 = 0;
					LOC18 = len_192097(n);
					HEX3Atmp_441066 = (LOC18 - 1);
					res_441068 = ((NI) 0);
					{
						while (1) {
							if (!(res_441068 <= HEX3Atmp_441066)) goto LA20;
							i_441064 = res_441068;
							c_441059 = (*n).kindU.S6.sons->data[i_441064];
							{
								NIM_BOOL LOC23;
								LOC23 = 0;
								LOC23 = usesresult_441004(c_441059);
								if (!LOC23) goto LA24;
								result = NIM_TRUE;
								goto BeforeRet;
							}
							LA24: ;
							res_441068 += ((NI) 1);
						} LA20: ;
					}
				}
			}
		}
		LA5: ;
	}
	LA3: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, insertdestructors_433265)(Tcontext245023* c, Tnode191813* varsection, TY433269* Result) {
	NI totalvars;
{	totalvars = sonslen_194403(varsection);
	{
		NI j_433287;
		NI HEX3Atmp_433418;
		NI res_433421;
		j_433287 = 0;
		HEX3Atmp_433418 = 0;
		HEX3Atmp_433418 = (NI)(totalvars - ((NI) 1));
		res_433421 = ((NI) 0);
		{
			while (1) {
				if (!(res_433421 <= HEX3Atmp_433418)) goto LA3;
				j_433287 = res_433421;
				{
					Tnode191813* varid;
					Tnode191813* LOC5;
					Ttype191849* vartyp;
					Tlineinfo164338 info;
					Ttype191849* destructablet;
					LOC5 = 0;
					LOC5 = HEX5BHEX5D_192244(varsection, j_433287);
					varid = HEX5BHEX5D_192244(LOC5, ((NI) 0));
					vartyp = (*(*varid).kindU.S4.sym).typ;
					info = (*varid).info;
					{
						NIM_BOOL LOC8;
						LOC8 = 0;
						LOC8 = (vartyp == NIM_NIL);
						if (LOC8) goto LA9;
						LOC8 = (((*(*varid).kindU.S4.sym).flags &(1<<((((NU8) 3))&31)))!=0);
						LA9: ;
						if (!LOC8) goto LA10;
						goto LA4;
					}
					LA10: ;
					destructablet = instantiatedestructor_432423(c, vartyp);
					{
						Tnode191813* trystmt;
						Tnodeseq191807* LOC29;
						TY209680 LOC30;
						Tnodeseq191807* LOC31;
						TY246103 LOC32;
						Tnode191813* LOC33;
						Tnode191813* LOC34;
						if (!!((destructablet == NIM_NIL))) goto LA14;
						trystmt = newnodei_193351(((NU8) 106), info);
						{
							Tnode191813* remainingvars;
							NI LOC20;
							Slice85773 LOC21;
							TY433269 LOC22;
							Tnode191813* outer;
							Tnode191813* inner;
							if (!(j_433287 < (NI)(totalvars - ((NI) 1)))) goto LA18;
							remainingvars = newnodei_193351((*varsection).kind, info);
							LOC20 = 0;
							LOC20 = len_192097(varsection);
							LOC21 = HEX2EHEX2E_105273((NI)(j_433287 + ((NI) 1)), (NI)(LOC20 - ((NI) 1)));
							asgnRefNoCycle((void**) (&(*remainingvars).kindU.S6.sons), HEX5BHEX5D_432717((*varsection).kindU.S6.sons, LOC21));
							memset((void*)(&LOC22), 0, sizeof(LOC22));
							insertdestructors_433265(c, remainingvars, (&LOC22));
							outer = 0;
							outer = LOC22.Field0;
							inner = 0;
							inner = LOC22.Field1;
							{
								if (!!((outer == NIM_NIL))) goto LA25;
								addson_193819(trystmt, outer);
								unsureAsgnRef((void**) (&(*Result).Field1), inner);
							}
							goto LA23;
							LA25: ;
							{
								unsureAsgnRef((void**) (&(*Result).Field1), newnodei_193351(((NU8) 115), info));
								addson_193819((*Result).Field1, remainingvars);
								addson_193819(trystmt, (*Result).Field1);
							}
							LA23: ;
						}
						goto LA16;
						LA18: ;
						{
							unsureAsgnRef((void**) (&(*Result).Field1), newnodei_193351(((NU8) 115), info));
							addson_193819(trystmt, (*Result).Field1);
						}
						LA16: ;
						LOC29 = 0;
						LOC29 = (Tnodeseq191807*) newSeq((&NTI191807), 1);
						memset((void*)LOC30, 0, sizeof(LOC30));
						LOC31 = 0;
						LOC31 = (Tnodeseq191807*) newSeq((&NTI191807), 2);
						memset((void*)LOC32, 0, sizeof(LOC32));
						LOC32[0] = usesym_355055((*destructablet).destructor);
						LOC32[1] = usesym_355055((*varid).kindU.S4.sym);
						asgnRefNoCycle((void**) (&LOC31->data[0]), LOC32[0]);
						asgnRefNoCycle((void**) (&LOC31->data[1]), LOC32[1]);
						LOC33 = 0;
						LOC33 = newnode_193607(((NU8) 27), info, LOC31, NIM_NIL);
						LOC30[0] = semstmt_410277(c, LOC33);
						asgnRefNoCycle((void**) (&LOC29->data[0]), LOC30[0]);
						LOC34 = 0;
						LOC34 = newnode_193607(((NU8) 107), info, LOC29, NIM_NIL);
						addson_193819(trystmt, LOC34);
						unsureAsgnRef((void**) (&(*Result).Field0), newnodei_193351(((NU8) 115), info));
						(*varsection).kindU.S6.sons = (Tnodeseq191807*) setLengthSeq(&((*varsection).kindU.S6.sons)->Sup, sizeof(Tnode191813*), ((NI) ((NI)(j_433287 + ((NI) 1)))));
						addson_193819((*Result).Field0, varsection);
						addson_193819((*Result).Field0, trystmt);
						goto BeforeRet;
					}
					LA14: ;
				} LA4: ;
				res_433421 += ((NI) 1);
			} LA3: ;
		}
	}
	}BeforeRet: ;
}

N_NIMCALL(Tnode191813*, semstmtlist_441086)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	NI length;
	NIM_BOOL voidcontext;
	NI last;
{	result = 0;
	result = n;
	(*result).kind = ((NU8) 115);
	length = sonslen_194403(n);
	voidcontext = NIM_FALSE;
	last = (NI)(length - ((NI) 1));
	{
		NI i_441109;
		NI HEX3Atmp_441613;
		NI res_441616;
		i_441109 = 0;
		HEX3Atmp_441613 = 0;
		HEX3Atmp_441613 = (NI)(length - ((NI) 1));
		res_441616 = ((NI) 0);
		{
			while (1) {
				if (!(res_441616 <= HEX3Atmp_441613)) goto LA3;
				i_441109 = res_441616;
				{
					NU8 k;
					k = (*(*n).kindU.S6.sons->data[i_441109]).kind;
					switch (k) {
					case ((NU8) 107):
					case ((NU8) 87):
					case ((NU8) 105):
					{
						Tnode191813* deferpart;
						Tnode191813* trystmt;
						Tnode191813* body;
						deferpart = 0;
						{
							if (!(k == ((NU8) 105))) goto LA8;
							deferpart = newnodei_193351(((NU8) 107), (*(*n).kindU.S6.sons->data[i_441109]).info);
							add_192164(deferpart, (*(*n).kindU.S6.sons->data[i_441109]).kindU.S6.sons->data[((NI) 0)]);
						}
						goto LA6;
						LA8: ;
						{
							if (!(k == ((NU8) 107))) goto LA11;
							message_166188((*n).info, ((NU16) 234), ((NimStringDesc*) &TMP3424));
							deferpart = (*n).kindU.S6.sons->data[i_441109];
						}
						goto LA6;
						LA11: ;
						{
							message_166188((*n).info, ((NU16) 234), ((NimStringDesc*) &TMP3425));
							deferpart = (*n).kindU.S6.sons->data[i_441109];
						}
						LA6: ;
						trystmt = newnodei_193351(((NU8) 106), (*(*n).kindU.S6.sons->data[i_441109]).info);
						body = newnodei_193351(((NU8) 115), (*(*n).kindU.S6.sons->data[i_441109]).info);
						{
							NI LOC16;
							NI LOC19;
							Slice85773 LOC20;
							LOC16 = 0;
							LOC16 = sonslen_194403(n);
							if (!(i_441109 < (NI)(LOC16 - ((NI) 1)))) goto LA17;
							LOC19 = 0;
							LOC19 = len_192097(n);
							LOC20 = HEX2EHEX2E_105273((NI)(i_441109 + ((NI) 1)), (NI)(LOC19 - ((NI) 1)));
							asgnRefNoCycle((void**) (&(*body).kindU.S6.sons), HEX5BHEX5D_432717((*n).kindU.S6.sons, LOC20));
						}
						LA17: ;
						addson_193819(trystmt, body);
						addson_193819(trystmt, deferpart);
						asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_441109]), semtry_434715(c, trystmt));
						(*n).kindU.S6.sons = (Tnodeseq191807*) setLengthSeq(&((*n).kindU.S6.sons)->Sup, sizeof(Tnode191813*), ((NI) ((NI)(i_441109 + ((NI) 1)))));
						asgnRefNoCycle((void**) (&(*n).typ), (*(*n).kindU.S6.sons->data[i_441109]).typ);
						goto BeforeRet;
					}
					break;
					default:
					{
						asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_441109]), semexpr_410201(c, (*n).kindU.S6.sons->data[i_441109], 0));
						{
							NIM_BOOL LOC24;
							Tnode191813* LOC26;
							Tnode191813* LOC29;
							LOC24 = 0;
							LOC24 = (((NI) 0) < (*c).intypeclass);
							if (!(LOC24)) goto LA25;
							LOC26 = 0;
							LOC26 = HEX5BHEX5D_192244(n, i_441109);
							LOC24 = !(((*LOC26).typ == NIM_NIL));
							LA25: ;
							if (!LOC24) goto LA27;
							LOC29 = 0;
							LOC29 = HEX5BHEX5D_192244(n, i_441109);
							switch ((*(*LOC29).typ).kind) {
							case ((NU8) 1):
							{
								Tnode191813* verdict;
								Tnode191813* LOC31;
								LOC31 = 0;
								LOC31 = HEX5BHEX5D_192244(n, i_441109);
								verdict = semconstexpr_411485(c, LOC31);
								{
									if (!((*verdict).kindU.S1.intval == IL64(0))) goto LA34;
									localerror_166166((*result).info, ((NimStringDesc*) &TMP3426));
								}
								LA34: ;
							}
							break;
							case ((NU8) 60):
							{
								goto LA4;
							}
							break;
							default:
							{
							}
							break;
							}
						}
						LA27: ;
						{
							NIM_BOOL LOC40;
							LOC40 = 0;
							LOC40 = ((*(*n).kindU.S6.sons->data[i_441109]).typ == enforcevoidcontext_432005);
							if (LOC40) goto LA41;
							LOC40 = usesresult_441004((*n).kindU.S6.sons->data[i_441109]);
							LA41: ;
							if (!LOC40) goto LA42;
							voidcontext = NIM_TRUE;
							asgnRefNoCycle((void**) (&(*n).typ), enforcevoidcontext_432005);
						}
						LA42: ;
						{
							NIM_BOOL LOC46;
							NIM_BOOL LOC48;
							LOC46 = 0;
							LOC46 = (i_441109 == last);
							if (!(LOC46)) goto LA47;
							LOC48 = 0;
							LOC48 = (length == ((NI) 1));
							if (LOC48) goto LA49;
							LOC48 = ((flags &(1<<((((NU8) 7))&15)))!=0);
							LA49: ;
							LOC46 = LOC48;
							LA47: ;
							if (!LOC46) goto LA50;
							asgnRefNoCycle((void**) (&(*n).typ), (*(*n).kindU.S6.sons->data[i_441109]).typ);
							{
								NIM_BOOL LOC54;
								LOC54 = 0;
								LOC54 = isemptytype_196934((*n).typ);
								if (!!(LOC54)) goto LA55;
								(*n).kind = ((NU8) 126);
							}
							LA55: ;
						}
						goto LA44;
						LA50: ;
						{
							NIM_BOOL LOC58;
							LOC58 = 0;
							LOC58 = !((i_441109 == last));
							if (LOC58) goto LA59;
							LOC58 = voidcontext;
							LA59: ;
							if (!LOC58) goto LA60;
							discardcheck_433756(c, (*n).kindU.S6.sons->data[i_441109]);
						}
						goto LA44;
						LA60: ;
						{
							asgnRefNoCycle((void**) (&(*n).typ), (*(*n).kindU.S6.sons->data[i_441109]).typ);
							{
								NIM_BOOL LOC65;
								LOC65 = 0;
								LOC65 = isemptytype_196934((*n).typ);
								if (!!(LOC65)) goto LA66;
								(*n).kind = ((NU8) 126);
							}
							LA66: ;
						}
						LA44: ;
						switch ((*(*n).kindU.S6.sons->data[i_441109]).kind) {
						case ((NU8) 99):
						case ((NU8) 100):
						{
							TY433269 LOC69;
							Tnode191813* outer;
							Tnode191813* inner;
							memset((void*)(&LOC69), 0, sizeof(LOC69));
							insertdestructors_433265(c, (*n).kindU.S6.sons->data[i_441109], (&LOC69));
							outer = 0;
							outer = LOC69.Field0;
							inner = 0;
							inner = LOC69.Field1;
							{
								Tnode191813* rest;
								Slice85773 LOC74;
								Tnodeseq191807* LOC75;
								Tnode191813* LOC76;
								if (!!((outer == NIM_NIL))) goto LA72;
								asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_441109]), outer);
								LOC74 = HEX2EHEX2E_105273((NI)(i_441109 + ((NI) 1)), (NI)(length - ((NI) 1)));
								LOC75 = 0;
								LOC75 = HEX5BHEX5D_432717((*n).kindU.S6.sons, LOC74);
								rest = newnode_193607(((NU8) 115), (*n).info, LOC75, NIM_NIL);
								LOC76 = 0;
								LOC76 = semstmtlist_441086(c, rest, flags);
								addson_193819(inner, LOC76);
								(*n).kindU.S6.sons = (Tnodeseq191807*) setLengthSeq(&((*n).kindU.S6.sons)->Sup, sizeof(Tnode191813*), ((NI) ((NI)(i_441109 + ((NI) 1)))));
								goto BeforeRet;
							}
							LA72: ;
						}
						break;
						case ((NU8) 108):
						case ((NU8) 109):
						case ((NU8) 110):
						case ((NU8) 111):
						{
							{
								NI j_441289;
								NI HEX3Atmp_441605;
								NI HEX3Atmp_441606;
								NI res_441609;
								j_441289 = 0;
								HEX3Atmp_441605 = 0;
								HEX3Atmp_441606 = 0;
								HEX3Atmp_441605 = (NI)(i_441109 + ((NI) 1));
								HEX3Atmp_441606 = (NI)(length - ((NI) 1));
								res_441609 = HEX3Atmp_441605;
								{
									while (1) {
										if (!(res_441609 <= HEX3Atmp_441606)) goto LA80;
										j_441289 = res_441609;
										switch ((*(*n).kindU.S6.sons->data[j_441289]).kind) {
										case ((NU8) 90):
										case ((NU8) 125):
										case ((NU8) 23):
										case ((NU8) 1):
										{
										}
										break;
										default:
										{
											localerror_166155((*(*n).kindU.S6.sons->data[j_441289]).info, ((NU16) 41), ((NimStringDesc*) &TMP2991));
										}
										break;
										}
										res_441609 += ((NI) 1);
									} LA80: ;
								}
							}
						}
						break;
						default:
						{
						}
						break;
						}
					}
					break;
					}
				} LA4: ;
				res_441616 += ((NI) 1);
			} LA3: ;
		}
	}
	{
		NI LOC86;
		LOC86 = 0;
		LOC86 = len_192097(result);
		if (!(LOC86 == ((NI) 1))) goto LA87;
		result = (*result).kindU.S6.sons->data[((NI) 0)];
	}
	LA87: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semraise_438101)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = n;
	checksonslen_246249(n, ((NI) 1));
	{
		Ttype191849* typ;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA3;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 0)], 0));
		typ = (*(*n).kindU.S6.sons->data[((NI) 0)]).typ;
		{
			NIM_BOOL LOC7;
			LOC7 = 0;
			LOC7 = !(((*typ).kind == ((NU8) 22)));
			if (LOC7) goto LA8;
			LOC7 = !(((*(*typ).sons->data[((NI) 0)]).kind == ((NU8) 17)));
			LA8: ;
			if (!LOC7) goto LA9;
			localerror_166155((*n).info, ((NU16) 112), ((NimStringDesc*) &TMP2991));
		}
		LA9: ;
	}
	LA3: ;
	return result;
}

N_NIMCALL(void, addtovarsection_436306)(Tcontext245023* c, Tnode191813** result, Tnode191813* orig, Tnode191813* identdefs) {
	NI L;
	Tnode191813* value;
	L = len_192097(identdefs);
	value = HEX5BHEX5D_192244(identdefs, (NI)(L - ((NI) 1)));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = !(((*value).typ == NIM_NIL));
		if (!(LOC3)) goto LA4;
		LOC3 = (((*(*value).typ).flags &(1<<((((NU8) 26))&31)))!=0);
		LA4: ;
		if (!LOC3) goto LA5;
		asgnRefNoCycle((void**) (&(*identdefs).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), emptynode_192807);
		{
			Tnode191813* oldresult;
			if (!!(((*(*result)).kind == ((NU8) 115)))) goto LA9;
			oldresult = (*result);
			add_192164(oldresult, identdefs);
			unsureAsgnRef((void**) (&(*result)), newnodei_193351(((NU8) 115), (*(*result)).info));
			add_192164((*result), oldresult);
		}
		goto LA7;
		LA9: ;
		{
			Tnode191813* o;
			o = copynode_195640(orig);
			add_192164(o, identdefs);
			add_192164((*result), o);
		}
		LA7: ;
		{
			NI i_436364;
			NI HEX3Atmp_436380;
			NI res_436383;
			i_436364 = 0;
			HEX3Atmp_436380 = 0;
			HEX3Atmp_436380 = (NI)(L - ((NI) 3));
			res_436383 = ((NI) 0);
			{
				while (1) {
					Tnode191813* LOC15;
					Tnode191813* LOC16;
					if (!(res_436383 <= HEX3Atmp_436380)) goto LA14;
					i_436364 = res_436383;
					LOC15 = 0;
					LOC15 = HEX5BHEX5D_192244(identdefs, i_436364);
					LOC16 = 0;
					LOC16 = overloadedasgn_436296(c, LOC15, value);
					add_192164((*result), LOC16);
					res_436383 += ((NI) 1);
				} LA14: ;
			}
		}
	}
	goto LA1;
	LA5: ;
	{
		Tnode191813* o;
		if (!((*(*result)).kind == ((NU8) 115))) goto LA18;
		o = copynode_195640(orig);
		add_192164(o, identdefs);
		add_192164((*result), o);
	}
	goto LA1;
	LA18: ;
	{
		add_192164((*result), identdefs);
	}
	LA1: ;
}

N_NIMCALL(NIM_BOOL, isdiscardunderscore_436399)(Tsym191843* v) {
	NIM_BOOL result;
	result = 0;
	{
		if (!eqStrings((*(*v).name).s, ((NimStringDesc*) &TMP3429))) goto LA3;
		(*v).flags |= ((NI32)1)<<((((NU8) 31))%(sizeof(NI32)*8));
		result = NIM_TRUE;
	}
	LA3: ;
	return result;
}

N_NIMCALL(Tsym191843*, findshadowedvar_435035)(Tcontext245023* c, Tsym191843* v) {
	Tsym191843* result;
{	result = 0;
	{
		Tscope191837* scope_435040;
		Tscope191837* HEX3Atmp_435077;
		Tscope191837* current_435080;
		scope_435040 = 0;
		HEX3Atmp_435077 = 0;
		HEX3Atmp_435077 = (*(*c).currentscope).parent;
		current_435080 = HEX3Atmp_435077;
		{
			while (1) {
				Tsym191843* shadowed;
				if (!!((current_435080 == NIM_NIL))) goto LA3;
				scope_435040 = current_435080;
				{
					if (!(scope_435040 == (*c).toplevelscope)) goto LA6;
					goto LA1;
				}
				LA6: ;
				shadowed = strtableget_199111((*scope_435040).symbols, (*v).name);
				{
					NIM_BOOL LOC10;
					LOC10 = 0;
					LOC10 = !((shadowed == NIM_NIL));
					if (!(LOC10)) goto LA11;
					LOC10 = ((2099976 &(1<<(((*shadowed).kind)&31)))!=0);
					LA11: ;
					if (!LOC10) goto LA12;
					result = shadowed;
					goto BeforeRet;
				}
				LA12: ;
				current_435080 = (*current_435080).parent;
			} LA3: ;
		}
	} LA1: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, identwithin_435093)(Tnode191813* n, Tident168021* s) {
	NIM_BOOL result;
	NIM_BOOL LOC10;
{	result = 0;
	{
		NI i_435109;
		NI HEX3Atmp_435123;
		NI LOC2;
		NI res_435126;
		i_435109 = 0;
		HEX3Atmp_435123 = 0;
		LOC2 = 0;
		LOC2 = safelen_192125(n);
		HEX3Atmp_435123 = (NI)(LOC2 - ((NI) 1));
		res_435126 = ((NI) 0);
		{
			while (1) {
				if (!(res_435126 <= HEX3Atmp_435123)) goto LA4;
				i_435109 = res_435126;
				{
					NIM_BOOL LOC7;
					LOC7 = 0;
					LOC7 = identwithin_435093((*n).kindU.S6.sons->data[i_435109], s);
					if (!LOC7) goto LA8;
					result = NIM_TRUE;
					goto BeforeRet;
				}
				LA8: ;
				res_435126 += ((NI) 1);
			} LA4: ;
		}
	}
	LOC10 = 0;
	LOC10 = ((*n).kind == ((NU8) 3));
	if (!(LOC10)) goto LA11;
	LOC10 = ((*(*(*n).kindU.S4.sym).name).Sup.id == (*s).Sup.id);
	LA11: ;
	result = LOC10;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, checknilable_435204)(Tsym191843* v) {
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = (((*v).flags &(1<<((((NU8) 3))&31)))!=0);
		if (!(LOC3)) goto LA4;
		LOC3 = !(((196608 & (*(*v).typ).flags) == 0));
		LA4: ;
		if (!LOC3) goto LA5;
		{
			if (!(*v).ast == 0) goto LA9;
			message_166188((*v).info, ((NU16) 250), (*(*v).name).s);
		}
		goto LA7;
		LA9: ;
		{
			NIM_BOOL LOC12;
			LOC12 = 0;
			LOC12 = (((*(*v).typ).flags &(1<<((((NU8) 16))&31)))!=0);
			if (!(LOC12)) goto LA13;
			LOC12 = !((((*(*(*v).ast).typ).flags &(1<<((((NU8) 16))&31)))!=0));
			LA13: ;
			if (!LOC12) goto LA14;
			message_166188((*v).info, ((NU16) 250), (*(*v).name).s);
		}
		goto LA7;
		LA14: ;
		LA7: ;
	}
	LA5: ;
}

N_NIMCALL(Tnode191813*, semvarorlet_436418)(Tcontext245023* c, Tnode191813* n, NU8 symkind) {
	Tnode191813* result;
	Tnode191813* b;
	NIM_BOOL hascompiletime;
	result = 0;
	b = 0;
	result = copynode_195640(n);
	hascompiletime = NIM_FALSE;
	{
		NI i_436438;
		NI HEX3Atmp_436951;
		NI LOC2;
		NI res_436954;
		i_436438 = 0;
		HEX3Atmp_436951 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_436951 = (NI)(LOC2 - ((NI) 1));
		res_436954 = ((NI) 0);
		{
			while (1) {
				if (!(res_436954 <= HEX3Atmp_436951)) goto LA4;
				i_436438 = res_436954;
				{
					Tnode191813* a;
					NI length;
					Ttype191849* typ;
					Tnode191813* def;
					Ttype191849* tup;
					a = (*n).kindU.S6.sons->data[i_436438];
					{
						if (!(gcmd_155130 == ((NU8) 14))) goto LA8;
						suggeststmt_355301(c, a);
					}
					LA8: ;
					{
						if (!((*a).kind == ((NU8) 125))) goto LA12;
						goto LA5;
					}
					LA12: ;
					{
						if (!!(((*a).kind == ((NU8) 35) || (*a).kind == ((NU8) 36) || (*a).kind == ((NU8) 102)))) goto LA16;
						illformedast_246229(a);
					}
					LA16: ;
					checkminsonslen_246259(a, ((NI) 3));
					length = sonslen_194403(a);
					typ = 0;
					{
						if (!!(((*(*a).kindU.S6.sons->data[(NI)(length - ((NI) 2))]).kind == ((NU8) 1)))) goto LA20;
						typ = semtypenode_410269(c, (*a).kindU.S6.sons->data[(NI)(length - ((NI) 2))], NIM_NIL);
					}
					goto LA18;
					LA20: ;
					{
						typ = NIM_NIL;
					}
					LA18: ;
					def = 0;
					{
						if (!!(((*(*a).kindU.S6.sons->data[(NI)(length - ((NI) 1))]).kind == ((NU8) 1)))) goto LA25;
						def = semexprwithtype_410211(c, (*a).kindU.S6.sons->data[(NI)(length - ((NI) 1))], 64);
						{
							NIM_BOOL LOC29;
							LOC29 = 0;
							LOC29 = ((*(*def).typ).kind == ((NU8) 8));
							if (!(LOC29)) goto LA30;
							LOC29 = !(((*(*(*c).p).owner).kind == ((NU8) 17)));
							LA30: ;
							if (!LOC29) goto LA31;
							localerror_166166((*def).info, ((NimStringDesc*) &TMP3427));
							asgnRefNoCycle((void**) (&(*def).typ), errortype_246150(c));
						}
						LA31: ;
						{
							if (!!((typ == NIM_NIL))) goto LA35;
							{
								NIM_BOOL LOC39;
								LOC39 = 0;
								LOC39 = ismetatype_192821(typ);
								if (!LOC39) goto LA40;
								def = inferwithmetatype_410463(c, typ, def, NIM_FALSE);
								typ = (*def).typ;
							}
							goto LA37;
							LA40: ;
							{
								def = fitnode_410245(c, typ, def);
							}
							LA37: ;
						}
						goto LA33;
						LA35: ;
						{
							typ = skipintlit_239698((*def).typ);
							{
								NIM_BOOL LOC46;
								Ttype191849* LOC48;
								NimStringDesc* LOC51;
								NimStringDesc* LOC52;
								LOC46 = 0;
								LOC46 = ((17367040 &(IL64(1)<<(((*typ).kind)&IL64(63))))!=0);
								if (!(LOC46)) goto LA47;
								LOC48 = 0;
								LOC48 = lastson_194442(typ);
								LOC46 = ((*LOC48).kind == ((NU8) 3));
								LA47: ;
								if (!LOC46) goto LA49;
								LOC51 = 0;
								LOC51 = copyStr(reprEnum((*typ).kind, (&NTI191260)), ((NI) 2));
								LOC52 = 0;
								LOC52 = nsuToLowerStr(LOC51);
								localerror_166155((*def).info, ((NU16) 225), LOC52);
							}
							LA49: ;
						}
						LA33: ;
					}
					goto LA23;
					LA25: ;
					{
						def = emptynode_192807;
						{
							if (!(symkind == ((NU8) 9))) goto LA56;
							localerror_166155((*a).info, ((NU16) 219), ((NimStringDesc*) &TMP2991));
						}
						LA56: ;
					}
					LA23: ;
					{
						if (!(typ == NIM_NIL)) goto LA60;
						goto LA5;
					}
					LA60: ;
					typeallowedcheck_410980((*a).info, typ, symkind);
					tup = skiptypes_195167(typ, 2048);
					{
						if (!((*a).kind == ((NU8) 36))) goto LA64;
						{
							if (!!(((*tup).kind == ((NU8) 18)))) goto LA68;
							localerror_166155((*a).info, ((NU16) 188), ((NimStringDesc*) &TMP3428));
						}
						goto LA66;
						LA68: ;
						{
							NI LOC71;
							LOC71 = 0;
							LOC71 = sonslen_194351(tup);
							if (!!(((NI)(length - ((NI) 2)) == LOC71))) goto LA72;
							localerror_166155((*a).info, ((NU16) 111), ((NimStringDesc*) &TMP2991));
						}
						goto LA66;
						LA72: ;
						{
							b = newnodei_193351(((NU8) 36), (*a).info);
							newsons_194272(b, length);
							asgnRefNoCycle((void**) (&(*b).kindU.S6.sons->data[(NI)(length - ((NI) 2))]), (*a).kindU.S6.sons->data[(NI)(length - ((NI) 2))]);
							asgnRefNoCycle((void**) (&(*b).kindU.S6.sons->data[(NI)(length - ((NI) 1))]), def);
							addtovarsection_436306(c, &result, n, b);
						}
						LA66: ;
					}
					goto LA62;
					LA64: ;
					{
						NIM_BOOL LOC76;
						NIM_BOOL LOC77;
						NIM_BOOL LOC78;
						NI LOC82;
						LOC76 = 0;
						LOC77 = 0;
						LOC78 = 0;
						LOC78 = ((*tup).kind == ((NU8) 18));
						if (!(LOC78)) goto LA79;
						LOC78 = ((*def).kind == ((NU8) 37));
						LA79: ;
						LOC77 = LOC78;
						if (!(LOC77)) goto LA80;
						LOC77 = ((*a).kind == ((NU8) 35));
						LA80: ;
						LOC76 = LOC77;
						if (!(LOC76)) goto LA81;
						LOC82 = 0;
						LOC82 = len_192097(a);
						LOC76 = (((NI) 3) < LOC82);
						LA81: ;
						if (!LOC76) goto LA83;
						message_166188((*a).info, ((NU16) 248), ((NimStringDesc*) &TMP2991));
					}
					goto LA62;
					LA83: ;
					LA62: ;
					{
						NI j_436638;
						NI HEX3Atmp_436944;
						NI res_436947;
						j_436638 = 0;
						HEX3Atmp_436944 = 0;
						HEX3Atmp_436944 = (NI)(length - ((NI) 3));
						res_436947 = ((NI) 0);
						{
							while (1) {
								Tsym191843* v;
								if (!(res_436947 <= HEX3Atmp_436944)) goto LA87;
								j_436638 = res_436947;
								v = semidentdef_435142(c, (*a).kindU.S6.sons->data[j_436638], symkind);
								{
									NIM_BOOL LOC90;
									NIM_BOOL LOC92;
									LOC90 = 0;
									LOC90 = !((((*v).flags &(1<<((((NU8) 31))&31)))!=0));
									if (!(LOC90)) goto LA91;
									LOC92 = 0;
									LOC92 = isdiscardunderscore_436399(v);
									LOC90 = !(LOC92);
									LA91: ;
									if (!LOC90) goto LA93;
									addinterfacedecl_250736(c, v);
								}
								LA93: ;
								{
									if (!(((NI) 0) < (*c).inunrolledcontext)) goto LA97;
									(*v).flags |= ((NI32)1)<<((((NU8) 21))%(sizeof(NI32)*8));
								}
								goto LA95;
								LA97: ;
								{
									Tsym191843* shadowed;
									shadowed = findshadowedvar_435035(c, v);
									{
										if (!!((shadowed == NIM_NIL))) goto LA102;
										(*shadowed).flags |= ((NI32)1)<<((((NU8) 21))%(sizeof(NI32)*8));
										{
											NIM_BOOL LOC106;
											LOC106 = 0;
											LOC106 = ((*shadowed).kind == ((NU8) 11));
											if (!(LOC106)) goto LA107;
											LOC106 = !((((*v).flags &(1<<((((NU8) 31))&31)))!=0));
											LA107: ;
											if (!LOC106) goto LA108;
											message_166188((*a).info, ((NU16) 259), ((NimStringDesc*) &TMP2991));
										}
										LA108: ;
										{
											NIM_BOOL LOC112;
											NIM_BOOL LOC114;
											LOC112 = 0;
											LOC112 = ((gnotes_165011 &(IL64(1)<<(((((NU16) 249)- 230))&IL64(63))))!=0);
											if (!(LOC112)) goto LA113;
											LOC114 = 0;
											LOC114 = identwithin_435093(def, (*v).name);
											LOC112 = !(LOC114);
											LA113: ;
											if (!LOC112) goto LA115;
											message_166188((*a).info, ((NU16) 249), (*(*v).name).s);
										}
										LA115: ;
									}
									LA102: ;
								}
								LA95: ;
								{
									Tnode191813* LOC137;
									Tnode191813* LOC138;
									if (!!(((*a).kind == ((NU8) 36)))) goto LA119;
									{
										NIM_BOOL LOC123;
										LOC123 = 0;
										LOC123 = !((def == NIM_NIL));
										if (!(LOC123)) goto LA124;
										LOC123 = !(((*def).kind == ((NU8) 1)));
										LA124: ;
										if (!LOC123) goto LA125;
										asgnRefNoCycle((void**) (&(*v).ast), def);
										{
											if (!(((*v).flags &(1<<((((NU8) 22))&31)))!=0)) goto LA129;
											localerror_166155((*def).info, ((NU16) 220), ((NimStringDesc*) &TMP2991));
										}
										LA129: ;
									}
									LA125: ;
									asgnRefNoCycle((void**) (&(*v).typ), typ);
									b = newnodei_193351(((NU8) 35), (*a).info);
									{
										NIM_BOOL LOC133;
										NimStringDesc* LOC136;
										LOC133 = 0;
										LOC133 = importantcomments_155164();
										if (!LOC133) goto LA134;
										LOC136 = 0;
										LOC136 = (*b).comment; (*b).comment = copyStringRC1((*a).comment);
										if (LOC136) nimGCunrefNoCycle(LOC136);
									}
									LA134: ;
									LOC137 = 0;
									LOC137 = newsymnode_193325(v);
									addson_193819(b, LOC137);
									addson_193819(b, (*a).kindU.S6.sons->data[(NI)(length - ((NI) 2))]);
									LOC138 = 0;
									LOC138 = copytree_196028(def);
									addson_193819(b, LOC138);
									addtovarsection_436306(c, &result, n, b);
								}
								goto LA117;
								LA119: ;
								{
									{
										if (!((*def).kind == ((NU8) 37))) goto LA142;
										asgnRefNoCycle((void**) (&(*v).ast), HEX5BHEX5D_192244(def, j_436638));
									}
									LA142: ;
									asgnRefNoCycle((void**) (&(*v).typ), (*tup).sons->data[j_436638]);
									asgnRefNoCycle((void**) (&(*b).kindU.S6.sons->data[j_436638]), newsymnode_193325(v));
								}
								LA117: ;
								checknilable_435204(v);
								{
									if (!(((*v).flags &(1<<((((NU8) 23))&31)))!=0)) goto LA146;
									hascompiletime = NIM_TRUE;
								}
								LA146: ;
								res_436947 += ((NI) 1);
							} LA87: ;
						}
					}
				} LA5: ;
				res_436954 += ((NI) 1);
			} LA4: ;
		}
	}
	{
		if (!hascompiletime) goto LA150;
		setupcompiletimevar_398855((*c).module, result);
	}
	LA150: ;
	return result;
}

N_NIMCALL(Tnode191813*, fitremovehiddenconv_435013)(Tcontext245023* c, Ttype191849* typ, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = fitnode_410245(c, typ, n);
	{
		if (!((*result).kind == ((NU8) 58) || (*result).kind == ((NU8) 59))) goto LA3;
		changetype_410253((*result).kindU.S6.sons->data[((NI) 1)], typ, NIM_TRUE);
		result = (*result).kindU.S6.sons->data[((NI) 1)];
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC6;
		LOC6 = 0;
		LOC6 = sametype_226092((*result).typ, typ, 0);
		if (!!(LOC6)) goto LA7;
		changetype_410253(result, typ, NIM_FALSE);
	}
	goto LA1;
	LA7: ;
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semconst_436982)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = copynode_195640(n);
	{
		NI i_436999;
		NI HEX3Atmp_437124;
		NI LOC2;
		NI res_437127;
		i_436999 = 0;
		HEX3Atmp_437124 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_437124 = (NI)(LOC2 - ((NI) 1));
		res_437127 = ((NI) 0);
		{
			while (1) {
				if (!(res_437127 <= HEX3Atmp_437124)) goto LA4;
				i_436999 = res_437127;
				{
					Tnode191813* a;
					Tsym191843* v;
					Ttype191849* typ;
					Tnode191813* def;
					Tnode191813* b;
					Tnode191813* LOC53;
					Tnode191813* LOC54;
					a = (*n).kindU.S6.sons->data[i_436999];
					{
						if (!(gcmd_155130 == ((NU8) 14))) goto LA8;
						suggeststmt_355301(c, a);
					}
					LA8: ;
					{
						if (!((*a).kind == ((NU8) 125))) goto LA12;
						goto LA5;
					}
					LA12: ;
					{
						if (!!(((*a).kind == ((NU8) 102)))) goto LA16;
						illformedast_246229(a);
					}
					LA16: ;
					checksonslen_246249(a, ((NI) 3));
					v = semidentdef_435142(c, (*a).kindU.S6.sons->data[((NI) 0)], ((NU8) 10));
					typ = NIM_NIL;
					{
						if (!!(((*(*a).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1)))) goto LA20;
						typ = semtypenode_410269(c, (*a).kindU.S6.sons->data[((NI) 1)], NIM_NIL);
					}
					LA20: ;
					def = semconstexpr_411485(c, (*a).kindU.S6.sons->data[((NI) 2)]);
					{
						if (!(def == NIM_NIL)) goto LA24;
						localerror_166155((*(*a).kindU.S6.sons->data[((NI) 2)]).info, ((NU16) 104), ((NimStringDesc*) &TMP2991));
						goto LA5;
					}
					LA24: ;
					{
						if (!!((typ == NIM_NIL))) goto LA28;
						def = fitremovehiddenconv_435013(c, typ, def);
					}
					goto LA26;
					LA28: ;
					{
						typ = (*def).typ;
					}
					LA26: ;
					{
						if (!(typ == NIM_NIL)) goto LA33;
						localerror_166155((*(*a).kindU.S6.sons->data[((NI) 2)]).info, ((NU16) 104), ((NimStringDesc*) &TMP2991));
						goto LA5;
					}
					LA33: ;
					{
						NIM_BOOL LOC37;
						Ttype191849* LOC38;
						NimStringDesc* LOC42;
						LOC37 = 0;
						LOC38 = 0;
						LOC38 = typeallowed_229654(typ, ((NU8) 10));
						LOC37 = !((LOC38 == NIM_NIL));
						if (!(LOC37)) goto LA39;
						LOC37 = !(((*def).kind == ((NU8) 23)));
						LA39: ;
						if (!LOC37) goto LA40;
						LOC42 = 0;
						LOC42 = typetostring_221032(typ, ((NU8) 0));
						localerror_166155((*a).info, ((NU16) 165), LOC42);
						goto LA5;
					}
					LA40: ;
					asgnRefNoCycle((void**) (&(*v).typ), typ);
					asgnRefNoCycle((void**) (&(*v).ast), def);
					{
						if (!!((((*v).flags &(1<<((((NU8) 31))&31)))!=0))) goto LA45;
						addinterfacedecl_250736(c, v);
					}
					LA45: ;
					b = newnodei_193351(((NU8) 102), (*a).info);
					{
						NIM_BOOL LOC49;
						NimStringDesc* LOC52;
						LOC49 = 0;
						LOC49 = importantcomments_155164();
						if (!LOC49) goto LA50;
						LOC52 = 0;
						LOC52 = (*b).comment; (*b).comment = copyStringRC1((*a).comment);
						if (LOC52) nimGCunrefNoCycle(LOC52);
					}
					LA50: ;
					LOC53 = 0;
					LOC53 = newsymnode_193325(v);
					addson_193819(b, LOC53);
					addson_193819(b, (*a).kindU.S6.sons->data[((NI) 1)]);
					LOC54 = 0;
					LOC54 = copytree_196028(def);
					addson_193819(b, LOC54);
					addson_193819(result, b);
				} LA5: ;
				res_437127 += ((NI) 1);
			} LA4: ;
		}
	}
	return result;
}

N_NIMCALL(void, typesectionleftsidepass_438199)(Tcontext245023* c, Tnode191813* n) {
	{
		NI i_438215;
		NI HEX3Atmp_438275;
		NI LOC2;
		NI res_438278;
		i_438215 = 0;
		HEX3Atmp_438275 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_438275 = (NI)(LOC2 - ((NI) 1));
		res_438278 = ((NI) 0);
		{
			while (1) {
				if (!(res_438278 <= HEX3Atmp_438275)) goto LA4;
				i_438215 = res_438278;
				{
					Tnode191813* a;
					Tsym191843* s;
					a = (*n).kindU.S6.sons->data[i_438215];
					{
						if (!(gcmd_155130 == ((NU8) 14))) goto LA8;
						suggeststmt_355301(c, a);
					}
					LA8: ;
					{
						if (!((*a).kind == ((NU8) 125))) goto LA12;
						goto LA5;
					}
					LA12: ;
					{
						if (!!(((*a).kind == ((NU8) 103)))) goto LA16;
						illformedast_246229(a);
					}
					LA16: ;
					checksonslen_246249(a, ((NI) 3));
					s = semidentdef_435142(c, (*a).kindU.S6.sons->data[((NI) 0)], ((NU8) 7));
					asgnRefNoCycle((void**) (&(*s).typ), newtypes_245218(((NU8) 30), c));
					asgnRefNoCycle((void**) (&(*(*s).typ).sym), s);
					{
						if (!((*(*a).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 43))) goto LA20;
						pragma_261069(c, s, (*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data[((NI) 1)], TMP3383);
					}
					LA20: ;
					{
						if (!!((((*s).flags &(1<<((((NU8) 31))&31)))!=0))) goto LA24;
						addinterfacedecl_250736(c, s);
					}
					LA24: ;
					asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(s));
				} LA5: ;
				res_438278 += ((NI) 1);
			} LA4: ;
		}
	}
}

N_NIMCALL(void, setmagictype_422877)(Tsym191843* m, NU8 kind, NI size) {
	(*(*m).typ).kind = kind;
	(*(*m).typ).align = ((NI16) (size));
	(*(*m).typ).size = ((NI64) (size));
}

N_NIMCALL(void, processmagictype_422888)(Tcontext245023* c, Tsym191843* m) {
	switch ((*m).magic) {
	case ((NU16) 183):
	{
		setmagictype_422877(m, ((NU8) 31), intsize_160623);
	}
	break;
	case ((NU16) 184):
	{
		setmagictype_422877(m, ((NU8) 32), ((NI) 1));
	}
	break;
	case ((NU16) 185):
	{
		setmagictype_422877(m, ((NU8) 33), ((NI) 2));
	}
	break;
	case ((NU16) 186):
	{
		setmagictype_422877(m, ((NU8) 34), ((NI) 4));
	}
	break;
	case ((NU16) 187):
	{
		setmagictype_422877(m, ((NU8) 35), ((NI) 8));
	}
	break;
	case ((NU16) 188):
	{
		setmagictype_422877(m, ((NU8) 40), intsize_160623);
	}
	break;
	case ((NU16) 189):
	{
		setmagictype_422877(m, ((NU8) 41), ((NI) 1));
	}
	break;
	case ((NU16) 190):
	{
		setmagictype_422877(m, ((NU8) 42), ((NI) 2));
	}
	break;
	case ((NU16) 191):
	{
		setmagictype_422877(m, ((NU8) 43), ((NI) 4));
	}
	break;
	case ((NU16) 192):
	{
		setmagictype_422877(m, ((NU8) 44), ((NI) 8));
	}
	break;
	case ((NU16) 193):
	{
		setmagictype_422877(m, ((NU8) 36), floatsize_160624);
	}
	break;
	case ((NU16) 194):
	{
		setmagictype_422877(m, ((NU8) 37), ((NI) 4));
	}
	break;
	case ((NU16) 195):
	{
		setmagictype_422877(m, ((NU8) 38), ((NI) 8));
	}
	break;
	case ((NU16) 196):
	{
		setmagictype_422877(m, ((NU8) 39), ((NI) 16));
	}
	break;
	case ((NU16) 197):
	{
		setmagictype_422877(m, ((NU8) 1), ((NI) 1));
	}
	break;
	case ((NU16) 198):
	{
		setmagictype_422877(m, ((NU8) 2), ((NI) 1));
	}
	break;
	case ((NU16) 199):
	{
		Ttype191849* LOC18;
		setmagictype_422877(m, ((NU8) 28), ptrsize_160625);
		LOC18 = 0;
		LOC18 = getsystype_239030(((NU8) 2));
		rawaddson_195478((*m).typ, LOC18);
	}
	break;
	case ((NU16) 200):
	{
		Ttype191849* LOC20;
		setmagictype_422877(m, ((NU8) 29), ptrsize_160625);
		LOC20 = 0;
		LOC20 = getsystype_239030(((NU8) 2));
		rawaddson_195478((*m).typ, LOC20);
	}
	break;
	case ((NU16) 201):
	{
		setmagictype_422877(m, ((NU8) 26), ptrsize_160625);
	}
	break;
	case ((NU16) 202):
	{
		Ttype191849* LOC23;
		setmagictype_422877(m, ((NU8) 19), ((NI) 1));
		LOC23 = 0;
		LOC23 = newtypes_245218(((NU8) 3), c);
		rawaddson_195478((*m).typ, LOC23);
	}
	break;
	case ((NU16) 203):
	{
		setmagictype_422877(m, ((NU8) 20), intsize_160623);
	}
	break;
	case ((NU16) 204):
	{
		setmagictype_422877(m, ((NU8) 5), ptrsize_160625);
	}
	break;
	case ((NU16) 205):
	{
		setmagictype_422877(m, ((NU8) 6), ((NI) 0));
	}
	break;
	case ((NU16) 206):
	{
		setmagictype_422877(m, ((NU8) 7), ((NI) 0));
	}
	break;
	case ((NU16) 207):
	{
		Ttype191849* LOC29;
		setmagictype_422877(m, ((NU8) 8), ((NI) 0));
		LOC29 = 0;
		LOC29 = newtypes_245218(((NU8) 0), c);
		rawaddson_195478((*m).typ, LOC29);
	}
	break;
	case ((NU16) 208):
	{
		setmagictype_422877(m, ((NU8) 3), ((NI) 0));
	}
	break;
	case ((NU16) 176):
	{
		setmagictype_422877(m, ((NU8) 16), ((NI) 0));
	}
	break;
	case ((NU16) 177):
	{
		setmagictype_422877(m, ((NU8) 27), ((NI) 0));
	}
	break;
	case ((NU16) 181):
	{
		setmagictype_422877(m, ((NU8) 48), ((NI) 0));
	}
	break;
	case ((NU16) 178):
	{
		Ttype191849* LOC35;
		setmagictype_422877(m, ((NU8) 20), ((NI) 0));
		LOC35 = 0;
		LOC35 = newtypes_245218(((NU8) 0), c);
		rawaddson_195478((*m).typ, LOC35);
	}
	break;
	case ((NU16) 179):
	{
		setmagictype_422877(m, ((NU8) 19), ((NI) 0));
	}
	break;
	case ((NU16) 180):
	{
		setmagictype_422877(m, ((NU8) 24), ((NI) 0));
	}
	break;
	case ((NU16) 182):
	{
		Ttype191849* LOC39;
		setmagictype_422877(m, ((NU8) 15), ((NI) 0));
		LOC39 = 0;
		LOC39 = newtypes_245218(((NU8) 0), c);
		rawaddson_195478((*m).typ, LOC39);
	}
	break;
	case ((NU16) 209):
	{
	}
	break;
	case ((NU16) 210):
	{
		setmagictype_422877(m, ((NU8) 17), ((NI) 0));
		asgnRefNoCycle((void**) (&(*(*m).typ).n), newnodei_193351(((NU8) 138), (*m).info));
		(*(*m).typ).flags |= ((NI32)1)<<((((NU8) 15))%(sizeof(NI32)*8));
	}
	break;
	case ((NU16) 211):
	{
		Ttype191849* LOC43;
		setmagictype_422877(m, ((NU8) 17), ((NI) 0));
		asgnRefNoCycle((void**) (&(*(*m).typ).n), newnodei_193351(((NU8) 138), (*m).info));
		(*(*m).typ).flags |= ((NI32)1)<<((((NU8) 15))%(sizeof(NI32)*8));
		LOC43 = 0;
		LOC43 = systypefromname_239213(((NimStringDesc*) &TMP3430));
		rawaddson_195478((*m).typ, LOC43);
	}
	break;
	default:
	{
		localerror_166155((*m).info, ((NU16) 63), ((NimStringDesc*) &TMP2991));
	}
	break;
	}
}

N_NIMCALL(void, typesectionrightsidepass_438297)(Tcontext245023* c, Tnode191813* n) {
	{
		NI i_438313;
		NI HEX3Atmp_438558;
		NI LOC2;
		NI res_438561;
		i_438313 = 0;
		HEX3Atmp_438558 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_438558 = (NI)(LOC2 - ((NI) 1));
		res_438561 = ((NI) 0);
		{
			while (1) {
				if (!(res_438561 <= HEX3Atmp_438558)) goto LA4;
				i_438313 = res_438561;
				{
					Tnode191813* a;
					Tsym191843* s;
					Tnode191813* aa;
					a = (*n).kindU.S6.sons->data[i_438313];
					{
						if (!((*a).kind == ((NU8) 125))) goto LA8;
						goto LA5;
					}
					LA8: ;
					{
						if (!!(((*a).kind == ((NU8) 103)))) goto LA12;
						illformedast_246229(a);
					}
					LA12: ;
					checksonslen_246249(a, ((NI) 3));
					{
						if (!!(((*(*a).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA16;
						illformedast_246229(a);
					}
					LA16: ;
					s = (*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
					{
						NIM_BOOL LOC20;
						LOC20 = 0;
						LOC20 = ((*s).magic == ((NU16) 0));
						if (!(LOC20)) goto LA21;
						LOC20 = ((*(*a).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1));
						LA21: ;
						if (!LOC20) goto LA22;
						localerror_166155((*a).info, ((NU16) 138), (*(*s).name).s);
					}
					LA22: ;
					{
						if (!!(((*s).magic == ((NU16) 0)))) goto LA26;
						processmagictype_422888(c, s);
					}
					LA26: ;
					{
						Tscope191837* LOC32;
						Ttype191849* LOC37;
						Ttype191849* body;
						if (!!(((*(*a).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1)))) goto LA30;
						LOC32 = 0;
						LOC32 = openscope_250091(c);
						pushowner_245260(s);
						{
							if (!((*s).magic == ((NU16) 0))) goto LA35;
							(*(*s).typ).kind = ((NU8) 10);
						}
						LA35: ;
						asgnRefNoCycle((void**) (&(*(*s).typ).n), semgenericparamlist_422951(c, (*a).kindU.S6.sons->data[((NI) 1)], (*s).typ));
						asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[((NI) 1)]), (*(*s).typ).n);
						(*(*s).typ).size = IL64(-1);
						LOC37 = 0;
						LOC37 = newtypes_245218(((NU8) 0), c);
						rawaddson_195478((*s).typ, LOC37);
						asgnRefNoCycle((void**) (&(*s).ast), a);
						(*c).ingenericcontext += ((NI) 1);
						body = semtypenode_410269(c, (*a).kindU.S6.sons->data[((NI) 2)], NIM_NIL);
						(*c).ingenericcontext -= ((NI) 1);
						{
							NI LOC42;
							if (!!((body == NIM_NIL))) goto LA40;
							asgnRefNoCycle((void**) (&(*body).sym), s);
							(*body).size = IL64(-1);
							LOC42 = 0;
							LOC42 = sonslen_194351((*s).typ);
							asgnRefNoCycle((void**) (&(*(*s).typ).sons->data[(NI)(LOC42 - ((NI) 1))]), body);
						}
						LA40: ;
						popowner_245266();
						closescope_250111(c);
					}
					goto LA28;
					LA30: ;
					{
						Ttype191849* t;
						if (!!(((*(*a).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 1)))) goto LA44;
						pushowner_245260(s);
						t = semtypenode_410269(c, (*a).kindU.S6.sons->data[((NI) 2)], (*s).typ);
						{
							if (!((*s).typ == NIM_NIL)) goto LA48;
							asgnRefNoCycle((void**) (&(*s).typ), t);
						}
						goto LA46;
						LA48: ;
						{
							if (!!((t == (*s).typ))) goto LA51;
							assigntype_194452((*s).typ, t);
						}
						goto LA46;
						LA51: ;
						LA46: ;
						asgnRefNoCycle((void**) (&(*s).ast), a);
						popowner_245266();
					}
					goto LA28;
					LA44: ;
					LA28: ;
					aa = (*a).kindU.S6.sons->data[((NI) 2)];
					{
						NIM_BOOL LOC55;
						NIM_BOOL LOC56;
						NI LOC58;
						Ttype191849* st;
						Ttype191849* LOC77;
						NimStringDesc* LOC78;
						Tident168021* LOC79;
						Tsym191843* LOC80;
						LOC55 = 0;
						LOC56 = 0;
						LOC56 = ((*aa).kind == ((NU8) 141) || (*aa).kind == ((NU8) 142));
						if (!(LOC56)) goto LA57;
						LOC58 = 0;
						LOC58 = len_192097(aa);
						LOC56 = (LOC58 == ((NI) 1));
						LA57: ;
						LOC55 = LOC56;
						if (!(LOC55)) goto LA59;
						LOC55 = ((*(*aa).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 133));
						LA59: ;
						if (!LOC55) goto LA60;
						st = (*s).typ;
						{
							if (!((*st).kind == ((NU8) 10))) goto LA64;
							st = lastson_194442(st);
						}
						LA64: ;
						{
							NimStringDesc* LOC70;
							if (!!(((6291456 &(IL64(1)<<(((*st).kind)&IL64(63))))!=0))) goto LA68;
							LOC70 = 0;
							LOC70 = HEX24_166306(TMP3431);
							internalerror_166218(LOC70);
						}
						LA68: ;
						{
							Ttype191849* LOC73;
							NimStringDesc* LOC76;
							LOC73 = 0;
							LOC73 = lastson_194442(st);
							if (!!(((*LOC73).sym == NIM_NIL))) goto LA74;
							LOC76 = 0;
							LOC76 = HEX24_166306(TMP3433);
							internalerror_166218(LOC76);
						}
						LA74: ;
						LOC77 = 0;
						LOC77 = lastson_194442(st);
						LOC78 = 0;
						LOC78 = rawNewString((*(*s).name).s->Sup.len + 11);
appendString(LOC78, (*(*s).name).s);
appendString(LOC78, ((NimStringDesc*) &TMP3434));
						LOC79 = 0;
						LOC79 = getident_168463(LOC78);
						LOC80 = 0;
						LOC80 = getcurrowner_245255();
						asgnRefNoCycle((void**) (&(*LOC77).sym), newsym_192655(((NU8) 7), LOC79, LOC80, (*s).info));
					}
					LA60: ;
				} LA5: ;
				res_438561 += ((NI) 1);
			} LA4: ;
		}
	}
}

N_NIMCALL(void, checkformetafields_438580)(Tnode191813* n) {
{	{
		if (!n == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	switch ((*n).kind) {
	case ((NU8) 138):
	case ((NU8) 139):
	{
		{
			Tnode191813* s_438600;
			s_438600 = 0;
			{
				NI i_438707;
				NI HEX3Atmp_438709;
				NI LOC8;
				NI res_438711;
				i_438707 = 0;
				HEX3Atmp_438709 = 0;
				LOC8 = 0;
				LOC8 = len_192097(n);
				HEX3Atmp_438709 = (LOC8 - 1);
				res_438711 = ((NI) 0);
				{
					while (1) {
						if (!(res_438711 <= HEX3Atmp_438709)) goto LA10;
						i_438707 = res_438711;
						s_438600 = (*n).kindU.S6.sons->data[i_438707];
						checkformetafields_438580(s_438600);
						res_438711 += ((NI) 1);
					} LA10: ;
				}
			}
		}
	}
	break;
	case ((NU8) 85):
	case ((NU8) 88):
	{
		Tnode191813* LOC12;
		LOC12 = 0;
		LOC12 = lastson_194431(n);
		checkformetafields_438580(LOC12);
	}
	break;
	case ((NU8) 3):
	{
		Ttype191849* t;
		t = (*(*n).kindU.S4.sym).typ;
		switch ((*t).kind) {
		case ((NU8) 24):
		case ((NU8) 19):
		case ((NU8) 16):
		case ((NU8) 27):
		case ((NU8) 23):
		case ((NU8) 21):
		case ((NU8) 22):
		case ((NU8) 25):
		case ((NU8) 9):
		case ((NU8) 11):
		{
			NI start;
			start = ((2560 &(IL64(1)<<(((*t).kind)&IL64(63))))!=0);
			{
				NI i_438651;
				NI HEX3Atmp_438715;
				NI res_438718;
				i_438651 = 0;
				HEX3Atmp_438715 = 0;
				HEX3Atmp_438715 = (((*t).sons ? (*t).sons->Sup.len : 0) - 1);
				res_438718 = ((NI) (start));
				{
					while (1) {
						if (!(res_438718 <= HEX3Atmp_438715)) goto LA17;
						i_438651 = res_438718;
						{
							NIM_BOOL LOC20;
							NIM_BOOL LOC21;
							NimStringDesc* LOC26;
							LOC20 = 0;
							LOC21 = 0;
							LOC21 = !(((*t).sons->data[i_438651] == NIM_NIL));
							if (!(LOC21)) goto LA22;
							LOC21 = ismetatype_192821((*t).sons->data[i_438651]);
							LA22: ;
							LOC20 = LOC21;
							if (!(LOC20)) goto LA23;
							LOC20 = !((((*(*t).sons->data[i_438651]).flags &(1<<((((NU8) 23))&31)))!=0));
							LA23: ;
							if (!LOC20) goto LA24;
							LOC26 = 0;
							LOC26 = typetostring_221032((*t).sons->data[i_438651], ((NU8) 0));
							localerror_166155((*n).info, ((NU16) 189), LOC26);
						}
						LA24: ;
						res_438718 += ((NI) 1);
					} LA17: ;
				}
			}
		}
		break;
		default:
		{
			{
				NIM_BOOL LOC30;
				NIM_BOOL LOC31;
				NimStringDesc* LOC36;
				LOC30 = 0;
				LOC31 = 0;
				LOC31 = !((t == NIM_NIL));
				if (!(LOC31)) goto LA32;
				LOC31 = ismetatype_192821(t);
				LA32: ;
				LOC30 = LOC31;
				if (!(LOC30)) goto LA33;
				LOC30 = !((((*t).flags &(1<<((((NU8) 23))&31)))!=0));
				LA33: ;
				if (!LOC30) goto LA34;
				LOC36 = 0;
				LOC36 = typetostring_221032(t, ((NU8) 0));
				localerror_166155((*n).info, ((NU16) 189), LOC36);
			}
			LA34: ;
		}
		break;
		}
	}
	break;
	default:
	{
		{
			NimStringDesc* LOC42;
			if (!NIM_TRUE) goto LA40;
			LOC42 = 0;
			LOC42 = HEX24_166306(TMP3435);
			internalerror_166218(LOC42);
		}
		LA40: ;
	}
	break;
	}
	}BeforeRet: ;
}

N_NIMCALL(void, typesectionfinalpass_438746)(Tcontext245023* c, Tnode191813* n) {
	{
		NI i_438762;
		NI HEX3Atmp_438851;
		NI LOC2;
		NI res_438854;
		i_438762 = 0;
		HEX3Atmp_438851 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_438851 = (NI)(LOC2 - ((NI) 1));
		res_438854 = ((NI) 0);
		{
			while (1) {
				if (!(res_438854 <= HEX3Atmp_438851)) goto LA4;
				i_438762 = res_438854;
				{
					Tnode191813* a;
					Tsym191843* s;
					a = (*n).kindU.S6.sons->data[i_438762];
					{
						if (!((*a).kind == ((NU8) 125))) goto LA8;
						goto LA5;
					}
					LA8: ;
					{
						if (!!(((*(*a).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA12;
						illformedast_246229(a);
					}
					LA12: ;
					s = (*(*a).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
					{
						if (!((*(*a).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 1))) goto LA16;
						{
							Ttype191849* t;
							if (!((*(*a).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 3) || (*(*a).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 2) || (*(*a).kindU.S6.sons->data[((NI) 2)]).kind == ((NU8) 53))) goto LA20;
							t = semtypenode_410269(c, (*a).kindU.S6.sons->data[((NI) 2)], NIM_NIL);
							{
								if (!((147456 &(IL64(1)<<(((*t).kind)&IL64(63))))!=0)) goto LA24;
								assigntype_194452((*s).typ, t);
								(*(*s).typ).Sup.id = (*t).Sup.id;
							}
							LA24: ;
						}
						LA20: ;
						checkconstructedtype_266110((*s).info, (*s).typ);
						{
							NIM_BOOL LOC28;
							LOC28 = 0;
							LOC28 = ((393216 &(IL64(1)<<(((*(*s).typ).kind)&IL64(63))))!=0);
							if (!(LOC28)) goto LA29;
							LOC28 = !((*(*s).typ).n == 0);
							LA29: ;
							if (!LOC28) goto LA30;
							checkformetafields_438580((*(*s).typ).n);
						}
						LA30: ;
					}
					LA16: ;
				} LA5: ;
				res_438854 += ((NI) 1);
			} LA4: ;
		}
	}
}

N_NIMCALL(Tnode191813*, semtypesection_438873)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	typesectionleftsidepass_438199(c, n);
	typesectionrightsidepass_438297(c, n);
	typesectionfinalpass_438746(c, n);
	result = n;
	return result;
}

N_NIMCALL(Tnode191813*, semdiscard_432006)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = n;
	checksonslen_246249(n, ((NI) 1));
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA3;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 0)], 0));
		{
			NIM_BOOL LOC7;
			LOC7 = 0;
			LOC7 = isemptytype_196934((*(*n).kindU.S6.sons->data[((NI) 0)]).typ);
			if (!LOC7) goto LA8;
			localerror_166155((*n).info, ((NU16) 141), ((NimStringDesc*) &TMP2991));
		}
		LA8: ;
	}
	LA3: ;
	return result;
}

N_NIMCALL(Tnode191813*, semwhile_432217)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tscope191837* LOC1;
	Tnode191813* LOC2;
	result = 0;
	result = n;
	checksonslen_246249(n, ((NI) 2));
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	LOC2 = 0;
	LOC2 = semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 0)], 0);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), forcebool_416629(c, LOC2));
	(*(*c).p).nestedloopcounter += ((NI) 1);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), semstmt_410277(c, (*n).kindU.S6.sons->data[((NI) 1)]));
	(*(*c).p).nestedloopcounter -= ((NI) 1);
	closescope_250111(c);
	{
		if (!((*(*n).kindU.S6.sons->data[((NI) 1)]).typ == enforcevoidcontext_432005)) goto LA5;
		asgnRefNoCycle((void**) (&(*result).typ), enforcevoidcontext_432005);
	}
	LA5: ;
	return result;
}

N_NIMCALL(Tnode191813*, sembreakorcontinue_432027)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = n;
	checksonslen_246249(n, ((NI) 1));
	{
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA3;
		{
			Tsym191843* s;
			if (!!(((*n).kind == ((NU8) 111)))) goto LA7;
			s = 0;
			switch ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind) {
			case ((NU8) 2):
			{
				s = lookup_250804(c, (*n).kindU.S6.sons->data[((NI) 0)]);
			}
			break;
			case ((NU8) 3):
			{
				s = (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
			}
			break;
			default:
			{
				illformedast_246229(n);
			}
			break;
			}
			{
				NIM_BOOL LOC14;
				Tnode191813* x;
				LOC14 = 0;
				LOC14 = ((*s).kind == ((NU8) 22));
				if (!(LOC14)) goto LA15;
				LOC14 = ((*(*s).owner).Sup.id == (*(*(*c).p).owner).Sup.id);
				LA15: ;
				if (!LOC14) goto LA16;
				x = newsymnode_193325(s);
				(*x).info = (*n).info;
				(*s).flags |= ((NI32)1)<<((((NU8) 0))%(sizeof(NI32)*8));
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), x);
				suggestsym_354960((*x).info, s);
			}
			goto LA12;
			LA16: ;
			{
				localerror_166155((*n).info, ((NU16) 164), (*(*s).name).s);
			}
			LA12: ;
		}
		goto LA5;
		LA7: ;
		{
			localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3436));
		}
		LA5: ;
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC21;
		NimStringDesc* LOC25;
		LOC21 = 0;
		LOC21 = ((*(*c).p).nestedloopcounter <= ((NI) 0));
		if (!(LOC21)) goto LA22;
		LOC21 = ((*(*c).p).nestedblockcounter <= ((NI) 0));
		LA22: ;
		if (!LOC21) goto LA23;
		LOC25 = 0;
		LOC25 = rendertree_213058(n, 4);
		localerror_166155((*n).info, ((NU16) 164), LOC25);
	}
	goto LA1;
	LA23: ;
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semexprnoderef_410228)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	result = 0;
	result = semexpr_410201(c, n, flags);
	{
		if (!((*result).kind == ((NU8) 1))) goto LA3;
		result = errornode_246160(c, n);
	}
	LA3: ;
	{
		NimStringDesc* LOC9;
		if (!((*result).typ == NIM_NIL)) goto LA7;
		LOC9 = 0;
		LOC9 = rendertree_213058(result, 4);
		localerror_166155((*n).info, ((NU16) 90), LOC9);
		asgnRefNoCycle((void**) (&(*result).typ), errortype_246150(c));
	}
	goto LA5;
	LA7: ;
	{
		semprocvarcheck_432366(c, result);
		semdestructorcheck_433440(c, result, flags);
	}
	LA5: ;
	return result;
}

N_NIMCALL(Tsym191843*, symforvar_437707)(Tcontext245023* c, Tnode191813* n) {
	Tsym191843* result;
	Tnode191813* m;
	result = 0;
	{
		if (!((*n).kind == ((NU8) 43))) goto LA3;
		m = (*n).kindU.S6.sons->data[((NI) 0)];
	}
	goto LA1;
	LA3: ;
	{
		m = n;
	}
	LA1: ;
	result = newsymg_410916(((NU8) 21), m, c);
	return result;
}

N_NIMCALL(void, addforvardecl_437675)(Tcontext245023* c, Tsym191843* v) {
	{
		Tsym191843* shadowed;
		if (!((gnotes_165011 &(IL64(1)<<(((((NU16) 249)- 230))&IL64(63))))!=0)) goto LA3;
		shadowed = findshadowedvar_435035(c, v);
		{
			if (!!((shadowed == NIM_NIL))) goto LA7;
			message_166188((*v).info, ((NU16) 249), (*(*v).name).s);
		}
		LA7: ;
	}
	LA3: ;
	adddecl_250607(c, v);
}

N_NIMCALL(Tnode191813*, semforvars_437804)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	NI length;
	Ttype191849* iterbase;
	Ttype191849* iter;
	result = 0;
	result = n;
	length = sonslen_194403(n);
	iterbase = skiptypes_195167((*(*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))]).typ, IL64(562949953421312));
	iter = skiptypes_195167(iterbase, 2048);
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = !(((*iter).kind == ((NU8) 18)));
		if (LOC3) goto LA4;
		LOC3 = (length == ((NI) 3));
		LA4: ;
		if (!LOC3) goto LA5;
		{
			Tsym191843* v;
			if (!(length == ((NI) 3))) goto LA9;
			v = symforvar_437707(c, (*n).kindU.S6.sons->data[((NI) 0)]);
			{
				Tsym191843* LOC13;
				LOC13 = 0;
				LOC13 = getcurrowner_245255();
				if (!((*LOC13).kind == ((NU8) 6))) goto LA14;
				(*v).flags |= ((NI32)1)<<((((NU8) 3))%(sizeof(NI32)*8));
			}
			LA14: ;
			asgnRefNoCycle((void**) (&(*v).typ), iterbase);
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), newsymnode_193325(v));
			{
				if (!!((((*v).flags &(1<<((((NU8) 31))&31)))!=0))) goto LA18;
				addforvardecl_437675(c, v);
			}
			LA18: ;
		}
		goto LA7;
		LA9: ;
		{
			localerror_166155((*n).info, ((NU16) 111), ((NimStringDesc*) &TMP2991));
		}
		LA7: ;
	}
	goto LA1;
	LA5: ;
	{
		NI LOC22;
		LOC22 = 0;
		LOC22 = sonslen_194351(iter);
		if (!!(((NI)(length - ((NI) 2)) == LOC22))) goto LA23;
		localerror_166155((*n).info, ((NU16) 111), ((NimStringDesc*) &TMP2991));
	}
	goto LA1;
	LA23: ;
	{
		{
			NI i_437871;
			NI HEX3Atmp_437928;
			NI res_437931;
			i_437871 = 0;
			HEX3Atmp_437928 = 0;
			HEX3Atmp_437928 = (NI)(length - ((NI) 3));
			res_437931 = ((NI) 0);
			{
				while (1) {
					Tsym191843* v;
					if (!(res_437931 <= HEX3Atmp_437928)) goto LA28;
					i_437871 = res_437931;
					v = symforvar_437707(c, (*n).kindU.S6.sons->data[i_437871]);
					{
						Tsym191843* LOC31;
						LOC31 = 0;
						LOC31 = getcurrowner_245255();
						if (!((*LOC31).kind == ((NU8) 6))) goto LA32;
						(*v).flags |= ((NI32)1)<<((((NU8) 3))%(sizeof(NI32)*8));
					}
					LA32: ;
					asgnRefNoCycle((void**) (&(*v).typ), (*iter).sons->data[i_437871]);
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[i_437871]), newsymnode_193325(v));
					{
						NIM_BOOL LOC36;
						NIM_BOOL LOC38;
						LOC36 = 0;
						LOC36 = !((((*v).flags &(1<<((((NU8) 31))&31)))!=0));
						if (!(LOC36)) goto LA37;
						LOC38 = 0;
						LOC38 = isdiscardunderscore_436399(v);
						LOC36 = !(LOC38);
						LA37: ;
						if (!LOC36) goto LA39;
						addforvardecl_437675(c, v);
					}
					LA39: ;
					res_437931 += ((NI) 1);
				} LA28: ;
			}
		}
	}
	LA1: ;
	(*(*c).p).nestedloopcounter += ((NI) 1);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[(NI)(length - ((NI) 1))]), semstmt_410277(c, (*n).kindU.S6.sons->data[(NI)(length - ((NI) 1))]));
	(*(*c).p).nestedloopcounter -= ((NI) 1);
	return result;
}

N_NIMCALL(Tnode191813*, instfieldloopbody_437152)(Tfieldinstctx437147* c, Tnode191813* n, Tnode191813* forloop) {
	Tnode191813* result;
{	result = 0;
	switch ((*n).kind) {
	case ((NU8) 1) ... ((NU8) 1):
	case ((NU8) 4) ... ((NU8) 23):
	{
		result = n;
	}
	break;
	case ((NU8) 2):
	case ((NU8) 3):
	{
		Tident168021* ident;
		NI L;
		result = n;
		ident = considerquotedident_250010(n);
		L = sonslen_194403(forloop);
		{
			if (!(*c).replacebyfieldname) goto LA5;
			{
				Tnode191813* LOC9;
				Tident168021* LOC10;
				NimStringDesc* fieldname;
				LOC9 = 0;
				LOC9 = HEX5BHEX5D_192244(forloop, ((NI) 0));
				LOC10 = 0;
				LOC10 = considerquotedident_250010(LOC9);
				if (!((*ident).Sup.id == (*LOC10).Sup.id)) goto LA11;
				{
					if (!(*c).tupletype == 0) goto LA15;
					fieldname = (*(*(*c).field).name).s;
				}
				goto LA13;
				LA15: ;
				{
					NimStringDesc* LOC20;
					NimStringDesc* LOC21;
					if (!(*(*c).tupletype).n == 0) goto LA18;
					LOC20 = 0;
					LOC21 = 0;
					LOC21 = nimIntToStr((*c).tupleindex);
					LOC20 = rawNewString(LOC21->Sup.len + 5);
appendString(LOC20, ((NimStringDesc*) &TMP3440));
appendString(LOC20, LOC21);
					fieldname = LOC20;
				}
				goto LA13;
				LA18: ;
				{
					fieldname = (*(*(*(*(*(*c).tupletype).n).kindU.S6.sons->data[(*c).tupleindex]).kindU.S4.sym).name).s;
				}
				LA13: ;
				result = newstrnode_192643(((NU8) 20), fieldname);
				goto BeforeRet;
			}
			LA11: ;
		}
		LA5: ;
		{
			NI i_437220;
			NI HEX3Atmp_437271;
			NI HEX3Atmp_437272;
			NI res_437275;
			i_437220 = 0;
			HEX3Atmp_437271 = 0;
			HEX3Atmp_437272 = 0;
			HEX3Atmp_437271 = (*c).replacebyfieldname;
			HEX3Atmp_437272 = (NI)(L - ((NI) 3));
			res_437275 = ((NI) (HEX3Atmp_437271));
			{
				while (1) {
					if (!(res_437275 <= HEX3Atmp_437272)) goto LA25;
					i_437220 = res_437275;
					{
						Tnode191813* LOC28;
						Tident168021* LOC29;
						Tnode191813* call;
						Tnode191813* tupl;
						LOC28 = 0;
						LOC28 = HEX5BHEX5D_192244(forloop, i_437220);
						LOC29 = 0;
						LOC29 = considerquotedident_250010(LOC28);
						if (!((*ident).Sup.id == (*LOC29).Sup.id)) goto LA30;
						call = (*forloop).kindU.S6.sons->data[(NI)(L - ((NI) 2))];
						tupl = (*call).kindU.S6.sons->data[(NI)((NI)(i_437220 + ((NI) 1)) - ((NI) ((*c).replacebyfieldname)))];
						{
							Tnode191813* LOC36;
							if (!(*c).field == 0) goto LA34;
							result = newnodei_193351(((NU8) 42), (*n).info);
							add_192164(result, tupl);
							LOC36 = 0;
							LOC36 = newintnode_192607(((NU8) 6), ((NI64) ((*c).tupleindex)));
							add_192164(result, LOC36);
						}
						goto LA32;
						LA34: ;
						{
							Tnode191813* LOC38;
							result = newnodei_193351(((NU8) 45), (*n).info);
							add_192164(result, tupl);
							LOC38 = 0;
							LOC38 = newsymnode_193338((*c).field, (*n).info);
							add_192164(result, LOC38);
						}
						LA32: ;
						goto LA23;
					}
					LA30: ;
					res_437275 += ((NI) 1);
				} LA25: ;
			}
		} LA23: ;
	}
	break;
	default:
	{
		NI LOC44;
		{
			if (!((*n).kind == ((NU8) 111))) goto LA42;
			localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3441));
		}
		LA42: ;
		result = copynode_195640(n);
		LOC44 = 0;
		LOC44 = sonslen_194403(n);
		newsons_194272(result, LOC44);
		{
			NI i_437267;
			NI HEX3Atmp_437280;
			NI LOC46;
			NI res_437283;
			i_437267 = 0;
			HEX3Atmp_437280 = 0;
			LOC46 = 0;
			LOC46 = sonslen_194403(n);
			HEX3Atmp_437280 = (NI)(LOC46 - ((NI) 1));
			res_437283 = ((NI) 0);
			{
				while (1) {
					if (!(res_437283 <= HEX3Atmp_437280)) goto LA48;
					i_437267 = res_437283;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_437267]), instfieldloopbody_437152(c, (*n).kindU.S6.sons->data[i_437267], forloop));
					res_437283 += ((NI) 1);
				} LA48: ;
			}
		}
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, semforobjectfields_437312)(Tfieldsctx437309 c, Tnode191813* typ, Tnode191813* forloop, Tnode191813* father) {
{	switch ((*typ).kind) {
	case ((NU8) 3):
	{
		Tfieldinstctx437147 fc;
		Tscope191837* LOC2;
		Tnode191813* body;
		Tnode191813* LOC3;
		Tnode191813* LOC4;
		memset((void*)(&fc), 0, sizeof(fc));
		fc.field = (*typ).kindU.S4.sym;
		fc.replacebyfieldname = (c.m == ((NU16) 153));
		LOC2 = 0;
		LOC2 = openscope_250091(c.c);
		(*c.c).inunrolledcontext += ((NI) 1);
		LOC3 = 0;
		LOC3 = lastson_194431(forloop);
		body = instfieldloopbody_437152((&fc), LOC3, forloop);
		LOC4 = 0;
		LOC4 = semstmt_410277(c.c, body);
		add_192164(father, LOC4);
		(*c.c).inunrolledcontext -= ((NI) 1);
		closescope_250111(c.c);
	}
	break;
	case ((NU8) 23):
	{
	}
	break;
	case ((NU8) 139):
	{
		NI L_437350;
		Tnode191813* call;
		Tnode191813* LOC12;
		Tnode191813* casestmt;
		Tnode191813* access;
		Tnode191813* LOC13;
		L_437350 = len_192097(forloop);
		call = (*forloop).kindU.S6.sons->data[(NI)(L_437350 - ((NI) 2))];
		{
			NI LOC9;
			LOC9 = 0;
			LOC9 = len_192097(call);
			if (!(((NI) 2) < LOC9)) goto LA10;
			localerror_166155((*forloop).info, ((NU16) 4), ((NimStringDesc*) &TMP3442));
			goto BeforeRet;
		}
		LA10: ;
		LOC12 = 0;
		LOC12 = HEX5BHEX5D_192244(typ, ((NI) 0));
		semforobjectfields_437312(c, LOC12, forloop, father);
		casestmt = newnodei_193351(((NU8) 97), (*forloop).info);
		access = newnodei_193407(((NU8) 45), (*forloop).info, ((NI) 2));
		asgnRefNoCycle((void**) (&(*access).kindU.S6.sons->data[((NI) 0)]), (*call).kindU.S6.sons->data[((NI) 1)]);
		asgnRefNoCycle((void**) (&(*access).kindU.S6.sons->data[((NI) 1)]), newsymnode_193338((*(*typ).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym, (*forloop).info));
		LOC13 = 0;
		LOC13 = semexprwithtype_410211(c.c, access, 0);
		add_192164(casestmt, LOC13);
		{
			NI i_437381;
			NI HEX3Atmp_437392;
			NI LOC15;
			NI res_437395;
			i_437381 = 0;
			HEX3Atmp_437392 = 0;
			LOC15 = 0;
			LOC15 = len_192097(typ);
			HEX3Atmp_437392 = (LOC15 - 1);
			res_437395 = ((NI) 1);
			{
				while (1) {
					Tnode191813* branch;
					Tnode191813* LOC18;
					NI L;
					Tnode191813* LOC19;
					Tnode191813* LOC20;
					Tnode191813* LOC21;
					if (!(res_437395 <= HEX3Atmp_437392)) goto LA17;
					i_437381 = res_437395;
					LOC18 = 0;
					LOC18 = HEX5BHEX5D_192244(typ, i_437381);
					branch = copytree_196028(LOC18);
					L = len_192097(branch);
					asgnRefNoCycle((void**) (&(*branch).kindU.S6.sons->data[(NI)(L - ((NI) 1))]), newnodei_193351(((NU8) 115), (*forloop).info));
					LOC19 = 0;
					LOC19 = HEX5BHEX5D_192244(typ, i_437381);
					LOC20 = 0;
					LOC20 = lastson_194431(LOC19);
					LOC21 = 0;
					LOC21 = HEX5BHEX5D_192244(branch, (NI)(L - ((NI) 1)));
					semforobjectfields_437312(c, LOC20, forloop, LOC21);
					add_192164(casestmt, branch);
					res_437395 += ((NI) 1);
				} LA17: ;
			}
		}
		add_192164(father, casestmt);
	}
	break;
	case ((NU8) 138):
	{
		{
			Tnode191813* t_437389;
			t_437389 = 0;
			{
				NI i_437403;
				NI HEX3Atmp_437405;
				NI LOC25;
				NI res_437407;
				i_437403 = 0;
				HEX3Atmp_437405 = 0;
				LOC25 = 0;
				LOC25 = len_192097(typ);
				HEX3Atmp_437405 = (LOC25 - 1);
				res_437407 = ((NI) 0);
				{
					while (1) {
						if (!(res_437407 <= HEX3Atmp_437405)) goto LA27;
						i_437403 = res_437407;
						t_437389 = (*typ).kindU.S6.sons->data[i_437403];
						semforobjectfields_437312(c, t_437389, forloop, father);
						res_437407 += ((NI) 1);
					} LA27: ;
				}
			}
		}
	}
	break;
	default:
	{
		illformedastlocal_246239(typ);
	}
	break;
	}
	}BeforeRet: ;
}

N_NIMCALL(Tnode191813*, semforfields_437434)(Tcontext245023* c, Tnode191813* n, NU16 m) {
	Tnode191813* result;
	Tsym191843* truesymbol;
	Tident168021* LOC1;
	Tnode191813* stmts;
	NI length;
	Tnode191813* call;
	Ttype191849* tupletypea;
{	result = 0;
	result = newnodei_193407(((NU8) 96), (*n).info, ((NI) 2));
	LOC1 = 0;
	LOC1 = getident_168463(((NimStringDesc*) &TMP3437));
	truesymbol = strtableget_199111((*systemmodule_239019).kindU.S3.tab, LOC1);
	{
		Tident168021* LOC6;
		Tsym191843* LOC7;
		if (!(truesymbol == NIM_NIL)) goto LA4;
		localerror_166155((*n).info, ((NU16) 64), ((NimStringDesc*) &TMP3438));
		LOC6 = 0;
		LOC6 = getident_168463(((NimStringDesc*) &TMP3437));
		LOC7 = 0;
		LOC7 = getcurrowner_245255();
		truesymbol = newsym_192655(((NU8) 0), LOC6, LOC7, (*n).info);
		asgnRefNoCycle((void**) (&(*truesymbol).typ), getsystype_239030(((NU8) 1)));
	}
	LA4: ;
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), newsymnode_193338(truesymbol, (*n).info));
	stmts = newnodei_193351(((NU8) 115), (*n).info);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 1)]), stmts);
	length = sonslen_194403(n);
	call = (*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))];
	{
		NI LOC10;
		LOC10 = 0;
		LOC10 = sonslen_194403(call);
		if (!!(((NI)(length - ((NI) 2)) == (NI)((NI)(LOC10 - ((NI) 1)) + ((NI) ((m == ((NU16) 153)))))))) goto LA11;
		localerror_166155((*n).info, ((NU16) 111), ((NimStringDesc*) &TMP2991));
		goto BeforeRet;
	}
	LA11: ;
	tupletypea = skiptypes_195167((*(*call).kindU.S6.sons->data[((NI) 1)]).typ, IL64(211106240964608));
	{
		if (!!(((393216 &(IL64(1)<<(((*tupletypea).kind)&IL64(63))))!=0))) goto LA15;
		localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3439));
		goto BeforeRet;
	}
	LA15: ;
	{
		NI i_437515;
		NI HEX3Atmp_437630;
		NI LOC18;
		NI res_437633;
		i_437515 = 0;
		HEX3Atmp_437630 = 0;
		LOC18 = 0;
		LOC18 = len_192097(call);
		HEX3Atmp_437630 = (NI)(LOC18 - ((NI) 1));
		res_437633 = ((NI) 1);
		{
			while (1) {
				Ttype191849* tupletypeb;
				if (!(res_437633 <= HEX3Atmp_437630)) goto LA20;
				i_437515 = res_437633;
				tupletypeb = skiptypes_195167((*(*call).kindU.S6.sons->data[i_437515]).typ, IL64(211106240964608));
				{
					NIM_BOOL LOC23;
					LOC23 = 0;
					LOC23 = sametype_226092(tupletypea, tupletypeb, 0);
					if (!!(LOC23)) goto LA24;
					typemismatch_410379((*call).kindU.S6.sons->data[i_437515], tupletypea, tupletypeb);
				}
				LA24: ;
				res_437633 += ((NI) 1);
			} LA20: ;
		}
	}
	(*(*c).p).nestedloopcounter += ((NI) 1);
	{
		Tnode191813* loopbody;
		if (!((*tupletypea).kind == ((NU8) 18))) goto LA28;
		loopbody = (*n).kindU.S6.sons->data[(NI)(length - ((NI) 1))];
		{
			NI i_437562;
			NI HEX3Atmp_437639;
			NI LOC31;
			NI res_437642;
			i_437562 = 0;
			HEX3Atmp_437639 = 0;
			LOC31 = 0;
			LOC31 = sonslen_194351(tupletypea);
			HEX3Atmp_437639 = (NI)(LOC31 - ((NI) 1));
			res_437642 = ((NI) 0);
			{
				while (1) {
					Tscope191837* LOC34;
					Tfieldinstctx437147 fc;
					Tnode191813* body;
					Tnode191813* LOC35;
					if (!(res_437642 <= HEX3Atmp_437639)) goto LA33;
					i_437562 = res_437642;
					LOC34 = 0;
					LOC34 = openscope_250091(c);
					memset((void*)(&fc), 0, sizeof(fc));
					fc.tupletype = tupletypea;
					fc.tupleindex = i_437562;
					fc.replacebyfieldname = (m == ((NU16) 153));
					body = instfieldloopbody_437152((&fc), loopbody, n);
					(*c).inunrolledcontext += ((NI) 1);
					LOC35 = 0;
					LOC35 = semstmt_410277(c, body);
					add_192164(stmts, LOC35);
					(*c).inunrolledcontext -= ((NI) 1);
					closescope_250111(c);
					res_437642 += ((NI) 1);
				} LA33: ;
			}
		}
	}
	goto LA26;
	LA28: ;
	{
		Tfieldsctx437309 fc;
		Ttype191849* t;
		memset((void*)(&fc), 0, sizeof(fc));
		fc.m = m;
		fc.c = c;
		t = tupletypea;
		{
			while (1) {
				if (!((*t).kind == ((NU8) 17))) goto LA38;
				semforobjectfields_437312(fc, (*t).n, n, stmts);
				{
					if (!((*t).sons->data[((NI) 0)] == NIM_NIL)) goto LA41;
					goto LA37;
				}
				LA41: ;
				t = skiptypes_195167((*t).sons->data[((NI) 0)], IL64(211106247256320));
			} LA38: ;
		} LA37: ;
	}
	LA26: ;
	(*(*c).p).nestedloopcounter -= ((NI) 1);
	{
		NIM_BOOL LOC45;
		Tnode191813* b;
		LOC45 = 0;
		LOC45 = containsnode_196365(stmts, TMP3443);
		if (!LOC45) goto LA46;
		b = newnodei_193351(((NU8) 110), (*n).info);
		add_192164(b, emptynode_192807);
		add_192164(stmts, b);
	}
	goto LA43;
	LA46: ;
	{
		result = stmts;
	}
	LA43: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, implicititerator_437947)(Tcontext245023* c, NimStringDesc* it, Tnode191813* arg) {
	Tnode191813* result;
	Tident168021* LOC1;
	Tnode191813* LOC2;
	result = 0;
	result = newnodei_193351(((NU8) 27), (*arg).info);
	LOC1 = 0;
	LOC1 = getident_168463(it);
	LOC2 = 0;
	LOC2 = newidentnode_193313(LOC1, (*arg).info);
	add_192164(result, LOC2);
	{
		NIM_BOOL LOC5;
		Tnode191813* LOC9;
		LOC5 = 0;
		LOC5 = !(((*arg).typ == NIM_NIL));
		if (!(LOC5)) goto LA6;
		LOC5 = ((*(*arg).typ).kind == ((NU8) 23));
		LA6: ;
		if (!LOC5) goto LA7;
		LOC9 = 0;
		LOC9 = newderef_358024(arg);
		add_192164(result, LOC9);
	}
	goto LA3;
	LA7: ;
	{
		add_192164(result, arg);
	}
	LA3: ;
	result = semexprnoderef_410228(c, result, 2);
	return result;
}

N_NIMCALL(Tnode191813*, semfor_437981)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	NI length;
	Tscope191837* LOC1;
	Tnode191813* call;
	NIM_BOOL iscallexpr;
	result = 0;
	result = n;
	checkminsonslen_246259(n, ((NI) 3));
	length = sonslen_194403(n);
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))]), semexprnoderef_410228(c, (*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))], 2));
	call = (*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))];
	iscallexpr = ((*call).kind == ((NU8) 27) || (*call).kind == ((NU8) 29) || (*call).kind == ((NU8) 30) || (*call).kind == ((NU8) 31) || (*call).kind == ((NU8) 26) || (*call).kind == ((NU8) 28) || (*call).kind == ((NU8) 32));
	{
		NIM_BOOL LOC4;
		NIM_BOOL LOC5;
		Tnode191813* LOC7;
		Tnode191813* LOC9;
		LOC4 = 0;
		LOC5 = 0;
		LOC5 = iscallexpr;
		if (!(LOC5)) goto LA6;
		LOC7 = 0;
		LOC7 = HEX5BHEX5D_192244(call, ((NI) 0));
		LOC5 = ((*LOC7).kind == ((NU8) 3));
		LA6: ;
		LOC4 = LOC5;
		if (!(LOC4)) goto LA8;
		LOC9 = 0;
		LOC9 = HEX5BHEX5D_192244(call, ((NI) 0));
		LOC4 = ((*(*LOC9).kindU.S4.sym).magic == ((NU16) 152) || (*(*LOC9).kindU.S4.sym).magic == ((NU16) 153) || (*(*LOC9).kindU.S4.sym).magic == ((NU16) 154));
		LA8: ;
		if (!LOC4) goto LA10;
		{
			if (!((*(*(*call).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).magic == ((NU16) 154))) goto LA14;
			result = semforvars_437804(c, n);
			(*result).kind = ((NU8) 95);
		}
		goto LA12;
		LA14: ;
		{
			result = semforfields_437434(c, n, (*(*(*call).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).magic);
		}
		LA12: ;
	}
	goto LA2;
	LA10: ;
	{
		NIM_BOOL LOC18;
		NIM_BOOL LOC19;
		LOC18 = 0;
		LOC19 = 0;
		LOC19 = iscallexpr;
		if (!(LOC19)) goto LA20;
		LOC19 = ((*(*(*call).kindU.S6.sons->data[((NI) 0)]).typ).callconv == ((NU8) 8));
		LA20: ;
		LOC18 = LOC19;
		if (LOC18) goto LA21;
		LOC18 = ((*(*call).typ).kind == ((NU8) 49));
		LA21: ;
		if (!LOC18) goto LA22;
		result = semforvars_437804(c, n);
	}
	goto LA2;
	LA22: ;
	{
		NIM_BOOL LOC25;
		NIM_BOOL LOC26;
		LOC25 = 0;
		LOC26 = 0;
		LOC26 = !(iscallexpr);
		if (LOC26) goto LA27;
		LOC26 = !(((*(*call).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 3)));
		LA27: ;
		LOC25 = LOC26;
		if (LOC25) goto LA28;
		LOC25 = !(((49152 &(1<<(((*(*(*call).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).kind)&31)))!=0));
		LA28: ;
		if (!LOC25) goto LA29;
		{
			if (!(length == ((NI) 3))) goto LA33;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))]), implicititerator_437947(c, ((NimStringDesc*) &TMP3444), (*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))]));
		}
		goto LA31;
		LA33: ;
		{
			if (!(length == ((NI) 4))) goto LA36;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))]), implicititerator_437947(c, ((NimStringDesc*) &TMP3445), (*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))]));
		}
		goto LA31;
		LA36: ;
		{
			localerror_166155((*(*n).kindU.S6.sons->data[(NI)(length - ((NI) 2))]).info, ((NU16) 218), ((NimStringDesc*) &TMP2991));
		}
		LA31: ;
		result = semforvars_437804(c, n);
	}
	goto LA2;
	LA29: ;
	{
		result = semforvars_437804(c, n);
	}
	LA2: ;
	{
		if (!((*(*n).kindU.S6.sons->data[(NI)(length - ((NI) 1))]).typ == enforcevoidcontext_432005)) goto LA42;
		asgnRefNoCycle((void**) (&(*result).typ), enforcevoidcontext_432005);
	}
	LA42: ;
	closescope_250111(c);
	return result;
}

N_NIMCALL(NI64, tocover_432259)(Ttype191849* t) {
	NI64 result;
	Ttype191849* t2;
	result = 0;
	t2 = skiptypes_195167(t, IL64(211106242013184));
	{
		NIM_BOOL LOC3;
		NI LOC7;
		LOC3 = 0;
		LOC3 = ((*t2).kind == ((NU8) 14));
		if (!(LOC3)) goto LA4;
		LOC3 = enumhasholes_221099(t2);
		LA4: ;
		if (!LOC3) goto LA5;
		LOC7 = 0;
		LOC7 = sonslen_194403((*t2).n);
		result = ((NI64) (LOC7));
	}
	goto LA1;
	LA5: ;
	{
		Ttype191849* LOC9;
		LOC9 = 0;
		LOC9 = skiptypes_195167(t, IL64(211106240964608));
		result = lengthord_221016(LOC9);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semcase_434301)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tscope191837* LOC1;
	NIM_BOOL chckcovered;
	NI64 covered;
	Ttype191849* typ;
	NIM_BOOL haselse;
	NIM_BOOL notordinal;
	Ttype191849* LOC2;
{	result = 0;
	result = n;
	checkminsonslen_246259(n, ((NI) 2));
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 0)], 0));
	chckcovered = NIM_FALSE;
	covered = IL64(0);
	typ = commontypebegin_410472;
	haselse = NIM_FALSE;
	notordinal = NIM_FALSE;
	LOC2 = 0;
	LOC2 = skiptypes_195167((*(*n).kindU.S6.sons->data[((NI) 0)]).typ, IL64(211106242013184));
	switch ((*LOC2).kind) {
	case ((NU8) 31) ... ((NU8) 35):
	case ((NU8) 2):
	case ((NU8) 14):
	case ((NU8) 40) ... ((NU8) 43):
	case ((NU8) 1):
	{
		chckcovered = NIM_TRUE;
	}
	break;
	case ((NU8) 36) ... ((NU8) 39):
	case ((NU8) 28):
	case ((NU8) 50):
	{
		notordinal = NIM_TRUE;
	}
	break;
	default:
	{
		localerror_166155((*n).info, ((NU16) 107), ((NimStringDesc*) &TMP2991));
		goto BeforeRet;
	}
	break;
	}
	{
		NI i_434339;
		NI HEX3Atmp_434662;
		NI LOC7;
		NI res_434665;
		i_434339 = 0;
		HEX3Atmp_434662 = 0;
		LOC7 = 0;
		LOC7 = sonslen_194403(n);
		HEX3Atmp_434662 = (NI)(LOC7 - ((NI) 1));
		res_434665 = ((NI) 1);
		{
			while (1) {
				Tnode191813* x;
				if (!(res_434665 <= HEX3Atmp_434662)) goto LA9;
				i_434339 = res_434665;
				x = (*n).kindU.S6.sons->data[i_434339];
				switch ((*x).kind) {
				case ((NU8) 85):
				{
					NI last;
					NI LOC11;
					checkminsonslen_246259(x, ((NI) 2));
					semcasebranch_418947(c, n, x, i_434339, (&covered));
					LOC11 = 0;
					LOC11 = sonslen_194403(x);
					last = (NI)(LOC11 - ((NI) 1));
					asgnRefNoCycle((void**) (&(*x).kindU.S6.sons->data[last]), semexprbranchscope_433635(c, (*x).kindU.S6.sons->data[last]));
					typ = commontype_410477(typ, (*(*x).kindU.S6.sons->data[last]).typ);
				}
				break;
				case ((NU8) 86):
				{
					Tscope191837* LOC13;
					Tnode191813* LOC14;
					chckcovered = NIM_FALSE;
					checksonslen_246249(x, ((NI) 2));
					LOC13 = 0;
					LOC13 = openscope_250091(c);
					LOC14 = 0;
					LOC14 = semexprwithtype_410211(c, (*x).kindU.S6.sons->data[((NI) 0)], 0);
					asgnRefNoCycle((void**) (&(*x).kindU.S6.sons->data[((NI) 0)]), forcebool_416629(c, LOC14));
					asgnRefNoCycle((void**) (&(*x).kindU.S6.sons->data[((NI) 1)]), semexprbranch_433604(c, (*x).kindU.S6.sons->data[((NI) 1)]));
					typ = commontype_410477(typ, (*(*x).kindU.S6.sons->data[((NI) 1)]).typ);
					closescope_250111(c);
				}
				break;
				case ((NU8) 88):
				{
					chckcovered = NIM_FALSE;
					checksonslen_246249(x, ((NI) 1));
					asgnRefNoCycle((void**) (&(*x).kindU.S6.sons->data[((NI) 0)]), semexprbranchscope_433635(c, (*x).kindU.S6.sons->data[((NI) 0)]));
					typ = commontype_410477(typ, (*(*x).kindU.S6.sons->data[((NI) 0)]).typ);
					haselse = NIM_TRUE;
				}
				break;
				default:
				{
					illformedast_246229(x);
				}
				break;
				}
				res_434665 += ((NI) 1);
			} LA9: ;
		}
	}
	{
		NIM_BOOL LOC19;
		LOC19 = 0;
		LOC19 = notordinal;
		if (!(LOC19)) goto LA20;
		LOC19 = !(haselse);
		LA20: ;
		if (!LOC19) goto LA21;
		message_166188((*n).info, ((NU16) 234), ((NimStringDesc*) &TMP3446));
	}
	LA21: ;
	{
		if (!chckcovered) goto LA25;
		{
			NI64 LOC29;
			LOC29 = 0;
			LOC29 = tocover_432259((*(*n).kindU.S6.sons->data[((NI) 0)]).typ);
			if (!(covered == LOC29)) goto LA30;
			haselse = NIM_TRUE;
		}
		goto LA27;
		LA30: ;
		{
			localerror_166155((*n).info, ((NU16) 151), ((NimStringDesc*) &TMP2991));
		}
		LA27: ;
	}
	LA25: ;
	closescope_250111(c);
	{
		NIM_BOOL LOC35;
		NIM_BOOL LOC36;
		LOC35 = 0;
		LOC36 = 0;
		LOC36 = isemptytype_196934(typ);
		if (LOC36) goto LA37;
		LOC36 = ((*typ).kind == ((NU8) 5));
		LA37: ;
		LOC35 = LOC36;
		if (LOC35) goto LA38;
		LOC35 = !(haselse);
		LA38: ;
		if (!LOC35) goto LA39;
		{
			NI i_434628;
			NI HEX3Atmp_434670;
			NI LOC42;
			NI res_434673;
			i_434628 = 0;
			HEX3Atmp_434670 = 0;
			LOC42 = 0;
			LOC42 = len_192097(n);
			HEX3Atmp_434670 = (NI)(LOC42 - ((NI) 1));
			res_434673 = ((NI) 1);
			{
				while (1) {
					Tnode191813* LOC45;
					if (!(res_434673 <= HEX3Atmp_434670)) goto LA44;
					i_434628 = res_434673;
					LOC45 = 0;
					LOC45 = lastson_194431((*n).kindU.S6.sons->data[i_434628]);
					discardcheck_433756(c, LOC45);
					res_434673 += ((NI) 1);
				} LA44: ;
			}
		}
		{
			if (!(typ == enforcevoidcontext_432005)) goto LA48;
			asgnRefNoCycle((void**) (&(*result).typ), enforcevoidcontext_432005);
		}
		LA48: ;
	}
	goto LA33;
	LA39: ;
	{
		{
			NI i_434653;
			NI HEX3Atmp_434678;
			NI LOC52;
			NI res_434681;
			i_434653 = 0;
			HEX3Atmp_434678 = 0;
			LOC52 = 0;
			LOC52 = len_192097(n);
			HEX3Atmp_434678 = (NI)(LOC52 - ((NI) 1));
			res_434681 = ((NI) 1);
			{
				while (1) {
					Tnode191813* it;
					NI j;
					NI LOC55;
					if (!(res_434681 <= HEX3Atmp_434678)) goto LA54;
					i_434653 = res_434681;
					it = (*n).kindU.S6.sons->data[i_434653];
					LOC55 = 0;
					LOC55 = len_192097(it);
					j = (NI)(LOC55 - ((NI) 1));
					asgnRefNoCycle((void**) (&(*it).kindU.S6.sons->data[j]), fitnode_410245(c, typ, (*it).kindU.S6.sons->data[j]));
					res_434681 += ((NI) 1);
				} LA54: ;
			}
		}
		asgnRefNoCycle((void**) (&(*result).typ), typ);
	}
	LA33: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semreturn_448260)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = n;
	checksonslen_246249(n, ((NI) 1));
	{
		if (!((241664 &(1<<(((*(*(*c).p).owner).kind)&31)))!=0)) goto LA3;
		{
			if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA7;
			{
				Tnode191813* a;
				Tnode191813* LOC13;
				if (!!(((*(*c).p).resultsym == NIM_NIL))) goto LA11;
				a = newnodei_193351(((NU8) 73), (*(*n).kindU.S6.sons->data[((NI) 0)]).info);
				LOC13 = 0;
				LOC13 = newsymnode_193325((*(*c).p).resultsym);
				addson_193819(a, LOC13);
				addson_193819(a, (*n).kindU.S6.sons->data[((NI) 0)]);
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semasgn_448081(c, a));
				{
					NIM_BOOL LOC16;
					Tnode191813* LOC17;
					Tnode191813* LOC18;
					Tnode191813* LOC20;
					Tnode191813* LOC21;
					LOC16 = 0;
					LOC17 = 0;
					LOC17 = HEX5BHEX5D_192244(n, ((NI) 0));
					LOC18 = 0;
					LOC18 = HEX5BHEX5D_192244(LOC17, ((NI) 1));
					LOC16 = ((*LOC18).kind == ((NU8) 3));
					if (!(LOC16)) goto LA19;
					LOC20 = 0;
					LOC20 = HEX5BHEX5D_192244(n, ((NI) 0));
					LOC21 = 0;
					LOC21 = HEX5BHEX5D_192244(LOC20, ((NI) 1));
					LOC16 = ((*LOC21).kindU.S4.sym == (*(*c).p).resultsym);
					LA19: ;
					if (!LOC16) goto LA22;
					asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), emptynode_192807);
				}
				LA22: ;
			}
			goto LA9;
			LA11: ;
			{
				localerror_166155((*n).info, ((NU16) 179), ((NimStringDesc*) &TMP2991));
			}
			LA9: ;
		}
		LA7: ;
	}
	goto LA1;
	LA3: ;
	{
		localerror_166155((*n).info, ((NU16) 163), ((NimStringDesc*) &TMP3447));
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semusing_448837)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = newnodei_193351(((NU8) 1), (*n).info);
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = experimentalmode_246279(c);
		if (!!(LOC3)) goto LA4;
		localerror_166166((*n).info, ((NimStringDesc*) &TMP3448));
	}
	LA4: ;
	{
		Tnode191813* e_448852;
		Tnodeseq191807* HEX3Atmp_448892;
		NI i_448895;
		NI L_448897;
		e_448852 = 0;
		HEX3Atmp_448892 = 0;
		HEX3Atmp_448892 = (*n).kindU.S6.sons;
		i_448895 = ((NI) 0);
		L_448897 = (HEX3Atmp_448892 ? HEX3Atmp_448892->Sup.len : 0);
		{
			while (1) {
				if (!(i_448895 < L_448897)) goto LA8;
				e_448852 = HEX3Atmp_448892->data[i_448895];
				{
					Tnode191813* usedsym;
					NimStringDesc* LOC17;
					usedsym = semexpr_410201(c, e_448852, 0);
					{
						if (!((*usedsym).kind == ((NU8) 3))) goto LA12;
						switch ((*(*usedsym).kindU.S4.sym).kind) {
						case ((NU8) 3):
						case ((NU8) 8) ... ((NU8) 11):
						case ((NU8) 21):
						{
							safeadd_414279((&(*(*c).currentscope).usingsyms), usedsym);
							goto LA9;
						}
						break;
						case ((NU8) 12):
						case ((NU8) 18):
						case ((NU8) 17):
						case ((NU8) 14):
						case ((NU8) 15):
						case ((NU8) 13):
						case ((NU8) 16):
						{
							adddeclat_250629((*c).currentscope, (*usedsym).kindU.S4.sym);
							goto LA9;
						}
						break;
						default:
						{
						}
						break;
						}
					}
					LA12: ;
					LOC17 = 0;
					LOC17 = rendertree_213058(e_448852, 0);
					localerror_166155((*e_448852).info, ((NU16) 200), LOC17);
				} LA9: ;
				i_448895 += ((NI) 1);
			} LA8: ;
		}
	}
	return result;
}

N_NIMCALL(Tnode191813*, semasm_432207)(Tcontext245023* con, Tnode191813* n) {
	Tnode191813* result;
	NIM_CHAR marker;
	result = 0;
	checksonslen_246249(n, ((NI) 2));
	marker = pragmaasm_261088(con, (*n).kindU.S6.sons->data[((NI) 0)]);
	{
		if (!((NU8)(marker) == (NU8)(0))) goto LA3;
		marker = 96;
	}
	LA3: ;
	result = semasmoremit_262547(con, n, marker);
	return result;
}

N_NIMCALL(void, semyieldvarresult_448425)(Tcontext245023* c, Tnode191813* n, Ttype191849* restype) {
	Ttype191849* t;
	t = skiptypes_195167(restype, 2048);
	switch ((*t).kind) {
	case ((NU8) 23):
	{
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), takeimplicitaddr_447986(c, (*n).kindU.S6.sons->data[((NI) 0)]));
	}
	break;
	case ((NU8) 18):
	{
		{
			NI i_448452;
			NI HEX3Atmp_448508;
			NI LOC4;
			NI res_448511;
			i_448452 = 0;
			HEX3Atmp_448508 = 0;
			LOC4 = 0;
			LOC4 = sonslen_194351(t);
			HEX3Atmp_448508 = (LOC4 - 1);
			res_448511 = ((NI) 0);
			{
				while (1) {
					Ttype191849* e;
					if (!(res_448511 <= HEX3Atmp_448508)) goto LA6;
					i_448452 = res_448511;
					e = skiptypes_195167((*t).sons->data[i_448452], 2048);
					{
						if (!((*e).kind == ((NU8) 23))) goto LA9;
						{
							if (!((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 37))) goto LA13;
							asgnRefNoCycle((void**) (&(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data[i_448452]), takeimplicitaddr_447986(c, (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data[i_448452]));
						}
						goto LA11;
						LA13: ;
						{
							NIM_BOOL LOC16;
							Tnode191813* a;
							LOC16 = 0;
							LOC16 = ((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 58) || (*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 59));
							if (!(LOC16)) goto LA17;
							LOC16 = ((*(*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data[((NI) 1)]).kind == ((NU8) 37));
							LA17: ;
							if (!LOC16) goto LA18;
							a = (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data[((NI) 1)];
							asgnRefNoCycle((void**) (&(*a).kindU.S6.sons->data[i_448452]), takeimplicitaddr_447986(c, (*a).kindU.S6.sons->data[i_448452]));
						}
						goto LA11;
						LA18: ;
						{
							localerror_166155((*(*n).kindU.S6.sons->data[((NI) 0)]).info, ((NU16) 188), ((NimStringDesc*) &TMP3450));
						}
						LA11: ;
					}
					LA9: ;
					res_448511 += ((NI) 1);
				} LA6: ;
			}
		}
	}
	break;
	default:
	{
	}
	break;
	}
}

N_NIMCALL(Tnode191813*, semyield_448527)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = n;
	checksonslen_246249(n, ((NI) 1));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = ((*(*c).p).owner == NIM_NIL);
		if (LOC3) goto LA4;
		LOC3 = !(((49152 &(1<<(((*(*(*c).p).owner).kind)&31)))!=0));
		LA4: ;
		if (!LOC3) goto LA5;
		localerror_166155((*n).info, ((NU16) 36), ((NimStringDesc*) &TMP2991));
	}
	goto LA1;
	LA5: ;
	{
		NIM_BOOL LOC8;
		LOC8 = 0;
		LOC8 = (((NI) 0) < (*(*c).p).intrystmt);
		if (!(LOC8)) goto LA9;
		LOC8 = !(((*(*(*(*c).p).owner).typ).callconv == ((NU8) 5)));
		LA9: ;
		if (!LOC8) goto LA10;
		localerror_166155((*n).info, ((NU16) 37), ((NimStringDesc*) &TMP2991));
	}
	goto LA1;
	LA10: ;
	{
		Ttype191849* itertype;
		Ttype191849* restype;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 1)))) goto LA13;
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexprwithtype_410211(c, (*n).kindU.S6.sons->data[((NI) 0)], 0));
		itertype = (*(*(*c).p).owner).typ;
		restype = (*itertype).sons->data[((NI) 0)];
		{
			Ttype191849* adjustedres;
			if (!!((restype == NIM_NIL))) goto LA17;
			{
				if (!((*restype).kind == ((NU8) 49))) goto LA21;
				adjustedres = base_221039(restype);
			}
			goto LA19;
			LA21: ;
			{
				adjustedres = restype;
			}
			LA19: ;
			{
				if (!!(((*adjustedres).kind == ((NU8) 6)))) goto LA26;
				asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), fitnode_410245(c, adjustedres, (*n).kindU.S6.sons->data[((NI) 0)]));
			}
			LA26: ;
			{
				if (!((*(*n).kindU.S6.sons->data[((NI) 0)]).typ == NIM_NIL)) goto LA30;
				internalerror_166199((*n).info, ((NimStringDesc*) &TMP3449));
			}
			LA30: ;
			{
				NIM_BOOL LOC34;
				Ttype191849* inferred;
				LOC34 = 0;
				LOC34 = ismetatype_192821(adjustedres);
				if (!(LOC34)) goto LA35;
				LOC34 = !(((*adjustedres).kind == ((NU8) 8)));
				LA35: ;
				if (!LOC34) goto LA36;
				inferred = (*(*n).kindU.S6.sons->data[((NI) 0)]).typ;
				{
					if (!((*restype).kind == ((NU8) 49))) goto LA40;
					asgnRefNoCycle((void**) (&(*restype).sons->data[((NI) 0)]), inferred);
				}
				goto LA38;
				LA40: ;
				{
					asgnRefNoCycle((void**) (&(*itertype).sons->data[((NI) 0)]), inferred);
				}
				LA38: ;
			}
			LA36: ;
			semyieldvarresult_448425(c, n, adjustedres);
		}
		goto LA15;
		LA17: ;
		{
			localerror_166155((*n).info, ((NU16) 39), ((NimStringDesc*) &TMP2991));
		}
		LA15: ;
	}
	goto LA1;
	LA13: ;
	{
		if (!!(((*(*(*(*c).p).owner).typ).sons->data[((NI) 0)] == NIM_NIL))) goto LA45;
		localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3451));
	}
	goto LA1;
	LA45: ;
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, semiterator_440512)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	NU8 kind;
	Tsym191843* s;
	Ttype191849* t;
	result = 0;
	{
		NIM_BOOL LOC3;
		Tnode191813* LOC4;
		Tnode191813* LOC6;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = HEX5BHEX5D_192244(n, ((NI) 4));
		LOC3 = haspragma_264698(LOC4, ((NU16) 137));
		if (LOC3) goto LA5;
		LOC6 = 0;
		LOC6 = HEX5BHEX5D_192244(n, ((NI) 0));
		LOC3 = ((*LOC6).kind == ((NU8) 1));
		LA5: ;
		if (!LOC3) goto LA7;
		kind = ((NU8) 15);
	}
	goto LA1;
	LA7: ;
	{
		kind = ((NU8) 14);
	}
	LA1: ;
	{
		Tnode191813* LOC12;
		Tnode191813* LOC15;
		Tnode191813* LOC16;
		LOC12 = 0;
		LOC12 = HEX5BHEX5D_192244(n, ((NI) 0));
		if (!((*LOC12).kind == ((NU8) 3))) goto LA13;
		LOC15 = 0;
		LOC15 = HEX5BHEX5D_192244(n, ((NI) 0));
		asgnRefNoCycle((void**) (&(*(*LOC15).kindU.S4.sym).owner), getcurrowner_245255());
		LOC16 = 0;
		LOC16 = HEX5BHEX5D_192244(n, ((NI) 0));
		(*(*LOC16).kindU.S4.sym).kind = kind;
	}
	LA13: ;
	result = semprocaux_439890(c, n, kind, TMP3453, ((NU8) 0));
	s = (*(*result).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
	t = (*s).typ;
	{
		NIM_BOOL LOC19;
		LOC19 = 0;
		LOC19 = ((*t).sons->data[((NI) 0)] == NIM_NIL);
		if (!(LOC19)) goto LA20;
		LOC19 = !(((*(*s).typ).callconv == ((NU8) 8)));
		LA20: ;
		if (!LOC19) goto LA21;
		localerror_166155((*n).info, ((NU16) 178), ((NimStringDesc*) &TMP3454));
	}
	LA21: ;
	{
		if (!((*(*s).typ).callconv == ((NU8) 8))) goto LA25;
		(*(*s).typ).flags |= ((NI32)1)<<((((NU8) 11))%(sizeof(NI32)*8));
	}
	goto LA23;
	LA25: ;
	{
		(*(*s).typ).callconv = ((NU8) 5);
	}
	LA23: ;
	{
		NIM_BOOL LOC30;
		LOC30 = 0;
		LOC30 = ((*(*n).kindU.S6.sons->data[((NI) 6)]).kind == ((NU8) 1));
		if (!(LOC30)) goto LA31;
		LOC30 = ((*s).magic == ((NU16) 0));
		LA31: ;
		if (!LOC30) goto LA32;
		localerror_166155((*n).info, ((NU16) 138), (*(*s).name).s);
	}
	LA32: ;
	return result;
}

N_NIMCALL(Tnode191813*, semmethod_440688)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tsym191843* s;
	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = istoplevel_246269(c);
		if (!!(LOC3)) goto LA4;
		localerror_166155((*n).info, ((NU16) 181), ((NimStringDesc*) &TMP3455));
	}
	LA4: ;
	result = semprocaux_439890(c, n, ((NU8) 13), TMP3167, ((NU8) 0));
	s = (*(*result).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
	{
		NIM_BOOL LOC8;
		LOC8 = 0;
		LOC8 = isgenericroutine_196652(s);
		if (!!(LOC8)) goto LA9;
		{
			NIM_BOOL LOC13;
			LOC13 = 0;
			LOC13 = hasobjparam_440633(s);
			if (!LOC13) goto LA14;
			methoddef_356634(s, NIM_FALSE);
		}
		goto LA11;
		LA14: ;
		{
			localerror_166155((*n).info, ((NU16) 182), ((NimStringDesc*) &TMP3455));
		}
		LA11: ;
	}
	LA9: ;
	return result;
}

N_NIMCALL(Tnode191813*, semconverterdef_440699)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tsym191843* s;
	Ttype191849* t;
	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = istoplevel_246269(c);
		if (!!(LOC3)) goto LA4;
		localerror_166155((*n).info, ((NU16) 181), ((NimStringDesc*) &TMP3456));
	}
	LA4: ;
	checksonslen_246249(n, ((NI) 7));
	result = semprocaux_439890(c, n, ((NU8) 16), TMP3167, ((NU8) 0));
	s = (*(*result).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
	t = (*s).typ;
	{
		if (!((*t).sons->data[((NI) 0)] == NIM_NIL)) goto LA8;
		localerror_166155((*n).info, ((NU16) 178), ((NimStringDesc*) &TMP3456));
	}
	LA8: ;
	{
		NI LOC12;
		LOC12 = 0;
		LOC12 = sonslen_194351(t);
		if (!!((LOC12 == ((NI) 2)))) goto LA13;
		localerror_166155((*n).info, ((NU16) 213), ((NimStringDesc*) &TMP3456));
	}
	LA13: ;
	addconverter_245561(c, s);
	return result;
}

N_NIMCALL(Tnode191813*, semmacrodef_440724)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tsym191843* s;
	Ttype191849* t;
	result = 0;
	checksonslen_246249(n, ((NI) 7));
	result = semprocaux_439890(c, n, ((NU8) 17), TMP3457, ((NU8) 0));
	s = (*(*result).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
	t = (*s).typ;
	{
		if (!((*t).sons->data[((NI) 0)] == NIM_NIL)) goto LA3;
		localerror_166155((*n).info, ((NU16) 178), ((NimStringDesc*) &TMP3458));
	}
	LA3: ;
	{
		if (!((*(*n).kindU.S6.sons->data[((NI) 6)]).kind == ((NU8) 1))) goto LA7;
		localerror_166155((*n).info, ((NU16) 138), (*(*s).name).s);
	}
	LA7: ;
	return result;
}

N_NIMCALL(Tnode191813*, evalinclude_440760)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = newnodei_193351(((NU8) 115), (*n).info);
	addson_193819(result, n);
	{
		NI i_440777;
		NI HEX3Atmp_440783;
		NI LOC2;
		NI res_440786;
		i_440777 = 0;
		HEX3Atmp_440783 = 0;
		LOC2 = 0;
		LOC2 = sonslen_194403(n);
		HEX3Atmp_440783 = (NI)(LOC2 - ((NI) 1));
		res_440786 = ((NI) 0);
		{
			while (1) {
				NI32 f;
				if (!(res_440786 <= HEX3Atmp_440783)) goto LA4;
				i_440777 = res_440786;
				f = checkmodulename_252064((*n).kindU.S6.sons->data[i_440777]);
				{
					if (!!((f == ((NI32) -1)))) goto LA7;
					{
						NIM_BOOL LOC11;
						NimStringDesc* LOC14;
						LOC11 = 0;
						LOC11 = containsorincl_188898((&(*c).includedfiles), ((NI) (f)));
						if (!LOC11) goto LA12;
						LOC14 = 0;
						LOC14 = tofilename_165263(f);
						localerror_166155((*n).info, ((NU16) 25), LOC14);
					}
					goto LA9;
					LA12: ;
					{
						Tnode191813* LOC16;
						Tnode191813* LOC17;
						LOC16 = 0;
						LOC16 = gincludefile_242073((*c).module, f);
						LOC17 = 0;
						LOC17 = semstmt_410277(c, LOC16);
						addson_193819(result, LOC17);
						excl_188871((&(*c).includedfiles), ((NI) (f)));
					}
					LA9: ;
				}
				LA7: ;
				res_440786 += ((NI) 1);
			} LA4: ;
		}
	}
	return result;
}

N_NIMCALL(Tnode191813*, semexport_450816)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* x;
	result = 0;
	x = newnodei_193351((*n).kind, (*n).info);
	{
		NI i_450841;
		NI HEX3Atmp_451006;
		NI LOC2;
		NI res_451009;
		i_450841 = 0;
		HEX3Atmp_451006 = 0;
		LOC2 = 0;
		LOC2 = len_192097(n);
		HEX3Atmp_451006 = (LOC2 - 1);
		res_451009 = ((NI) 0);
		{
			while (1) {
				Tnode191813* a;
				Toverloaditer250431 o;
				Tsym191843* s;
				if (!(res_451009 <= HEX3Atmp_451006)) goto LA4;
				i_450841 = res_451009;
				a = (*n).kindU.S6.sons->data[i_450841];
				memset((void*)(&o), 0, sizeof(o));
				s = initoverloaditer_251108((&o), c, a);
				{
					NimStringDesc* LOC9;
					NimStringDesc* LOC10;
					if (!(s == NIM_NIL)) goto LA7;
					LOC9 = 0;
					LOC10 = 0;
					LOC10 = rendertree_213058(a, 0);
					LOC9 = rawNewString(LOC10->Sup.len + 15);
appendString(LOC9, ((NimStringDesc*) &TMP3475));
appendString(LOC9, LOC10);
					localerror_166155((*a).info, ((NU16) 4), LOC9);
				}
				goto LA5;
				LA7: ;
				{
					Tnode191813* LOC14;
					Ttabiter199119 ti;
					Tsym191843* it;
					if (!((*s).kind == ((NU8) 6))) goto LA12;
					strtableadd_199103((&(*(*c).module).kindU.S3.tab), s);
					LOC14 = 0;
					LOC14 = newsymnode_193338(s, (*a).info);
					add_192164(x, LOC14);
					memset((void*)(&ti), 0, sizeof(ti));
					it = inittabiter_199124((&ti), (*s).kindU.S3.tab);
					{
						while (1) {
							if (!!((it == NIM_NIL))) goto LA16;
							{
								if (!((43513792 &(1<<(((*it).kind)&31)))!=0)) goto LA19;
								strtableadd_199103((&(*(*c).module).kindU.S3.tab), it);
							}
							LA19: ;
							it = nextiter_199132((&ti), (*s).kindU.S3.tab);
						} LA16: ;
					}
				}
				goto LA5;
				LA12: ;
				{
					{
						while (1) {
							if (!!((s == NIM_NIL))) goto LA23;
							{
								Tnode191813* LOC28;
								if (!((43513792 &(1<<(((*s).kind)&31)))!=0)) goto LA26;
								LOC28 = 0;
								LOC28 = newsymnode_193338(s, (*a).info);
								add_192164(x, LOC28);
								strtableadd_199103((&(*(*c).module).kindU.S3.tab), s);
							}
							LA26: ;
							s = nextoverloaditer_251277((&o), c, a);
						} LA23: ;
					}
				}
				LA5: ;
				res_451009 += ((NI) 1);
			} LA4: ;
		}
	}
	result = n;
	return result;
}

N_NIMCALL(void, setline_440802)(Tnode191813* n, Tlineinfo164338 info) {
	{
		NI i_440824;
		NI HEX3Atmp_440827;
		NI LOC2;
		NI res_440830;
		i_440824 = 0;
		HEX3Atmp_440827 = 0;
		LOC2 = 0;
		LOC2 = safelen_192125(n);
		HEX3Atmp_440827 = (LOC2 - 1);
		res_440830 = ((NI) 0);
		{
			while (1) {
				if (!(res_440830 <= HEX3Atmp_440827)) goto LA4;
				i_440824 = res_440830;
				setline_440802((*n).kindU.S6.sons->data[i_440824], info);
				res_440830 += ((NI) 1);
			} LA4: ;
		}
	}
	(*n).info = info;
}

N_NIMCALL(Tnode191813*, sempragmablock_440846)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* pragmalist;
	result = 0;
	pragmalist = (*n).kindU.S6.sons->data[((NI) 0)];
	pragma_261069(c, NIM_NIL, pragmalist, TMP3476);
	result = semexpr_410201(c, (*n).kindU.S6.sons->data[((NI) 1)], 0);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 1)]), result);
	{
		NI i_440874;
		NI HEX3Atmp_440879;
		NI LOC2;
		NI res_440882;
		i_440874 = 0;
		HEX3Atmp_440879 = 0;
		LOC2 = 0;
		LOC2 = len_192097(pragmalist);
		HEX3Atmp_440879 = (LOC2 - 1);
		res_440882 = ((NI) 0);
		{
			while (1) {
				NU16 LOC5;
				if (!(res_440882 <= HEX3Atmp_440879)) goto LA4;
				i_440874 = res_440882;
				LOC5 = 0;
				LOC5 = whichpragma_220673((*pragmalist).kindU.S6.sons->data[i_440874]);
				switch (LOC5) {
				case ((NU16) 113):
				{
					setline_440802(result, (*(*pragmalist).kindU.S6.sons->data[i_440874]).info);
				}
				break;
				case ((NU16) 193):
				{
					result = n;
					asgnRefNoCycle((void**) (&(*result).typ), (*(*n).kindU.S6.sons->data[((NI) 1)]).typ);
				}
				break;
				default:
				{
				}
				break;
				}
				res_440882 += ((NI) 1);
			} LA4: ;
		}
	}
	return result;
}

N_NIMCALL(Tnode191813*, semstaticstmt_440898)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* a;
	result = 0;
	a = semstmt_410277(c, (*n).kindU.S6.sons->data[((NI) 0)]);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), a);
	evalstaticstmt_398844((*c).module, a, (*(*c).p).owner);
	result = newnodei_193407(((NU8) 114), (*n).info, ((NI) 1));
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[((NI) 0)]), emptynode_192807);
	return result;
}

N_NIMCALL(Tnode191813*, semexpr_410201)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
{	result = 0;
	result = n;
	{
		if (!(gcmd_155130 == ((NU8) 14))) goto LA3;
		suggestexpr_355070(c, n);
	}
	LA3: ;
	{
		if (!(((*n).flags &(1<<((((NU8) 6))&15)))!=0)) goto LA7;
		goto BeforeRet;
	}
	LA7: ;
	switch ((*n).kind) {
	case ((NU8) 2):
	case ((NU8) 53):
	{
		Tsym191843* s;
		s = lookup_250804(c, n);
		{
			if (!((*c).intypeclass == ((NI) 0))) goto LA12;
			semcapturesym_362834(s, (*(*c).p).owner);
		}
		LA12: ;
		result = semsym_442038(c, n, s, flags);
		{
			if (!((126976 &(1<<(((*s).kind)&31)))!=0)) goto LA16;
			result = symchoice_423316(c, n, s, ((NU8) 0));
			{
				if (!((*result).kind == ((NU8) 3))) goto LA20;
				markindirect_246197(c, (*result).kindU.S4.sym);
			}
			LA20: ;
		}
		LA16: ;
	}
	break;
	case ((NU8) 3):
	{
		result = semsym_442038(c, n, (*n).kindU.S4.sym, flags);
	}
	break;
	case ((NU8) 1):
	case ((NU8) 0):
	case ((NU8) 125):
	{
	}
	break;
	case ((NU8) 23):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA27;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 5)));
		}
		LA27: ;
	}
	break;
	case ((NU8) 6):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA32;
			setintlittype_239776(result);
		}
		LA32: ;
	}
	break;
	case ((NU8) 7):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA37;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 32)));
		}
		LA37: ;
	}
	break;
	case ((NU8) 8):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA42;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 33)));
		}
		LA42: ;
	}
	break;
	case ((NU8) 9):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA47;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 34)));
		}
		LA47: ;
	}
	break;
	case ((NU8) 10):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA52;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 35)));
		}
		LA52: ;
	}
	break;
	case ((NU8) 11):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA57;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 40)));
		}
		LA57: ;
	}
	break;
	case ((NU8) 12):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA62;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 41)));
		}
		LA62: ;
	}
	break;
	case ((NU8) 13):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA67;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 42)));
		}
		LA67: ;
	}
	break;
	case ((NU8) 14):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA72;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 43)));
		}
		LA72: ;
	}
	break;
	case ((NU8) 15):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA77;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 44)));
		}
		LA77: ;
	}
	break;
	case ((NU8) 16):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA82;
			asgnRefNoCycle((void**) (&(*result).typ), getfloatlittype_239688(result));
		}
		LA82: ;
	}
	break;
	case ((NU8) 17):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA87;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 37)));
		}
		LA87: ;
	}
	break;
	case ((NU8) 18):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA92;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 38)));
		}
		LA92: ;
	}
	break;
	case ((NU8) 19):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA97;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 39)));
		}
		LA97: ;
	}
	break;
	case ((NU8) 20) ... ((NU8) 22):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA102;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 28)));
		}
		LA102: ;
	}
	break;
	case ((NU8) 5):
	{
		{
			if (!((*result).typ == NIM_NIL)) goto LA107;
			asgnRefNoCycle((void**) (&(*result).typ), getsystype_239030(((NU8) 2)));
		}
		LA107: ;
	}
	break;
	case ((NU8) 45):
	{
		result = semfieldaccess_441814(c, n, flags);
		{
			if (!((*result).kind == ((NU8) 25))) goto LA112;
			(*result).kind = ((NU8) 27);
			result = semexpr_410201(c, result, flags);
		}
		LA112: ;
	}
	break;
	case ((NU8) 55):
	{
		message_166188((*n).info, ((NU16) 234), ((NimStringDesc*) &TMP3391));
		result = semexpr_410201(c, (*n).kindU.S6.sons->data[((NI) 0)], flags);
	}
	break;
	case ((NU8) 132):
	case ((NU8) 134):
	case ((NU8) 135):
	case ((NU8) 141) ... ((NU8) 150):
	case ((NU8) 137):
	{
		Ttype191849* typ;
		Ttype191849* LOC116;
		LOC116 = 0;
		LOC116 = semtypenode_410269(c, n, NIM_NIL);
		typ = skiptypes_195167(LOC116, IL64(562949953421568));
		asgnRefNoCycle((void**) (&(*result).typ), maketypedesc_245681(c, typ));
	}
	break;
	case ((NU8) 27):
	case ((NU8) 29):
	case ((NU8) 30):
	case ((NU8) 31):
	case ((NU8) 26):
	case ((NU8) 28):
	{
		NU8 mode;
		Tsym191843* s;
		checkminsonslen_246259(n, ((NI) 1));
		{
			if (!(((*n).flags &(1<<((((NU8) 8))&15)))!=0)) goto LA120;
			mode = 0;
		}
		goto LA118;
		LA120: ;
		{
			mode = 2;
		}
		LA118: ;
		s = qualifiedlookup_250864(c, (*n).kindU.S6.sons->data[((NI) 0)], mode);
		{
			if (!!((s == NIM_NIL))) goto LA125;
			switch ((*s).kind) {
			case ((NU8) 17):
			{
				{
					if (!!((((*s).flags &(1<<((((NU8) 25))&31)))!=0))) goto LA130;
					result = semdirectop_411032(c, n, flags);
				}
				goto LA128;
				LA130: ;
				{
					result = semmacroexpr_411066(c, n, n, s, flags);
				}
				LA128: ;
			}
			break;
			case ((NU8) 18):
			{
				{
					if (!!((((*s).flags &(1<<((((NU8) 25))&31)))!=0))) goto LA136;
					result = semdirectop_411032(c, n, flags);
				}
				goto LA134;
				LA136: ;
				{
					result = semtemplateexpr_411055(c, n, s, flags);
				}
				LA134: ;
			}
			break;
			case ((NU8) 7):
			{
				{
					NI LOC142;
					LOC142 = 0;
					LOC142 = len_192097(n);
					if (!(LOC142 == ((NI) 2))) goto LA143;
					result = semconv_443510(c, n);
				}
				goto LA140;
				LA143: ;
				{
					NI LOC146;
					LOC146 = 0;
					LOC146 = len_192097(n);
					if (!(LOC146 == ((NI) 1))) goto LA147;
					result = semobjconstr_446041(c, n, flags);
				}
				goto LA140;
				LA147: ;
				{
					NIM_BOOL LOC150;
					LOC150 = 0;
					LOC150 = contains_188829((&(*c).ambiguoussymbols), (*s).Sup.id);
					if (!LOC150) goto LA151;
					localerror_166155((*n).info, ((NU16) 62), (*(*s).name).s);
				}
				goto LA140;
				LA151: ;
				{
					if (!((*s).magic == ((NU16) 0))) goto LA154;
					result = semdirectop_411032(c, n, flags);
				}
				goto LA140;
				LA154: ;
				{
					result = semmagic_449578(c, n, s, flags);
				}
				LA140: ;
			}
			break;
			case ((NU8) 12):
			case ((NU8) 13):
			case ((NU8) 16):
			case ((NU8) 14):
			case ((NU8) 15):
			{
				{
					if (!((*s).magic == ((NU16) 0))) goto LA160;
					result = semdirectop_411032(c, n, flags);
				}
				goto LA158;
				LA160: ;
				{
					result = semmagic_449578(c, n, s, flags);
				}
				LA158: ;
			}
			break;
			default:
			{
				result = semindirectop_446072(c, n, flags);
			}
			break;
			}
		}
		goto LA123;
		LA125: ;
		{
			NIM_BOOL LOC165;
			Tnode191813* LOC166;
			Tnode191813* LOC168;
			Tnode191813* LOC169;
			LOC165 = 0;
			LOC166 = 0;
			LOC166 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC165 = ((*LOC166).kind == ((NU8) 42));
			if (!(LOC165)) goto LA167;
			LOC168 = 0;
			LOC168 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC169 = 0;
			LOC169 = HEX5BHEX5D_192244(LOC168, ((NI) 0));
			LOC165 = issymchoice_443471(LOC169);
			LA167: ;
			if (!LOC165) goto LA170;
			setgenericparams_451037(c, (*n).kindU.S6.sons->data[((NI) 0)]);
			result = semdirectop_411032(c, n, flags);
		}
		goto LA123;
		LA170: ;
		{
			NIM_BOOL LOC173;
			LOC173 = 0;
			LOC173 = issymchoice_443471((*n).kindU.S6.sons->data[((NI) 0)]);
			if (LOC173) goto LA174;
			LOC173 = (((*n).flags &(1<<((((NU8) 8))&15)))!=0);
			LA174: ;
			if (!LOC173) goto LA175;
			result = semdirectop_411032(c, n, flags);
		}
		goto LA123;
		LA175: ;
		{
			result = semindirectop_446072(c, n, flags);
		}
		LA123: ;
	}
	break;
	case ((NU8) 93):
	{
		{
			if (!((flags &(1<<((((NU8) 3))&15)))!=0)) goto LA181;
			result = semwhen_411040(c, n, NIM_TRUE);
		}
		goto LA179;
		LA181: ;
		{
			result = semwhen_411040(c, n, NIM_FALSE);
			result = semexpr_410201(c, result, flags);
		}
		LA179: ;
	}
	break;
	case ((NU8) 42):
	{
		Tsym191843* s;
		checkminsonslen_246259(n, ((NI) 1));
		s = qualifiedlookup_250864(c, (*n).kindU.S6.sons->data[((NI) 0)], 2);
		{
			NIM_BOOL LOC187;
			NIM_BOOL LOC188;
			Tnode191813* LOC191;
			LOC187 = 0;
			LOC188 = 0;
			LOC188 = !((s == NIM_NIL));
			if (!(LOC188)) goto LA189;
			LOC188 = ((126976 &(1<<(((*s).kind)&31)))!=0);
			LA189: ;
			LOC187 = LOC188;
			if (LOC187) goto LA190;
			LOC191 = 0;
			LOC191 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC187 = ((*LOC191).kind == ((NU8) 56) || (*LOC191).kind == ((NU8) 57));
			LA190: ;
			if (!LOC187) goto LA192;
			asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semsymgenericinstantiation_442019(c, (*n).kindU.S6.sons->data[((NI) 0)], s));
			result = explicitgenericinstantiation_416005(c, n, s);
		}
		goto LA185;
		LA192: ;
		{
			NIM_BOOL LOC195;
			Ttype191849* LOC199;
			LOC195 = 0;
			LOC195 = !((s == NIM_NIL));
			if (!(LOC195)) goto LA196;
			LOC195 = ((128 &(1<<(((*s).kind)&31)))!=0);
			LA196: ;
			if (!LOC195) goto LA197;
			LOC199 = 0;
			LOC199 = semtypenode_410269(c, n, NIM_NIL);
			result = symnodefromtype_411113(c, LOC199, (*n).info);
		}
		goto LA185;
		LA197: ;
		{
			result = semarrayaccess_447898(c, n, flags);
		}
		LA185: ;
	}
	break;
	case ((NU8) 40):
	{
		Tident168021* LOC202;
		Tnode191813* LOC203;
		LOC202 = 0;
		LOC202 = getident_168463(((NimStringDesc*) &TMP3421));
		LOC203 = 0;
		LOC203 = buildoverloadedsubscripts_447722(n, LOC202);
		result = semexpr_410201(c, LOC203, flags);
	}
	break;
	case ((NU8) 43):
	{
		internalerror_166199((*n).info, ((NimStringDesc*) &TMP3422));
	}
	break;
	case ((NU8) 37):
	{
		NU8 LOC206;
		LOC206 = 0;
		LOC206 = checkpar_449990(n);
		switch (LOC206) {
		case ((NU8) 0):
		{
			result = errornode_246160(c, n);
		}
		break;
		case ((NU8) 3):
		{
			Tnode191813* tupexp;
			tupexp = semtuplepositionsconstr_450204(c, n, flags);
			{
				NIM_BOOL LOC211;
				Ttype191849* typ;
				Ttype191849* LOC214;
				LOC211 = 0;
				LOC211 = istupletype_450260(tupexp);
				if (!LOC211) goto LA212;
				LOC214 = 0;
				LOC214 = semtypenode_410269(c, n, NIM_NIL);
				typ = skiptypes_195167(LOC214, IL64(562949953421568));
				asgnRefNoCycle((void**) (&(*result).typ), maketypedesc_245681(c, typ));
			}
			goto LA209;
			LA212: ;
			{
				result = tupexp;
			}
			LA209: ;
		}
		break;
		case ((NU8) 2):
		{
			result = semtuplefieldsconstr_450092(c, n, flags);
		}
		break;
		case ((NU8) 1):
		{
			result = semexpr_410201(c, (*n).kindU.S6.sons->data[((NI) 0)], flags);
		}
		break;
		}
	}
	break;
	case ((NU8) 39):
	{
		result = semsetconstr_449734(c, n);
	}
	break;
	case ((NU8) 41):
	{
		result = semarrayconstr_444273(c, n, flags);
	}
	break;
	case ((NU8) 38):
	{
		result = semobjconstr_446041(c, n, flags);
	}
	break;
	case ((NU8) 51):
	{
		result = semlambda_410261(c, n, flags);
	}
	break;
	case ((NU8) 52):
	{
		result = semdo_439430(c, n, flags);
	}
	break;
	case ((NU8) 47):
	{
		result = semderef_447761(c, n);
	}
	break;
	case ((NU8) 63):
	{
		result = n;
		checksonslen_246249(n, ((NI) 1));
		result = semaddr_445049(c, (*n).kindU.S6.sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 64):
	case ((NU8) 65):
	{
		checksonslen_246249(n, ((NI) 1));
		asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 0)]), semexpr_410201(c, (*n).kindU.S6.sons->data[((NI) 0)], flags));
	}
	break;
	case ((NU8) 61):
	{
		result = semcast_443625(c, n);
	}
	break;
	case ((NU8) 48):
	case ((NU8) 92):
	{
		result = semif_433860(c, n);
	}
	break;
	case ((NU8) 58):
	case ((NU8) 59):
	case ((NU8) 60):
	case ((NU8) 32):
	{
		checksonslen_246249(n, ((NI) 2));
	}
	break;
	case ((NU8) 71):
	case ((NU8) 72):
	case ((NU8) 66):
	case ((NU8) 67):
	{
		checksonslen_246249(n, ((NI) 1));
	}
	break;
	case ((NU8) 68):
	case ((NU8) 69):
	case ((NU8) 70):
	{
		checksonslen_246249(n, ((NI) 3));
	}
	break;
	case ((NU8) 46):
	{
		checkminsonslen_246259(n, ((NI) 2));
	}
	break;
	case ((NU8) 54):
	{
		result = semtableconstr_449895(c, n);
	}
	break;
	case ((NU8) 56):
	case ((NU8) 57):
	{
	}
	break;
	case ((NU8) 62):
	{
		result = semstaticexpr_445882(c, n);
	}
	break;
	case ((NU8) 73):
	{
		result = semasgn_448081(c, n);
	}
	break;
	case ((NU8) 112):
	case ((NU8) 127):
	{
		result = semblock_450650(c, n);
	}
	break;
	case ((NU8) 115):
	case ((NU8) 126):
	{
		result = semstmtlist_441086(c, n, flags);
	}
	break;
	case ((NU8) 108):
	{
		result = semraise_438101(c, n);
	}
	break;
	case ((NU8) 99):
	{
		result = semvarorlet_436418(c, n, ((NU8) 8));
	}
	break;
	case ((NU8) 100):
	{
		result = semvarorlet_436418(c, n, ((NU8) 9));
	}
	break;
	case ((NU8) 101):
	{
		result = semconst_436982(c, n);
	}
	break;
	case ((NU8) 98):
	{
		result = semtypesection_438873(c, n);
	}
	break;
	case ((NU8) 114):
	{
		result = semdiscard_432006(c, n);
	}
	break;
	case ((NU8) 96):
	{
		result = semwhile_432217(c, n);
	}
	break;
	case ((NU8) 106):
	{
		result = semtry_434715(c, n);
	}
	break;
	case ((NU8) 110):
	case ((NU8) 111):
	{
		result = sembreakorcontinue_432027(c, n);
	}
	break;
	case ((NU8) 94):
	case ((NU8) 95):
	{
		result = semfor_437981(c, n);
	}
	break;
	case ((NU8) 97):
	{
		result = semcase_434301(c, n);
	}
	break;
	case ((NU8) 109):
	{
		result = semreturn_448260(c, n);
	}
	break;
	case ((NU8) 124):
	{
		result = semusing_448837(c, n);
	}
	break;
	case ((NU8) 89):
	{
		result = semasm_432207(c, n);
	}
	break;
	case ((NU8) 104):
	{
		result = semyield_448527(c, n);
	}
	break;
	case ((NU8) 90):
	{
		pragma_261069(c, (*(*c).p).owner, n, TMP3452);
	}
	break;
	case ((NU8) 84):
	{
		result = semiterator_440512(c, n);
	}
	break;
	case ((NU8) 79):
	{
		result = semproc_432397(c, n);
	}
	break;
	case ((NU8) 80):
	{
		result = semmethod_440688(c, n);
	}
	break;
	case ((NU8) 81):
	{
		result = semconverterdef_440699(c, n);
	}
	break;
	case ((NU8) 82):
	{
		result = semmacrodef_440724(c, n);
	}
	break;
	case ((NU8) 83):
	{
		result = semtemplatedef_426550(c, n);
	}
	break;
	case ((NU8) 116):
	{
		{
			NIM_BOOL LOC263;
			LOC263 = 0;
			LOC263 = istoplevel_246269(c);
			if (!!(LOC263)) goto LA264;
			localerror_166155((*n).info, ((NU16) 181), ((NimStringDesc*) &TMP3459));
		}
		LA264: ;
		result = evalimport_252004(c, n);
	}
	break;
	case ((NU8) 117):
	{
		{
			NIM_BOOL LOC269;
			LOC269 = 0;
			LOC269 = istoplevel_246269(c);
			if (!!(LOC269)) goto LA270;
			localerror_166155((*n).info, ((NU16) 181), ((NimStringDesc*) &TMP3459));
		}
		LA270: ;
		result = evalimportexcept_252857(c, n);
	}
	break;
	case ((NU8) 120):
	{
		{
			NIM_BOOL LOC275;
			LOC275 = 0;
			LOC275 = istoplevel_246269(c);
			if (!!(LOC275)) goto LA276;
			localerror_166155((*n).info, ((NU16) 181), ((NimStringDesc*) &TMP3470));
		}
		LA276: ;
		result = evalfrom_252011(c, n);
	}
	break;
	case ((NU8) 121):
	{
		{
			NIM_BOOL LOC281;
			LOC281 = 0;
			LOC281 = istoplevel_246269(c);
			if (!!(LOC281)) goto LA282;
			localerror_166155((*n).info, ((NU16) 181), ((NimStringDesc*) &TMP3473));
		}
		LA282: ;
		result = evalinclude_440760(c, n);
	}
	break;
	case ((NU8) 118):
	case ((NU8) 119):
	{
		{
			NIM_BOOL LOC287;
			LOC287 = 0;
			LOC287 = istoplevel_246269(c);
			if (!!(LOC287)) goto LA288;
			localerror_166155((*n).info, ((NU16) 181), ((NimStringDesc*) &TMP3474));
		}
		LA288: ;
		result = semexport_450816(c, n);
	}
	break;
	case ((NU8) 91):
	{
		result = sempragmablock_440846(c, n);
	}
	break;
	case ((NU8) 113):
	{
		result = semstaticstmt_440898(c, n);
	}
	break;
	case ((NU8) 105):
	{
		localerror_166155((*n).info, ((NU16) 4), ((NimStringDesc*) &TMP3477));
	}
	break;
	default:
	{
		NimStringDesc* LOC294;
		LOC294 = 0;
		LOC294 = rendertree_213058(n, 4);
		localerror_166155((*n).info, ((NU16) 168), LOC294);
	}
	break;
	}
	{
		if (!!((result == NIM_NIL))) goto LA297;
		(*result).flags |= ((NI16)1)<<((((NU8) 6))%(sizeof(NI16)*8));
	}
	LA297: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semexprwithtype_410211)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	result = 0;
	result = semexpr_410201(c, n, (flags | 128));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = result == 0;
		if (LOC3) goto LA4;
		LOC3 = ((*result).kind == ((NU8) 1));
		LA4: ;
		if (!LOC3) goto LA5;
		result = errornode_246160(c, n);
	}
	LA5: ;
	{
		NIM_BOOL LOC9;
		NimStringDesc* LOC13;
		LOC9 = 0;
		LOC9 = ((*result).typ == NIM_NIL);
		if (LOC9) goto LA10;
		LOC9 = ((*result).typ == enforcevoidcontext_432005);
		LA10: ;
		if (!LOC9) goto LA11;
		LOC13 = 0;
		LOC13 = rendertree_213058(result, 4);
		localerror_166155((*n).info, ((NU16) 90), LOC13);
		asgnRefNoCycle((void**) (&(*result).typ), errortype_246150(c));
	}
	goto LA7;
	LA11: ;
	{
		semprocvarcheck_432366(c, result);
		{
			if (!((*(*result).typ).kind == ((NU8) 23))) goto LA17;
			result = newderef_358024(result);
		}
		LA17: ;
		semdestructorcheck_433440(c, result, flags);
	}
	LA7: ;
	return result;
}

N_NIMCALL(Tnode191813*, semconstexpr_411485)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tnode191813* e;
{	result = 0;
	e = semexprwithtype_410211(c, n, 0);
	{
		if (!(e == NIM_NIL)) goto LA3;
		localerror_166155((*n).info, ((NU16) 104), ((NimStringDesc*) &TMP2991));
		result = n;
		goto BeforeRet;
	}
	LA3: ;
	result = getconstexpr_257004((*c).module, e);
	{
		if (!(result == NIM_NIL)) goto LA7;
		result = evalconstexpr_398821((*c).module, e);
		{
			NIM_BOOL LOC11;
			LOC11 = 0;
			LOC11 = (result == NIM_NIL);
			if (LOC11) goto LA12;
			LOC11 = ((*result).kind == ((NU8) 1));
			LA12: ;
			if (!LOC11) goto LA13;
			{
				NIM_BOOL LOC17;
				LOC17 = 0;
				LOC17 = HEX3DHEX3D_165789((*e).info, (*n).info);
				if (!!(LOC17)) goto LA18;
				pushinfocontext_165189((*n).info);
				localerror_166155((*e).info, ((NU16) 104), ((NimStringDesc*) &TMP2991));
				popinfocontext_165208();
			}
			goto LA15;
			LA18: ;
			{
				localerror_166155((*e).info, ((NU16) 104), ((NimStringDesc*) &TMP2991));
			}
			LA15: ;
			result = e;
		}
		goto LA9;
		LA13: ;
		{
			result = fixuptypeaftereval_411201(c, result, e);
		}
		LA9: ;
	}
	LA7: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, tryconstexpr_411420)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* volatile result;
	Tnode191813* e;
	NI olderrorcount;
	NI olderrormax;
	NU8 olderroroutputs;
	TSafePoint TMP3478;
{	result = 0;
	e = semexprwithtype_410211(c, n, 0);
	{
		if (!(e == NIM_NIL)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	result = getconstexpr_257004((*c).module, e);
	{
		if (!!((result == NIM_NIL))) goto LA7;
		goto BeforeRet;
	}
	LA7: ;
	olderrorcount = gerrorcounter_165012;
	olderrormax = gerrormax_165015;
	olderroroutputs = erroroutputs_165053;
	erroroutputs_165053 = 0;
	gerrormax_165015 = ((NI) IL64(9223372036854775807));
	pushSafePoint(&TMP3478);
	TMP3478.status = setjmp(TMP3478.context);
	if (TMP3478.status == 0) {
		result = evalconstexpr_398821((*c).module, e);
		{
			NIM_BOOL LOC12;
			LOC12 = 0;
			LOC12 = (result == NIM_NIL);
			if (LOC12) goto LA13;
			LOC12 = ((*result).kind == ((NU8) 1));
			LA13: ;
			if (!LOC12) goto LA14;
			result = NIM_NIL;
		}
		goto LA10;
		LA14: ;
		{
			result = fixuptypeaftereval_411201(c, result, e);
		}
		LA10: ;
		popSafePoint();
	}
	else {
		popSafePoint();
		if (isObj(getCurrentException()->Sup.m_type, (&NTI164344))) {
			TMP3478.status = 0;
			result = NIM_NIL;
			popCurrentException();
		}
	}
	if (TMP3478.status != 0) reraiseException();
	gerrorcounter_165012 = olderrorcount;
	gerrormax_165015 = olderrormax;
	erroroutputs_165053 = olderroroutputs;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, semoperand_441821)(Tcontext245023* c, Tnode191813* n, NU16 flags) {
	Tnode191813* result;
	result = 0;
	result = semexpr_410201(c, n, (flags | 256));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = ((*result).kind == ((NU8) 1));
		if (!(LOC3)) goto LA4;
		LOC3 = (*result).typ == 0;
		LA4: ;
		if (!LOC3) goto LA5;
		result = errornode_246160(c, n);
	}
	LA5: ;
	{
		if (!!(((*result).typ == NIM_NIL))) goto LA9;
		{
			if (!((*(*result).typ).kind == ((NU8) 23))) goto LA13;
			result = newderef_358024(result);
		}
		LA13: ;
	}
	goto LA7;
	LA9: ;
	{
		if (!!(((24 & flags) == 0))) goto LA16;
		asgnRefNoCycle((void**) (&(*result).typ), newtypes_245218(((NU8) 3), c));
	}
	goto LA7;
	LA16: ;
	{
		NimStringDesc* LOC19;
		LOC19 = 0;
		LOC19 = rendertree_213058(result, 4);
		localerror_166155((*n).info, ((NU16) 90), LOC19);
		asgnRefNoCycle((void**) (&(*result).typ), errortype_246150(c));
	}
	LA7: ;
	return result;
}

N_NIMCALL(Tnode191813*, seminferredlambda_439457)(Tcontext245023* c, Tidtable191861 pt, Tnode191813* n_439461) {
	Tnode191813* result;
	Tnode191813* n;
	Tscope191837* LOC1;
	Tsym191843* s;
	Tnode191813* sembody;
	Tnode191813* LOC2;
	result = 0;
	n = n_439461;
	n = replacetypesinbody_268617(c, pt, n);
	result = n;
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 2)]), emptynode_192807);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 3)]), (*(*n).typ).n);
	LOC1 = 0;
	LOC1 = openscope_250091(c);
	s = (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym;
	pushowner_245260(s);
	addparams_410293(c, (*(*n).typ).n, ((NU8) 12));
	pushproccon_245358(c, s);
	addresult_438997(c, (*(*n).typ).sons->data[((NI) 0)], (*n).info, ((NU8) 12));
	addresultnode_439031(c, n);
	LOC2 = 0;
	LOC2 = semprocbody_410238(c, (*n).kindU.S6.sons->data[((NI) 6)]);
	sembody = hlobody_412161(c, LOC2);
	asgnRefNoCycle((void**) (&(*n).kindU.S6.sons->data[((NI) 6)]), transformbody_371118((*c).module, sembody, (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym));
	popproccon_245390(c);
	popowner_245266();
	closescope_250111(c);
	asgnRefNoCycle((void**) (&(*s).ast), result);
	return result;
}

N_NIMCALL(Tpasscontext242005*, myopen_451686)(Tsym191843* module) {
	Tpasscontext242005* result;
	Tcontext245023* c;
	TY245124 LOC5;
	TY245130 LOC6;
	result = 0;
	c = newcontext_245181(module);
	{
		if (!!(((*c).p == NIM_NIL))) goto LA3;
		internalerror_166199((*module).info, ((NimStringDesc*) &TMP1963));
	}
	LA3: ;
	(*c).semconstexpr = semconstexpr_411485;
	(*c).semexpr = semexpr_410201;
	(*c).semtryexpr = tryexpr_410317;
	(*c).semtryconstexpr = tryconstexpr_411420;
	(*c).semoperand = semoperand_441821;
	(*c).semconstboolexpr = semconstboolexpr_416652;
	(*c).semoverloadedcall = semoverloadedcall_415892;
	memset((void*)(&LOC5), 0, sizeof(LOC5));
	LOC5.ClPrc = ((TMP3479) (seminferredlambda_439457)); LOC5.ClEnv = NIM_NIL;
	asgnRef((void**) (&(*c).seminferredlambda.ClEnv), LOC5.ClEnv);
	(*c).seminferredlambda.ClPrc = LOC5.ClPrc;
	memset((void*)(&LOC6), 0, sizeof(LOC6));
	LOC6.ClPrc = ((TMP3480) (generateinstance_413450)); LOC6.ClEnv = NIM_NIL;
	asgnRef((void**) (&(*c).semgenerateinstance.ClEnv), LOC6.ClEnv);
	(*c).semgenerateinstance.ClPrc = LOC6.ClPrc;
	(*c).semtypenode = semtypenode_410269;
	(*c).insttypeboundop = insttypeboundop_351551;
	pushproccon_245358(c, module);
	pushowner_245260((*c).module);
	asgnRef((void**) (&(*c).importtable), openscope_250091(c));
	strtableadd_199103((&(*(*c).importtable).symbols), module);
	{
		if (!(((*module).flags &(1<<((((NU8) 13))&31)))!=0)) goto LA9;
		asgnRefNoCycle((void**) (&systemmodule_239019), module);
	}
	goto LA7;
	LA9: ;
	{
		strtableadd_199103((&(*(*c).importtable).symbols), systemmodule_239019);
		importallsymbols_252389(c, systemmodule_239019);
	}
	LA7: ;
	asgnRef((void**) (&(*c).toplevelscope), openscope_250091(c));
	result = &c->Sup;
	return result;
}

N_NIMCALL(Tpasscontext242005*, myopencached_451723)(Tsym191843* module, Trodreader234030* rd) {
	Tpasscontext242005* result;
	result = 0;
	result = myopen_451686(module);
	{
		Tsym191843* m_451737;
		Tsymseq191815* HEX3Atmp_451739;
		NI i_451742;
		NI L_451744;
		m_451737 = 0;
		HEX3Atmp_451739 = 0;
		HEX3Atmp_451739 = (*rd).methods;
		i_451742 = ((NI) 0);
		L_451744 = (HEX3Atmp_451739 ? HEX3Atmp_451739->Sup.len : 0);
		{
			while (1) {
				if (!(i_451742 < L_451744)) goto LA3;
				m_451737 = HEX3Atmp_451739->data[i_451742];
				methoddef_356634(m_451737, NIM_TRUE);
				i_451742 += ((NI) 1);
			} LA3: ;
		}
	}
	return result;
}

N_NIMCALL(void, addcodeforgenerics_451577)(Tcontext245023* c, Tnode191813* n) {
	{
		NI i_451601;
		NI HEX3Atmp_451663;
		NI HEX3Atmp_451664;
		NI res_451667;
		i_451601 = 0;
		HEX3Atmp_451663 = 0;
		HEX3Atmp_451664 = 0;
		HEX3Atmp_451663 = (*c).lastgenericidx;
		HEX3Atmp_451664 = (NI)(((*c).generics ? (*c).generics->Sup.len : 0) - ((NI) 1));
		res_451667 = HEX3Atmp_451663;
		{
			while (1) {
				Tsym191843* prc;
				if (!(res_451667 <= HEX3Atmp_451664)) goto LA3;
				i_451601 = res_451667;
				prc = (*(*c).generics->data[i_451601].inst).sym;
				{
					NIM_BOOL LOC6;
					LOC6 = 0;
					LOC6 = ((77824 &(1<<(((*prc).kind)&31)))!=0);
					if (!(LOC6)) goto LA7;
					LOC6 = ((*prc).magic == ((NU16) 0));
					LA7: ;
					if (!LOC6) goto LA8;
					{
						NIM_BOOL LOC12;
						NimStringDesc* LOC16;
						LOC12 = 0;
						LOC12 = ((*prc).ast == NIM_NIL);
						if (LOC12) goto LA13;
						LOC12 = ((*(*prc).ast).kindU.S6.sons->data[((NI) 6)] == NIM_NIL);
						LA13: ;
						if (!LOC12) goto LA14;
						LOC16 = 0;
						LOC16 = rawNewString((*(*prc).name).s->Sup.len + 12);
appendString(LOC16, ((NimStringDesc*) &TMP3483));
appendString(LOC16, (*(*prc).name).s);
						internalerror_166199((*prc).info, LOC16);
					}
					goto LA10;
					LA14: ;
					{
						addson_193819(n, (*prc).ast);
					}
					LA10: ;
				}
				LA8: ;
				res_451667 += ((NI) 1);
			} LA3: ;
		}
	}
	(*c).lastgenericidx = ((*c).generics ? (*c).generics->Sup.len : 0);
}

N_NIMCALL(Tnode191813*, hlostmt_412187)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
{	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = (((*c).patterns ? (*c).patterns->Sup.len : 0) == ((NI) 0));
		if (LOC3) goto LA4;
		LOC3 = !(((goptions_155126 &(1<<((((NU8) 21))&31)))!=0));
		LA4: ;
		if (!LOC3) goto LA5;
		result = n;
		goto BeforeRet;
	}
	LA5: ;
	(*c).hloloopdetector = ((NI) 0);
	result = hlo_411542(c, n);
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, buildechostmt_446413)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	Tsym191843* e;
	Tident168021* LOC1;
	result = 0;
	result = newnodei_193351(((NU8) 27), (*n).info);
	LOC1 = 0;
	LOC1 = getident_168463(((NimStringDesc*) &TMP3484));
	e = strtableget_199111((*systemmodule_239019).kindU.S3.tab, LOC1);
	{
		Tnode191813* LOC6;
		if (!!((e == NIM_NIL))) goto LA4;
		LOC6 = 0;
		LOC6 = newsymnode_193325(e);
		add_192164(result, LOC6);
	}
	goto LA2;
	LA4: ;
	{
		Tnode191813* LOC8;
		localerror_166155((*n).info, ((NU16) 64), ((NimStringDesc*) &TMP3485));
		LOC8 = 0;
		LOC8 = errornode_246160(c, n);
		add_192164(result, LOC8);
	}
	LA2: ;
	add_192164(result, n);
	result = semexpr_410201(c, result, 0);
	return result;
}

N_NIMCALL(Tnode191813*, semstmtandgenerategenerics_451760)(Tcontext245023* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = semstmt_410277(c, n);
	{
		Tnode191813* a;
		if (!((*c).lastgenericidx < ((*c).generics ? (*c).generics->Sup.len : 0))) goto LA3;
		a = newnodei_193351(((NU8) 115), (*n).info);
		addcodeforgenerics_451577(c, a);
		{
			NI LOC7;
			LOC7 = 0;
			LOC7 = sonslen_194403(a);
			if (!(((NI) 0) < LOC7)) goto LA8;
			{
				if (!!(((*result).kind == ((NU8) 1)))) goto LA12;
				addson_193819(a, result);
			}
			LA12: ;
			result = a;
		}
		LA8: ;
	}
	LA3: ;
	result = hlostmt_412187(c, result);
	{
		NIM_BOOL LOC16;
		NIM_BOOL LOC18;
		LOC16 = 0;
		LOC16 = (gcmd_155130 == ((NU8) 18));
		if (!(LOC16)) goto LA17;
		LOC18 = 0;
		LOC18 = isemptytype_196934((*result).typ);
		LOC16 = !(LOC18);
		LA17: ;
		if (!LOC16) goto LA19;
		result = buildechostmt_446413(c, result);
	}
	LA19: ;
	result = transformstmt_371207((*c).module, result);
	return result;
}

N_NIMCALL(void, recovercontext_451798)(Tcontext245023* c) {
	asgnRef((void**) (&(*c).currentscope), (*c).toplevelscope);
	{
		while (1) {
			Tsym191843* LOC3;
			LOC3 = 0;
			LOC3 = getcurrowner_245255();
			if (!!(((*LOC3).kind == ((NU8) 6)))) goto LA2;
			popowner_245266();
		} LA2: ;
	}
	{
		while (1) {
			NIM_BOOL LOC6;
			LOC6 = 0;
			LOC6 = !(((*c).p == NIM_NIL));
			if (!(LOC6)) goto LA7;
			LOC6 = !(((*(*(*c).p).owner).kind == ((NU8) 6)));
			LA7: ;
			if (!LOC6) goto LA5;
			asgnRef((void**) (&(*c).p), (*(*c).p).next);
		} LA5: ;
	}
}

static N_INLINE(NIM_BOOL, isObjWithCache)(TNimType* obj, TNimType* subclass, TNimType** cache) {
	NIM_BOOL result;
{	result = 0;
	{
		if (!(obj == subclass)) goto LA3;
		result = NIM_TRUE;
		goto BeforeRet;
	}
	LA3: ;
	{
		if (!((*obj).base == subclass)) goto LA7;
		result = NIM_TRUE;
		goto BeforeRet;
	}
	LA7: ;
	{
		if (!(cache[(((NI) 0))- 0] == obj)) goto LA11;
		result = NIM_FALSE;
		goto BeforeRet;
	}
	LA11: ;
	{
		if (!(cache[(((NI) 1))- 0] == obj)) goto LA15;
		result = NIM_TRUE;
		goto BeforeRet;
	}
	LA15: ;
	result = isobjslowpath_22817(obj, subclass, cache);
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, myprocess_451851)(Tpasscontext242005* context, Tnode191813* n) {
	Tnode191813* volatile result;
	Tcontext245023* c;
	result = 0;
	c = ((Tcontext245023*) (context));
	{
		if (!(gerrormax_165015 <= ((NI) 1))) goto LA3;
		result = semstmtandgenerategenerics_451760(c, n);
	}
	goto LA1;
	LA3: ;
	{
		NI oldcontextlen;
		NI oldingenericinst;
		TSafePoint TMP3486;
		oldcontextlen = getinfocontextlen_165153();
		oldingenericinst = (*c).ingenericinst;
		pushSafePoint(&TMP3486);
		TMP3486.status = setjmp(TMP3486.context);
		if (TMP3486.status == 0) {
			result = semstmtandgenerategenerics_451760(c, n);
			popSafePoint();
		}
		else {
			popSafePoint();
			if (isObj(getCurrentException()->Sup.m_type, (&NTI164344))||isObj(getCurrentException()->Sup.m_type, (&NTI164346))) {
				TMP3486.status = 0;
				recovercontext_451798(c);
				(*c).ingenericinst = oldingenericinst;
				setinfocontextlen_165170(oldcontextlen);
				{
					Exception* LOC11;
					LOC11 = 0;
					LOC11 = getCurrentException();
					if (!((LOC11) && (isObjWithCache((*LOC11).Sup.m_type, (&NTI164346), Nim_OfCheck_CACHE1)))) goto LA12;
					result = NIM_NIL;
				}
				goto LA9;
				LA12: ;
				{
					result = emptynode_192807;
				}
				LA9: ;
				popCurrentException();
			}
		}
		if (TMP3486.status != 0) reraiseException();
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, myclose_451867)(Tpasscontext242005* context, Tnode191813* n) {
	Tnode191813* result;
	Tcontext245023* c;
	result = 0;
	c = ((Tcontext245023*) (context));
	closescope_250111(c);
	rawclosescope_250102(c);
	result = newnode_192401(((NU8) 115));
	{
		if (!!((n == NIM_NIL))) goto LA3;
		internalerror_166199((*n).info, ((NimStringDesc*) &TMP3487));
	}
	LA3: ;
	addcodeforgenerics_451577(c, result);
	{
		if (!!(((*(*c).module).ast == NIM_NIL))) goto LA7;
		add_192164(result, (*(*c).module).ast);
	}
	LA7: ;
	popowner_245266();
	popproccon_245390(c);
	return result;
}
NIM_EXTERNC N_NOINLINE(void, nimsrc_semInit)(void) {
	Ttype191849* LOC1;
	Ttype191849* LOC2;
	Tident168021* LOC3;
	Tlineinfo164338 LOC4;
	LOC1 = 0;
	LOC1 = (Ttype191849*) newObj((&NTI191809), sizeof(Ttype191849));
	(*LOC1).Sup.Sup.m_type = (&NTI191849);
	(*LOC1).kind = ((NU8) 6);
	asgnRefNoCycle((void**) (&commontypebegin_410472), LOC1);
	asgnRefNoCycle((void**) (&typedescid_420273), getident_168463(((NimStringDesc*) &TMP1035)));
	LOC2 = 0;
	LOC2 = (Ttype191849*) newObj((&NTI191809), sizeof(Ttype191849));
	(*LOC2).Sup.Sup.m_type = (&NTI191849);
	(*LOC2).kind = ((NU8) 7);
	asgnRefNoCycle((void**) (&enforcevoidcontext_432005), LOC2);
	if (analyzingdestructor_432401) nimGCunrefNoCycle(analyzingdestructor_432401);
	analyzingdestructor_432401 = (Tsym191843*) newObjRC1((&NTI191811), sizeof(Tsym191843));
	(*analyzingdestructor_432401).Sup.Sup.m_type = (&NTI191843);
	if (destructoristrivial_432402) nimGCunrefNoCycle(destructoristrivial_432402);
	destructoristrivial_432402 = (Tsym191843*) newObjRC1((&NTI191811), sizeof(Tsym191843));
	(*destructoristrivial_432402).Sup.Sup.m_type = (&NTI191843);
	asgnRefNoCycle((void**) (&destructorname_432419), getident_168463(((NimStringDesc*) &TMP1036)));
	asgnRefNoCycle((void**) (&destructorparam_432420), getident_168463(((NimStringDesc*) &TMP1037)));
	LOC3 = 0;
	LOC3 = getident_168463(((NimStringDesc*) &TMP1038));
	LOC4 = unknownlineinfo_165024();
	asgnRefNoCycle((void**) (&destructorpragma_432421), newidentnode_193313(LOC3, LOC4));
}

NIM_EXTERNC N_NOINLINE(void, nimsrc_semDatInit)(void) {
static TNimNode* TMP3104[2];
static TNimNode* TMP3132[5];
static TNimNode* TMP4010[2];
static TNimNode TMP862[12];
NTI413758.size = sizeof(TY413758);
NTI413758.kind = 18;
NTI413758.base = 0;
NTI413758.flags = 2;
TMP3104[0] = &TMP862[1];
TMP862[1].kind = 1;
TMP862[1].offset = offsetof(TY413758, Field0);
TMP862[1].typ = (&NTI191811);
TMP862[1].name = "Field0";
TMP3104[1] = &TMP862[2];
TMP862[2].kind = 1;
TMP862[2].offset = offsetof(TY413758, Field1);
TMP862[2].typ = (&NTI108);
TMP862[2].name = "Field1";
TMP862[0].len = 2; TMP862[0].kind = 2; TMP862[0].sons = &TMP3104[0];
NTI413758.node = &TMP862[0];
NTI413757.size = sizeof(TY413757*);
NTI413757.kind = 24;
NTI413757.base = (&NTI413758);
NTI413757.flags = 2;
NTI413757.marker = TMP3105;
NTI421253.size = sizeof(TY421253);
NTI421253.kind = 18;
NTI421253.base = 0;
TMP3132[0] = &TMP862[4];
TMP862[4].kind = 1;
TMP862[4].offset = offsetof(TY421253, HEX3Astate);
TMP862[4].typ = (&NTI311033);
TMP862[4].name = ":state";
TMP3132[1] = &TMP862[5];
TMP862[5].kind = 1;
TMP862[5].offset = offsetof(TY421253, paramname420285);
TMP862[5].typ = (&NTI149);
TMP862[5].name = "paramName420285";
TMP3132[2] = &TMP862[6];
TMP862[6].kind = 1;
TMP862[6].offset = offsetof(TY421253, genericparams420283);
TMP862[6].typ = (&NTI191805);
TMP862[6].name = "genericParams420283";
TMP3132[3] = &TMP862[7];
TMP862[7].kind = 1;
TMP862[7].offset = offsetof(TY421253, info420286);
TMP862[7].typ = (&NTI164338);
TMP862[7].name = "info420286";
TMP3132[4] = &TMP862[8];
TMP862[8].kind = 1;
TMP862[8].offset = offsetof(TY421253, c420281);
TMP862[8].typ = (&NTI245021);
TMP862[8].name = "c420281";
TMP862[3].len = 5; TMP862[3].kind = 2; TMP862[3].sons = &TMP3132[0];
NTI421253.node = &TMP862[3];
NTI421311.size = sizeof(TY421253*);
NTI421311.kind = 22;
NTI421311.base = (&NTI421253);
NTI421311.marker = TMP3133;
NTI433269.size = sizeof(TY433269);
NTI433269.kind = 18;
NTI433269.base = 0;
NTI433269.flags = 2;
TMP4010[0] = &TMP862[10];
TMP862[10].kind = 1;
TMP862[10].offset = offsetof(TY433269, Field0);
TMP862[10].typ = (&NTI191805);
TMP862[10].name = "Field0";
TMP4010[1] = &TMP862[11];
TMP862[11].kind = 1;
TMP862[11].offset = offsetof(TY433269, Field1);
TMP862[11].typ = (&NTI191805);
TMP862[11].name = "Field1";
TMP862[9].len = 2; TMP862[9].kind = 2; TMP862[9].sons = &TMP4010[0];
NTI433269.node = &TMP862[9];
}

