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

#include <string.h>
typedef struct Tnode191813 Tnode191813;
typedef struct Ttype191849 Ttype191849;
typedef struct Tlineinfo164338 Tlineinfo164338;
typedef struct NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
typedef struct Tsym191843 Tsym191843;
typedef struct Tident168021 Tident168021;
typedef struct Tnodeseq191807 Tnodeseq191807;
typedef struct TNimType TNimType;
typedef struct TNimNode TNimNode;
typedef struct Tidobj168015 Tidobj168015;
typedef struct TNimObject TNimObject;
typedef struct Ttypeseq191845 Ttypeseq191845;
typedef struct Tloc191827 Tloc191827;
typedef struct Ropeobj162009 Ropeobj162009;
typedef struct Tscope191837 Tscope191837;
typedef struct TY191944 TY191944;
typedef struct Tstrtable191817 Tstrtable191817;
typedef struct Tsymseq191815 Tsymseq191815;
typedef struct Tlib191831 Tlib191831;
typedef struct Tinstantiation191833 Tinstantiation191833;
typedef struct TY191933 TY191933;
typedef struct Tlistentry130022 Tlistentry130022;
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 Tidtable191861 Tidtable191861;
typedef struct Tidpairseq191859 Tidpairseq191859;
typedef struct Tidpair191857 Tidpair191857;
typedef struct Tnodetable191873 Tnodetable191873;
typedef struct Tnodepairseq191871 Tnodepairseq191871;
typedef struct Tnodepair191869 Tnodepair191869;
typedef struct TY86545 TY86545;
typedef struct Tidnodetable191867 Tidnodetable191867;
typedef struct Tidnodepairseq191865 Tidnodepairseq191865;
typedef struct Tidnodepair191863 Tidnodepair191863;
typedef struct Tbasechunk27438 Tbasechunk27438;
typedef struct Tfreecell27430 Tfreecell27430;
struct  Tlineinfo164338  {
NI16 line;
NI16 col;
NI32 fileindex;
};
struct  TGenericSeq  {
NI len;
NI reserved;
};
struct  NimStringDesc  {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
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;
};
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  TNimNode  {
NU8 kind;
NI offset;
TNimType* typ;
NCSTRING name;
NI len;
TNimNode** sons;
};
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  Tstrtable191817  {
NI counter;
Tsymseq191815* data;
};
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  Tscope191837  {
NI depthlevel;
Tstrtable191817 symbols;
Tnodeseq191807* usingsyms;
Tscope191837* parent;
};
struct  Tinstantiation191833  {
Tsym191843* sym;
Ttypeseq191845* concretetypes;
TY191933* usedby;
};
struct  Tlistentry130022  {
  TNimObject Sup;
Tlistentry130022* prev;
Tlistentry130022* next;
};
struct  Tlib191831  {
  Tlistentry130022 Sup;
NU8 kind;
NIM_BOOL generated;
NIM_BOOL isoverriden;
Ropeobj162009* name;
Tnode191813* path;
};
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  Tidtable191861  {
NI counter;
Tidpairseq191859* data;
};
struct  Tidpair191857  {
Tidobj168015* key;
TNimObject* val;
};
struct  Tnodetable191873  {
NI counter;
Tnodepairseq191871* data;
};
struct  Tnodepair191869  {
NI h;
Tnode191813* key;
NI val;
};
typedef Tnode191813* TY194071[7];
typedef NimStringDesc* TY191020[10];
struct TY86545 {
NimStringDesc* Field0;
NI Field1;
};
typedef Tnode191813* TY209680[1];
struct  Tidnodetable191867  {
NI counter;
Tidnodepairseq191865* data;
};
struct  Tidnodepair191863  {
Tidobj168015* key;
Tnode191813* val;
};
typedef NU8 TY433644[20];
struct  Tident168021  {
  Tidobj168015 Sup;
NimStringDesc* s;
Tident168021* next;
NI h;
};
struct  Ropeobj162009  {
  TNimObject Sup;
Ropeobj162009* left;
Ropeobj162009* right;
NI length;
NimStringDesc* data;
};
typedef NI TY27420[16];
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  Tfreecell27430  {
Tfreecell27430* next;
NI zerofield;
};
struct Ttypeseq191845 {
  TGenericSeq Sup;
  Ttype191849* data[SEQ_DECL_SIZE];
};
struct Tsymseq191815 {
  TGenericSeq Sup;
  Tsym191843* data[SEQ_DECL_SIZE];
};
struct Tnodeseq191807 {
  TGenericSeq Sup;
  Tnode191813* data[SEQ_DECL_SIZE];
};
struct TY191933 {
  TGenericSeq Sup;
  NI32 data[SEQ_DECL_SIZE];
};
struct TY191944 {
  TGenericSeq Sup;
  Tinstantiation191833* data[SEQ_DECL_SIZE];
};
struct Tidpairseq191859 {
  TGenericSeq Sup;
  Tidpair191857 data[SEQ_DECL_SIZE];
};
struct Tnodepairseq191871 {
  TGenericSeq Sup;
  Tnodepair191869 data[SEQ_DECL_SIZE];
};
struct Tidnodepairseq191865 {
  TGenericSeq Sup;
  Tidnodepair191863 data[SEQ_DECL_SIZE];
};
N_NIMCALL(Tnode191813*, newnode_192401)(NU8 kind);
N_NIMCALL(void, nimGCvisit)(void* d, NI op);
N_NIMCALL(void, TMP740)(void* p, NI op);
N_NIMCALL(void, TMP748)(void* p, NI op);
N_NIMCALL(void, TMP749)(void* p, NI op);
N_NIMCALL(void, TMP750)(void* p, NI op);
N_NIMCALL(void, TMP753)(void* p, NI op);
N_NIMCALL(void, TMP754)(void* p, NI op);
N_NIMCALL(void, TMP755)(void* p, NI op);
N_NIMCALL(void, TMP782)(void* p, NI op);
N_NIMCALL(void, TMP783)(void* p, NI op);
N_NIMCALL(void, TMP784)(void* p, NI op);
N_NIMCALL(void, TMP791)(void* p, NI op);
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(Tsym191843*, newsym_192656)(NU8 symkind, Tident168021* name, Tsym191843* owner, Tlineinfo164338 info);
static N_INLINE(NI, getid_190404)(void);
N_NIMCALL(Tident168021*, getident_168463)(NimStringDesc* identifier);
N_NIMCALL(Tlineinfo164338, unknownlineinfo_165027)(void);
N_NIMCALL(void, addson_193819)(Tnode191813* father, Tnode191813* son);
static N_INLINE(void, nimGCunrefNoCycle)(void* p);
N_NIMCALL(void*, newSeqRC1)(TNimType* typ, NI len);
N_NIMCALL(TGenericSeq*, incrSeq)(TGenericSeq* seq, NI elemsize);
N_NIMCALL(Tsym191843*, createmagic_196986)(NimStringDesc* name, NU16 m);
N_NIMCALL(void, TMP832)(void* p, NI op);
N_NIMCALL(void*, newSeq)(TNimType* typ, NI len);
N_NIMCALL(void, unsureAsgnRef)(void** dest, void* src);
N_NIMCALL(Ttype191849*, lastson_194442)(Ttype191849* n);
N_NIMCALL(NI, sonslen_194351)(Ttype191849* n);
N_NIMCALL(void, propagatetoowner_195274)(Ttype191849* owner, Ttype191849* elem);
N_NIMCALL(NIM_BOOL, ismetatype_192821)(Ttype191849* t);
N_NIMCALL(Ttype191849*, skiptypes_195167)(Ttype191849* t, NU64 kinds);
static N_INLINE(NIM_BOOL, isgcedmem_195235)(Ttype191849* t);
N_NIMCALL(void, TMP1057)(void* p, NI op);
N_NIMCALL(Tnode191813*, newnodei_193351)(NU8 kind, Tlineinfo164338 info);
N_NIMCALL(void, genericSeqAssign)(void* dest, void* src_81404, TNimType* mt);
N_NIMCALL(NI, sonslen_194403)(Tnode191813* n);
N_NIMCALL(NimStringDesc*, copyStringRC1)(NimStringDesc* src);
N_NIMCALL(NimStringDesc*, copyString)(NimStringDesc* src);
N_NIMCALL(NimStringDesc*, nimIntToStr)(NI x);
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, mergeloc_194207)(Tloc191827* a, Tloc191827 b);
N_NIMCALL(void, newsons_194313)(Ttype191849* father, NI length);
N_NIMCALL(TGenericSeq*, setLengthSeq)(TGenericSeq* seq, NI elemsize, NI newlen);
N_NIMCALL(Ttype191849*, newtype_194140)(NU8 kind, Tsym191843* owner);
N_NIMCALL(void, assigntype_194452)(Ttype191849* dest, Ttype191849* src);
N_NIMCALL(void, copystrtable_193024)(Tstrtable191817* dest, Tstrtable191817 src);
N_NIMCALL(void, genericAssign)(void* dest, void* src, TNimType* mt);
N_NIMCALL(void, initstrtable_195007)(Tstrtable191817* x);
N_NIMCALL(Tnode191813*, copytree_196028)(Tnode191813* src);
N_NIMCALL(void, internalerror_166218)(NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, HEX24_166306)(TY86545 x);
N_NIMCALL(Tnode191813*, newintnode_192608)(NU8 kind, NI64 intval);
static N_INLINE(Tnode191813*, HEX5BHEX5D_192244)(Tnode191813* n, NI i);
N_NIMCALL(NI, len_194377)(Ttype191849* n);
N_NIMCALL(void, internalerror_166199)(Tlineinfo164338 info, NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, nimCharToStr)(NIM_CHAR x);
N_NIMCALL(void, TMP3256)(void* p, NI op);
N_NIMCALL(NIM_BOOL, containsnode_196365)(Tnode191813* n, TY433644 kinds);
N_NIMCALL(NIM_BOOL, hassubnodewith_196439)(Tnode191813* n, NU8 kind);
TNimNode* NimDT_191843_kind[27];
TNimNode* NimDT_191813_kind[160];
STRING_LITERAL(TMP792, "*", 1);
STRING_LITERAL(TMP793, "not", 3);
STRING_LITERAL(TMP794, "contains", 8);
STRING_LITERAL(TMP2070, "", 0);
STRING_LITERAL(TMP2071, "stdcall", 7);
STRING_LITERAL(TMP2072, "cdecl", 5);
STRING_LITERAL(TMP2073, "safecall", 8);
STRING_LITERAL(TMP2074, "syscall", 7);
STRING_LITERAL(TMP2075, "inline", 6);
STRING_LITERAL(TMP2076, "noinline", 8);
STRING_LITERAL(TMP2077, "fastcall", 8);
STRING_LITERAL(TMP2078, "closure", 7);
STRING_LITERAL(TMP2079, "noconv", 6);
NIM_CONST TY191020 Callingconvtostr_191019 = {((NimStringDesc*) &TMP2070),
((NimStringDesc*) &TMP2071),
((NimStringDesc*) &TMP2072),
((NimStringDesc*) &TMP2073),
((NimStringDesc*) &TMP2074),
((NimStringDesc*) &TMP2075),
((NimStringDesc*) &TMP2076),
((NimStringDesc*) &TMP2077),
((NimStringDesc*) &TMP2078),
((NimStringDesc*) &TMP2079)}
;
STRING_LITERAL(TMP2083, "<unspecified>", 13);
STRING_LITERAL(TMP2084, "<unknown>", 9);
STRING_LITERAL(TMP2675, "ast.nim", 7);
NIM_CONST TY86545 TMP2674 = {((NimStringDesc*) &TMP2675),
((NI) 1519)}
;
STRING_LITERAL(TMP3231, "getInt", 6);
STRING_LITERAL(TMP3232, "getFloat", 8);
STRING_LITERAL(TMP3233, "getStr", 6);
STRING_LITERAL(TMP3236, "getStrOrChar", 12);
NIM_BOOL ggdebug_192066;
Tnode191813* emptynode_192807;
TNimType NTI191813; /* TNode */
extern TNimType NTI168015; /* TIdObj */
TNimType NTI191849; /* TType */
TNimType NTI191260; /* TTypeKind */
TNimType NTI191005; /* TCallingConvention */
TNimType NTI191437; /* TTypeFlag */
TNimType NTI191439; /* TTypeFlags */
TNimType NTI191845; /* TTypeSeq */
TNimType NTI191843; /* TSym */
TNimType NTI191441; /* TSymKind */
TNimType NTI191837; /* TScope */
extern TNimType NTI108; /* int */
TNimType NTI191817; /* TStrTable */
TNimType NTI191815; /* TSymSeq */
TNimType NTI191807; /* TNodeSeq */
TNimType NTI191839; /* PScope */
TNimType NTI191833; /* TInstantiation */
extern TNimType NTI114; /* int32 */
TNimType NTI191933; /* seq[int32] */
TNimType NTI191835; /* PInstantiation */
TNimType NTI191944; /* seq[PInstantiation] */
TNimType NTI191529; /* TMagic */
extern TNimType NTI168019; /* PIdent */
extern TNimType NTI164338; /* TLineInfo */
TNimType NTI191195; /* TSymFlag */
TNimType NTI191197; /* TSymFlags */
extern TNimType NTI155016; /* TOptions */
TNimType NTI191827; /* TLoc */
TNimType NTI191819; /* TLocKind */
TNimType NTI191823; /* TStorageLoc */
TNimType NTI191821; /* TLocFlag */
TNimType NTI191825; /* TLocFlags */
extern TNimType NTI162007; /* Rope */
extern TNimType NTI130022; /* TListEntry */
TNimType NTI191831; /* TLib */
TNimType NTI191829; /* TLibKind */
extern TNimType NTI138; /* bool */
TNimType NTI191841; /* PLib */
TNimType NTI191811; /* PSym */
extern TNimType NTI5710; /* BiggestInt */
extern TNimType NTI112; /* int16 */
TNimType NTI191809; /* PType */
TNimType NTI191433; /* TNodeFlag */
TNimType NTI191435; /* TNodeFlags */
TNimType NTI191029; /* TNodeKind */
extern TNimType NTI5712; /* BiggestFloat */
extern TNimType NTI149; /* string */
TNimType NTI191805; /* PNode */
extern Tgcheap48216 gch_48244;
Tsym191843* anyglobal_192814;
extern NU32 goptions_155126;
extern NI gfrontendid_190012;
Tnode191813* emptyparams_194044;
Tsym191843* opnot_196998;
Tsym191843* opcontains_196999;
TNimType NTI191861; /* TIdTable */
TNimType NTI191857; /* TIdPair */
extern TNimType NTI168017; /* PIdObj */
extern TNimType NTI3413; /* RootRef */
TNimType NTI191859; /* TIdPairSeq */
TNimType NTI191873; /* TNodeTable */
TNimType NTI191869; /* TNodePair */
extern TNimType NTI131021; /* THash */
TNimType NTI191871; /* TNodePairSeq */
TNimType NTI385221; /* ptr PNode */
TNimType NTI191867; /* TIdNodeTable */
TNimType NTI191863; /* TIdNodePair */
TNimType NTI191865; /* TIdNodePairSeq */
N_NIMCALL(void, TMP740)(void* p, NI op) {
	Ttypeseq191845* a;
	NI LOC1;
	a = (Ttypeseq191845*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP748)(void* p, NI op) {
	Tsymseq191815* a;
	NI LOC1;
	a = (Tsymseq191815*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP749)(void* p, NI op) {
	Tnodeseq191807* a;
	NI LOC1;
	a = (Tnodeseq191807*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP750)(void* p, NI op) {
	Tscope191837* a;
	a = (Tscope191837*)p;
	nimGCvisit((void*)(*a).symbols.data, op);
	nimGCvisit((void*)(*a).usingsyms, op);
	nimGCvisit((void*)(*a).parent, op);
}
N_NIMCALL(void, TMP753)(void* p, NI op) {
	TY191933* a;
	NI LOC1;
	a = (TY191933*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	}
}
N_NIMCALL(void, TMP754)(void* p, NI op) {
	Tinstantiation191833* a;
	a = (Tinstantiation191833*)p;
	nimGCvisit((void*)(*a).sym, op);
	nimGCvisit((void*)(*a).concretetypes, op);
	nimGCvisit((void*)(*a).usedby, op);
}
N_NIMCALL(void, TMP755)(void* p, NI op) {
	TY191944* a;
	NI LOC1;
	a = (TY191944*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP782)(void* p, NI op) {
	Tlib191831* a;
	a = (Tlib191831*)p;
	nimGCvisit((void*)(*a).Sup.prev, op);
	nimGCvisit((void*)(*a).Sup.next, op);
	nimGCvisit((void*)(*a).name, op);
	nimGCvisit((void*)(*a).path, op);
}
N_NIMCALL(void, TMP783)(void* p, NI op) {
	Tsym191843* a;
	a = (Tsym191843*)p;
	switch ((*a).kind) {
	case ((NU8) 7):
	case ((NU8) 4):
	nimGCvisit((void*)(*a).kindU.S1.typeinstcache, op);
	nimGCvisit((void*)(*a).kindU.S1.typscope, op);
	break;
	case ((NU8) 12):
	case ((NU8) 13):
	case ((NU8) 14):
	case ((NU8) 15):
	case ((NU8) 16):
	case ((NU8) 17):
	case ((NU8) 18):
	nimGCvisit((void*)(*a).kindU.S2.procinstcache, op);
	nimGCvisit((void*)(*a).kindU.S2.gcunsafetyreason, op);
	break;
	case ((NU8) 6):
	nimGCvisit((void*)(*a).kindU.S3.usedgenerics, op);
	nimGCvisit((void*)(*a).kindU.S3.tab.data, op);
	break;
	case ((NU8) 9):
	case ((NU8) 8):
	case ((NU8) 19):
	case ((NU8) 21):
	nimGCvisit((void*)(*a).kindU.S4.guard, op);
	break;
	default:
	break;
	} 
	nimGCvisit((void*)(*a).typ, op);
	nimGCvisit((void*)(*a).name, op);
	nimGCvisit((void*)(*a).owner, op);
	nimGCvisit((void*)(*a).ast, op);
	nimGCvisit((void*)(*a).loc.t, op);
	nimGCvisit((void*)(*a).loc.r, op);
	nimGCvisit((void*)(*a).loc.heaproot, op);
	nimGCvisit((void*)(*a).annex, op);
	nimGCvisit((void*)(*a).constraint, op);
}
N_NIMCALL(void, TMP784)(void* p, NI op) {
	Ttype191849* a;
	a = (Ttype191849*)p;
	nimGCvisit((void*)(*a).sons, op);
	nimGCvisit((void*)(*a).n, op);
	nimGCvisit((void*)(*a).owner, op);
	nimGCvisit((void*)(*a).sym, op);
	nimGCvisit((void*)(*a).destructor, op);
	nimGCvisit((void*)(*a).deepcopy, op);
	nimGCvisit((void*)(*a).assignment, op);
	nimGCvisit((void*)(*a).loc.t, op);
	nimGCvisit((void*)(*a).loc.r, op);
	nimGCvisit((void*)(*a).loc.heaproot, op);
}
N_NIMCALL(void, TMP791)(void* p, NI op) {
	Tnode191813* a;
	a = (Tnode191813*)p;
	nimGCvisit((void*)(*a).typ, op);
	switch ((*a).kind) {
	case ((NU8) 5) ... ((NU8) 15):
	break;
	case ((NU8) 16) ... ((NU8) 19):
	break;
	case ((NU8) 20) ... ((NU8) 22):
	nimGCvisit((void*)(*a).kindU.S3.strval, op);
	break;
	case ((NU8) 3):
	nimGCvisit((void*)(*a).kindU.S4.sym, op);
	break;
	case ((NU8) 2):
	nimGCvisit((void*)(*a).kindU.S5.ident, op);
	break;
	default:
	nimGCvisit((void*)(*a).kindU.S6.sons, op);
	break;
	} 
	nimGCvisit((void*)(*a).comment, op);
}

N_NIMCALL(Tnode191813*, newnode_192401)(NU8 kind) {
	Tnode191813* result;
	result = 0;
	result = (Tnode191813*) newObj((&NTI191805), sizeof(Tnode191813));
	(*result).kind = kind;
	(*result).info.fileindex = ((NI32) -1);
	(*result).info.col = ((NI16) -1);
	(*result).info.line = ((NI16) -1);
	return result;
}

static N_INLINE(Tcell46346*, usrtocell_49846)(void* usr) {
	Tcell46346* result;
	result = 0;
	result = ((Tcell46346*) ((NI)((NU32)(((NI) (usr))) - (NU32)(((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 (!((NU32)((*c).refcount) < (NU32)(((NI) 8)))) goto LA11;
			rtladdzct_51404(c);
		}
		LA11: ;
	}
	LA7: ;
	(*dest) = src;
}

static N_INLINE(NI, getid_190404)(void) {
	NI result;
	result = 0;
	result = gfrontendid_190012;
	gfrontendid_190012 += ((NI) 1);
	return result;
}

N_NIMCALL(Tsym191843*, newsym_192656)(NU8 symkind, Tident168021* name, Tsym191843* owner, Tlineinfo164338 info) {
	Tsym191843* result;
	result = 0;
	result = (Tsym191843*) newObj((&NTI191811), sizeof(Tsym191843));
	(*result).Sup.Sup.m_type = (&NTI191843);
	asgnRefNoCycle((void**) (&(*result).name), name);
	(*result).kind = symkind;
	(*result).flags = 0;
	(*result).info = info;
	(*result).options = goptions_155126;
	asgnRefNoCycle((void**) (&(*result).owner), owner);
	(*result).offset = ((NI) -1);
	(*result).Sup.id = getid_190404();
	return result;
}

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

N_NIMCALL(void, addson_193819)(Tnode191813* father, Tnode191813* son) {
	{
		if (!(*father).kindU.S6.sons == 0) goto LA3;
		if ((*father).kindU.S6.sons) nimGCunrefNoCycle((*father).kindU.S6.sons);
		(*father).kindU.S6.sons = (Tnodeseq191807*) newSeqRC1((&NTI191807), 0);
	}
	LA3: ;
	(*father).kindU.S6.sons = (Tnodeseq191807*) incrSeq(&((*father).kindU.S6.sons)->Sup, sizeof(Tnode191813*));
	asgnRefNoCycle((void**) (&(*father).kindU.S6.sons->data[(*father).kindU.S6.sons->Sup.len-1]), son);
}

N_NIMCALL(Tsym191843*, createmagic_196986)(NimStringDesc* name, NU16 m) {
	Tsym191843* result;
	Tident168021* LOC1;
	Tlineinfo164338 LOC2;
	result = 0;
	LOC1 = 0;
	LOC1 = getident_168463(name);
	LOC2 = unknownlineinfo_165027();
	result = newsym_192656(((NU8) 12), LOC1, NIM_NIL, LOC2);
	(*result).magic = m;
	return result;
}
N_NIMCALL(void, TMP832)(void* p, NI op) {
	Tidpairseq191859* a;
	NI LOC1;
	a = (Tidpairseq191859*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1].key, op);
	nimGCvisit((void*)a->data[LOC1].val, op);
	}
}

N_NIMCALL(void, initidtable_195057)(Tidtable191861* x) {
	(*x).counter = ((NI) 0);
	unsureAsgnRef((void**) (&(*x).data), (Tidpairseq191859*) newSeq((&NTI191859), ((NI) 8)));
}

N_NIMCALL(void, initstrtable_195007)(Tstrtable191817* x) {
	(*x).counter = ((NI) 0);
	unsureAsgnRef((void**) (&(*x).data), (Tsymseq191815*) newSeq((&NTI191815), ((NI) 8)));
}

N_NIMCALL(Ttype191849*, newtype_194140)(NU8 kind, Tsym191843* owner) {
	Ttype191849* result;
	result = 0;
	result = (Ttype191849*) newObj((&NTI191809), sizeof(Ttype191849));
	(*result).Sup.Sup.m_type = (&NTI191849);
	(*result).kind = kind;
	asgnRefNoCycle((void**) (&(*result).owner), owner);
	(*result).size = IL64(-1);
	(*result).align = ((NI16) 2);
	(*result).Sup.id = getid_190404();
	(*result).locklevel = ((NI16) -1);
	return result;
}

N_NIMCALL(Tnode191813*, newnodeit_193807)(NU8 kind, Tlineinfo164338 info, Ttype191849* typ) {
	Tnode191813* result;
	result = 0;
	result = newnode_192401(kind);
	(*result).info = info;
	asgnRefNoCycle((void**) (&(*result).typ), typ);
	return result;
}

N_NIMCALL(Tnode191813*, newnodei_193351)(NU8 kind, Tlineinfo164338 info) {
	Tnode191813* result;
	result = 0;
	result = (Tnode191813*) newObj((&NTI191805), sizeof(Tnode191813));
	(*result).kind = kind;
	(*result).info = info;
	return result;
}

N_NIMCALL(NI, sonslen_194351)(Ttype191849* n) {
	NI result;
	result = 0;
	{
		if (!(*n).sons == 0) goto LA3;
		result = ((NI) 0);
	}
	goto LA1;
	LA3: ;
	{
		result = ((*n).sons ? (*n).sons->Sup.len : 0);
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, lastson_194442)(Ttype191849* n) {
	Ttype191849* result;
	NI LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = sonslen_194351(n);
	result = (*n).sons->data[(NI)(LOC1 - ((NI) 1))];
	return result;
}

N_NIMCALL(Ttype191849*, skiptypes_195167)(Ttype191849* t, NU64 kinds) {
	Ttype191849* result;
	result = 0;
	result = t;
	{
		while (1) {
			if (!((kinds &(IL64(1)<<(((*result).kind)&IL64(63))))!=0)) goto LA2;
			result = lastson_194442(result);
		} LA2: ;
	}
	return result;
}

N_NIMCALL(Tnode191813*, newsymnode_193325)(Tsym191843* sym) {
	Tnode191813* result;
	result = 0;
	result = newnode_192401(((NU8) 3));
	asgnRefNoCycle((void**) (&(*result).kindU.S4.sym), sym);
	asgnRefNoCycle((void**) (&(*result).typ), (*sym).typ);
	(*result).info = (*sym).info;
	return result;
}

N_NIMCALL(void, addsonnilallowed_195530)(Tnode191813* father, Tnode191813* son) {
	{
		if (!(*father).kindU.S6.sons == 0) goto LA3;
		if ((*father).kindU.S6.sons) nimGCunrefNoCycle((*father).kindU.S6.sons);
		(*father).kindU.S6.sons = (Tnodeseq191807*) newSeqRC1((&NTI191807), 0);
	}
	LA3: ;
	(*father).kindU.S6.sons = (Tnodeseq191807*) incrSeq(&((*father).kindU.S6.sons)->Sup, sizeof(Tnode191813*));
	asgnRefNoCycle((void**) (&(*father).kindU.S6.sons->data[(*father).kindU.S6.sons->Sup.len-1]), son);
}

N_NIMCALL(NIM_BOOL, ismetatype_192821)(Ttype191849* t) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	NIM_BOOL LOC2;
	NIM_BOOL LOC4;
{	result = 0;
	LOC1 = 0;
	LOC2 = 0;
	LOC2 = ((*t).kind == ((NU8) 6) || (*t).kind == ((NU8) 8) || (*t).kind == ((NU8) 12) || (*t).kind >= ((NU8) 51) && (*t).kind <= ((NU8) 58));
	if (LOC2) goto LA3;
	LOC4 = 0;
	LOC4 = ((*t).kind == ((NU8) 59));
	if (!(LOC4)) goto LA5;
	LOC4 = ((*t).n == NIM_NIL);
	LA5: ;
	LOC2 = LOC4;
	LA3: ;
	LOC1 = LOC2;
	if (LOC1) goto LA6;
	LOC1 = (((*t).flags &(1<<((((NU8) 19))&31)))!=0);
	LA6: ;
	result = LOC1;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

static N_INLINE(NIM_BOOL, isgcedmem_195235)(Ttype191849* t) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	NIM_BOOL LOC3;
	result = 0;
	LOC1 = 0;
	LOC1 = ((*t).kind == ((NU8) 28) || (*t).kind == ((NU8) 22) || (*t).kind == ((NU8) 24));
	if (LOC1) goto LA2;
	LOC3 = 0;
	LOC3 = ((*t).kind == ((NU8) 25));
	if (!(LOC3)) goto LA4;
	LOC3 = ((*t).callconv == ((NU8) 8));
	LA4: ;
	LOC1 = LOC3;
	LA2: ;
	result = LOC1;
	return result;
}

N_NIMCALL(void, propagatetoowner_195274)(Ttype191849* owner, Ttype191849* elem) {
	(*owner).flags = ((*owner).flags | ((*elem).flags & 524288));
	{
		if (!(((*elem).flags &(1<<((((NU8) 16))&31)))!=0)) goto LA3;
		{
			if (!((*owner).kind == ((NU8) 11) || (*owner).kind == ((NU8) 10) || (*owner).kind == ((NU8) 9))) goto LA7;
			(*owner).flags |= ((NI32)1)<<((((NU8) 16))%(sizeof(NI32)*8));
		}
		goto LA5;
		LA7: ;
		{
			if (!!(((*owner).kind == ((NU8) 24) || (*owner).kind == ((NU8) 19) || (*owner).kind == ((NU8) 21) || (*owner).kind == ((NU8) 22) || (*owner).kind == ((NU8) 25)))) goto LA10;
			(*owner).flags |= ((NI32)1)<<((((NU8) 17))%(sizeof(NI32)*8));
		}
		goto LA5;
		LA10: ;
		LA5: ;
	}
	LA3: ;
	{
		if (!(((*elem).flags &(1<<((((NU8) 17))&31)))!=0)) goto LA14;
		{
			if (!((*owner).kind == ((NU8) 24) || (*owner).kind == ((NU8) 19) || (*owner).kind == ((NU8) 21) || (*owner).kind == ((NU8) 22) || (*owner).kind == ((NU8) 25))) goto LA18;
		}
		goto LA16;
		LA18: ;
		{
			(*owner).flags |= ((NI32)1)<<((((NU8) 17))%(sizeof(NI32)*8));
		}
		LA16: ;
	}
	LA14: ;
	{
		NIM_BOOL LOC23;
		LOC23 = 0;
		LOC23 = ismetatype_192821(elem);
		if (!LOC23) goto LA24;
		(*owner).flags |= ((NI32)1)<<((((NU8) 19))%(sizeof(NI32)*8));
	}
	LA24: ;
	{
		Ttype191849* o2;
		if (!(((*elem).flags &(1<<((((NU8) 26))&31)))!=0)) goto LA28;
		o2 = skiptypes_195167(elem, 2048);
		{
			if (!((*o2).kind == ((NU8) 18) || (*o2).kind == ((NU8) 17) || (*o2).kind == ((NU8) 16) || (*o2).kind == ((NU8) 4) || (*o2).kind == ((NU8) 24) || (*o2).kind == ((NU8) 19) || (*o2).kind == ((NU8) 13))) goto LA32;
			(*o2).flags |= ((NI32)1)<<((((NU8) 26))%(sizeof(NI32)*8));
			(*owner).flags |= ((NI32)1)<<((((NU8) 26))%(sizeof(NI32)*8));
		}
		LA32: ;
	}
	LA28: ;
	{
		Ttype191849* elemb;
		if (!!(((*owner).kind == ((NU8) 25) || (*owner).kind == ((NU8) 11) || (*owner).kind == ((NU8) 10) || (*owner).kind == ((NU8) 9)))) goto LA36;
		elemb = skiptypes_195167(elem, 2048);
		{
			NIM_BOOL LOC40;
			LOC40 = 0;
			LOC40 = isgcedmem_195235(elemb);
			if (LOC40) goto LA41;
			LOC40 = (((*elemb).flags &(1<<((((NU8) 20))&31)))!=0);
			LA41: ;
			if (!LOC40) goto LA42;
			(*owner).flags |= ((NI32)1)<<((((NU8) 20))%(sizeof(NI32)*8));
		}
		LA42: ;
	}
	LA36: ;
}

N_NIMCALL(void, rawaddson_195478)(Ttype191849* father, Ttype191849* son) {
	{
		if (!(*father).sons == 0) goto LA3;
		if ((*father).sons) nimGCunrefNoCycle((*father).sons);
		(*father).sons = (Ttypeseq191845*) newSeqRC1((&NTI191845), 0);
	}
	LA3: ;
	(*father).sons = (Ttypeseq191845*) incrSeq(&((*father).sons)->Sup, sizeof(Ttype191849*));
	asgnRefNoCycle((void**) (&(*father).sons->data[(*father).sons->Sup.len-1]), son);
	{
		if (!!(son == 0)) goto LA7;
		propagatetoowner_195274(father, son);
	}
	LA7: ;
}

N_NIMCALL(Tnode191813*, newsymnode_193338)(Tsym191843* sym, Tlineinfo164338 info) {
	Tnode191813* result;
	result = 0;
	result = newnode_192401(((NU8) 3));
	asgnRefNoCycle((void**) (&(*result).kindU.S4.sym), sym);
	asgnRefNoCycle((void**) (&(*result).typ), (*sym).typ);
	(*result).info = info;
	return result;
}

N_NIMCALL(void, add_192164)(Tnode191813* father, Tnode191813* son) {
	{
		if (!(*father).kindU.S6.sons == 0) goto LA3;
		if ((*father).kindU.S6.sons) nimGCunrefNoCycle((*father).kindU.S6.sons);
		(*father).kindU.S6.sons = (Tnodeseq191807*) newSeqRC1((&NTI191807), 0);
	}
	LA3: ;
	(*father).kindU.S6.sons = (Tnodeseq191807*) incrSeq(&((*father).kindU.S6.sons)->Sup, sizeof(Tnode191813*));
	asgnRefNoCycle((void**) (&(*father).kindU.S6.sons->data[(*father).kindU.S6.sons->Sup.len-1]), son);
}

N_NIMCALL(Tnode191813*, newidentnode_193313)(Tident168021* ident, Tlineinfo164338 info) {
	Tnode191813* result;
	result = 0;
	result = newnode_192401(((NU8) 2));
	asgnRefNoCycle((void**) (&(*result).kindU.S5.ident), ident);
	(*result).info = info;
	return result;
}
N_NIMCALL(void, TMP1057)(void* p, NI op) {
	Tnodepairseq191871* a;
	NI LOC1;
	a = (Tnodepairseq191871*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1].key, op);
	}
}

N_NIMCALL(Tnode191813*, newprocnode_194058)(NU8 kind, Tlineinfo164338 info, Tnode191813* body, Tnode191813* params, Tnode191813* name, Tnode191813* pattern, Tnode191813* genericparams, Tnode191813* pragmas, Tnode191813* exceptions) {
	Tnode191813* result;
	TY194071 LOC1;
	result = 0;
	result = newnodei_193351(kind, info);
	if ((*result).kindU.S6.sons) nimGCunrefNoCycle((*result).kindU.S6.sons);
	(*result).kindU.S6.sons = (Tnodeseq191807*) newSeqRC1((&NTI191807), 7);
	memset((void*)LOC1, 0, sizeof(LOC1));
	LOC1[0] = name;
	LOC1[1] = pattern;
	LOC1[2] = genericparams;
	LOC1[3] = params;
	LOC1[4] = pragmas;
	LOC1[5] = exceptions;
	LOC1[6] = body;
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[0]), LOC1[0]);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[1]), LOC1[1]);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[2]), LOC1[2]);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[3]), LOC1[3]);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[4]), LOC1[4]);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[5]), LOC1[5]);
	asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[6]), LOC1[6]);
	return result;
}

N_NIMCALL(NI, sonslen_194403)(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(Tnode191813*, newnode_193607)(NU8 kind, Tlineinfo164338 info, Tnodeseq191807* sons, Ttype191849* typ) {
	Tnode191813* result;
	result = 0;
	result = (Tnode191813*) newObj((&NTI191805), sizeof(Tnode191813));
	(*result).kind = kind;
	(*result).info = info;
	asgnRefNoCycle((void**) (&(*result).typ), typ);
	genericSeqAssign((&(*result).kindU.S6.sons), sons, (&NTI191807));
	return result;
}

N_NIMCALL(Tnode191813*, newnodei_193407)(NU8 kind, Tlineinfo164338 info, NI children) {
	Tnode191813* result;
	result = 0;
	result = (Tnode191813*) newObj((&NTI191805), sizeof(Tnode191813));
	(*result).kind = kind;
	(*result).info = info;
	{
		if (!(((NI) 0) < children)) goto LA3;
		if ((*result).kindU.S6.sons) nimGCunrefNoCycle((*result).kindU.S6.sons);
		(*result).kindU.S6.sons = (Tnodeseq191807*) newSeqRC1((&NTI191807), ((NI) (children)));
	}
	LA3: ;
	return result;
}

N_NIMCALL(Tnode191813*, lastson_194431)(Tnode191813* n) {
	Tnode191813* result;
	NI LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = sonslen_194403(n);
	result = (*n).kindU.S6.sons->data[(NI)(LOC1 - ((NI) 1))];
	return result;
}

N_NIMCALL(Tnode191813*, newstrnode_192644)(NU8 kind, NimStringDesc* strval) {
	Tnode191813* result;
	NimStringDesc* LOC1;
	result = 0;
	result = newnode_192401(kind);
	LOC1 = 0;
	LOC1 = (*result).kindU.S3.strval; (*result).kindU.S3.strval = copyStringRC1(strval);
	if (LOC1) nimGCunrefNoCycle(LOC1);
	return result;
}

N_NIMCALL(NI, len_194377)(Ttype191849* n) {
	NI result;
	result = 0;
	{
		if (!(*n).sons == 0) goto LA3;
		result = ((NI) 0);
	}
	goto LA1;
	LA3: ;
	{
		result = ((*n).sons ? (*n).sons->Sup.len : 0);
	}
	LA1: ;
	return result;
}

N_NIMCALL(NimStringDesc*, HEX24_194096)(NI16 x) {
	NimStringDesc* result;
	result = 0;
	{
		if (!(((NI) (x)) == ((NI) -1))) goto LA3;
		result = copyString(((NimStringDesc*) &TMP2083));
	}
	goto LA1;
	LA3: ;
	{
		if (!(((NI) (x)) == ((NI) 1001))) goto LA6;
		result = copyString(((NimStringDesc*) &TMP2084));
	}
	goto LA1;
	LA6: ;
	{
		result = nimIntToStr(((NI) (x)));
	}
	LA1: ;
	return result;
}

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)((NU32)((*c).refcount) + (NU32)(((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 (!((NU32)((*c).refcount) < (NU32)(((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;
}

N_NIMCALL(void, mergeloc_194207)(Tloc191827* a, Tloc191827 b) {
	{
		if (!((*a).k == ((NU8) 0))) goto LA3;
		(*a).k = b.k;
	}
	LA3: ;
	{
		if (!((*a).s == ((NU8) 0))) goto LA7;
		(*a).s = b.s;
	}
	LA7: ;
	(*a).flags = ((*a).flags | b.flags);
	{
		if (!((*a).t == NIM_NIL)) goto LA11;
		unsureAsgnRef((void**) (&(*a).t), b.t);
	}
	LA11: ;
	{
		if (!((*a).r == NIM_NIL)) goto LA15;
		unsureAsgnRef((void**) (&(*a).r), b.r);
	}
	LA15: ;
}

N_NIMCALL(void, newsons_194313)(Ttype191849* father, NI length) {
	{
		if (!(*father).sons == 0) goto LA3;
		if ((*father).sons) nimGCunrefNoCycle((*father).sons);
		(*father).sons = (Ttypeseq191845*) newSeqRC1((&NTI191845), ((NI) (length)));
	}
	goto LA1;
	LA3: ;
	{
		(*father).sons = (Ttypeseq191845*) setLengthSeq(&((*father).sons)->Sup, sizeof(Ttype191849*), ((NI) (length)));
	}
	LA1: ;
}

N_NIMCALL(void, assigntype_194452)(Ttype191849* dest, Ttype191849* src) {
	NI LOC14;
	(*dest).kind = (*src).kind;
	(*dest).flags = (*src).flags;
	(*dest).callconv = (*src).callconv;
	asgnRefNoCycle((void**) (&(*dest).n), (*src).n);
	(*dest).size = (*src).size;
	(*dest).align = (*src).align;
	asgnRefNoCycle((void**) (&(*dest).destructor), (*src).destructor);
	asgnRefNoCycle((void**) (&(*dest).deepcopy), (*src).deepcopy);
	asgnRefNoCycle((void**) (&(*dest).assignment), (*src).assignment);
	(*dest).locklevel = (*src).locklevel;
	{
		if (!!(((*src).sym == NIM_NIL))) goto LA3;
		{
			if (!!(((*dest).sym == NIM_NIL))) goto LA7;
			(*(*dest).sym).flags = ((*(*dest).sym).flags | (*(*src).sym).flags);
			{
				if (!((*(*dest).sym).annex == NIM_NIL)) goto LA11;
				asgnRef((void**) (&(*(*dest).sym).annex), (*(*src).sym).annex);
			}
			LA11: ;
			mergeloc_194207((&(*(*dest).sym).loc), (*(*src).sym).loc);
		}
		goto LA5;
		LA7: ;
		{
			asgnRefNoCycle((void**) (&(*dest).sym), (*src).sym);
		}
		LA5: ;
	}
	LA3: ;
	LOC14 = 0;
	LOC14 = sonslen_194351(src);
	newsons_194313(dest, LOC14);
	{
		NI i_194525;
		NI HEX3Atmp_194527;
		NI LOC16;
		NI res_194530;
		i_194525 = 0;
		HEX3Atmp_194527 = 0;
		LOC16 = 0;
		LOC16 = sonslen_194351(src);
		HEX3Atmp_194527 = (NI)(LOC16 - ((NI) 1));
		res_194530 = ((NI) 0);
		{
			while (1) {
				if (!(res_194530 <= HEX3Atmp_194527)) goto LA18;
				i_194525 = res_194530;
				asgnRefNoCycle((void**) (&(*dest).sons->data[i_194525]), (*src).sons->data[i_194525]);
				res_194530 += ((NI) 1);
			} LA18: ;
		}
	}
}

N_NIMCALL(void, copyidtable_193091)(Tidtable191861* dest, Tidtable191861 src) {
{	(*dest).counter = src.counter;
	{
		if (!src.data == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	unsureAsgnRef((void**) (&(*dest).data), (Tidpairseq191859*) newSeq((&NTI191859), ((NI) ((src.data ? src.data->Sup.len : 0)))));
	{
		NI i_193134;
		NI HEX3Atmp_193136;
		NI res_193139;
		i_193134 = 0;
		HEX3Atmp_193136 = 0;
		HEX3Atmp_193136 = (src.data ? (src.data->Sup.len-1) : -1);
		res_193139 = ((NI) 0);
		{
			while (1) {
				if (!(res_193139 <= HEX3Atmp_193136)) goto LA7;
				i_193134 = res_193139;
				asgnRef((void**) (&(*dest).data->data[i_193134].key), src.data->data[i_193134].key);
				asgnRef((void**) (&(*dest).data->data[i_193134].val), src.data->data[i_193134].val);
				res_193139 += ((NI) 1);
			} LA7: ;
		}
	}
	}BeforeRet: ;
}

N_NIMCALL(Tnode191813*, copynode_195640)(Tnode191813* src) {
	Tnode191813* result;
{	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_192401((*src).kind);
	(*result).info = (*src).info;
	asgnRefNoCycle((void**) (&(*result).typ), (*src).typ);
	(*result).flags = ((*src).flags & 13070);
	switch ((*src).kind) {
	case ((NU8) 5) ... ((NU8) 15):
	{
		(*result).kindU.S1.intval = (*src).kindU.S1.intval;
	}
	break;
	case ((NU8) 16) ... ((NU8) 19):
	{
		(*result).kindU.S2.floatval = (*src).kindU.S2.floatval;
	}
	break;
	case ((NU8) 3):
	{
		asgnRefNoCycle((void**) (&(*result).kindU.S4.sym), (*src).kindU.S4.sym);
	}
	break;
	case ((NU8) 2):
	{
		asgnRefNoCycle((void**) (&(*result).kindU.S5.ident), (*src).kindU.S5.ident);
	}
	break;
	case ((NU8) 20) ... ((NU8) 22):
	{
		NimStringDesc* LOC10;
		LOC10 = 0;
		LOC10 = (*result).kindU.S3.strval; (*result).kindU.S3.strval = copyStringRC1((*src).kindU.S3.strval);
		if (LOC10) nimGCunrefNoCycle(LOC10);
	}
	break;
	default:
	{
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, copytype_194549)(Ttype191849* t, Tsym191843* owner, NIM_BOOL keepid) {
	Ttype191849* result;
	result = 0;
	result = newtype_194140((*t).kind, owner);
	assigntype_194452(result, t);
	{
		if (!keepid) goto LA3;
		(*result).Sup.id = (*t).Sup.id;
	}
	goto LA1;
	LA3: ;
	{
	}
	LA1: ;
	asgnRefNoCycle((void**) (&(*result).sym), (*t).sym);
	return result;
}

N_NIMCALL(void, copystrtable_193024)(Tstrtable191817* dest, Tstrtable191817 src) {
{	(*dest).counter = src.counter;
	{
		if (!src.data == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	(*dest).data = (Tsymseq191815*) setLengthSeq(&((*dest).data)->Sup, sizeof(Tsym191843*), ((NI) ((src.data ? src.data->Sup.len : 0))));
	{
		NI i_193067;
		NI HEX3Atmp_193069;
		NI res_193072;
		i_193067 = 0;
		HEX3Atmp_193069 = 0;
		HEX3Atmp_193069 = (src.data ? (src.data->Sup.len-1) : -1);
		res_193072 = ((NI) 0);
		{
			while (1) {
				if (!(res_193072 <= HEX3Atmp_193069)) goto LA7;
				i_193067 = res_193072;
				asgnRefNoCycle((void**) (&(*dest).data->data[i_193067]), src.data->data[i_193067]);
				res_193072 += ((NI) 1);
			} LA7: ;
		}
	}
	}BeforeRet: ;
}

N_NIMCALL(Tsym191843*, copysym_194607)(Tsym191843* s, NIM_BOOL keepid) {
	Tsym191843* result;
	result = 0;
	result = newsym_192656((*s).kind, (*s).name, (*s).owner, (*s).info);
	asgnRefNoCycle((void**) (&(*result).typ), (*s).typ);
	{
		if (!keepid) goto LA3;
		(*result).Sup.id = (*s).Sup.id;
	}
	goto LA1;
	LA3: ;
	{
		(*result).Sup.id = getid_190404();
	}
	LA1: ;
	(*result).flags = (*s).flags;
	(*result).magic = (*s).magic;
	{
		if (!((*s).kind == ((NU8) 6))) goto LA8;
		copystrtable_193024((&(*result).kindU.S3.tab), (*s).kindU.S3.tab);
	}
	LA8: ;
	(*result).options = (*s).options;
	(*result).position = (*s).position;
	genericAssign((void*)(&(*result).loc), (void*)(&(*s).loc), (&NTI191827));
	asgnRef((void**) (&(*result).annex), (*s).annex);
	{
		if (!((525056 &(1<<(((*result).kind)&31)))!=0)) goto LA12;
		asgnRefNoCycle((void**) (&(*result).kindU.S4.guard), (*s).kindU.S4.guard);
	}
	LA12: ;
	return result;
}

N_NIMCALL(void, newsons_194272)(Tnode191813* father, NI length) {
	{
		if (!(*father).kindU.S6.sons == 0) goto LA3;
		if ((*father).kindU.S6.sons) nimGCunrefNoCycle((*father).kindU.S6.sons);
		(*father).kindU.S6.sons = (Tnodeseq191807*) newSeqRC1((&NTI191807), ((NI) (length)));
	}
	goto LA1;
	LA3: ;
	{
		(*father).kindU.S6.sons = (Tnodeseq191807*) setLengthSeq(&((*father).kindU.S6.sons)->Sup, sizeof(Tnode191813*), ((NI) (length)));
	}
	LA1: ;
}

N_NIMCALL(Tnode191813*, newintnode_192608)(NU8 kind, NI64 intval) {
	Tnode191813* result;
	result = 0;
	result = newnode_192401(kind);
	(*result).kindU.S1.intval = intval;
	return result;
}

N_NIMCALL(void, newstrtable_195027)(Tstrtable191817* Result) {
	initstrtable_195007(Result);
}

N_NIMCALL(Tnode191813*, copytree_196028)(Tnode191813* src) {
	Tnode191813* result;
{	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_192401((*src).kind);
	(*result).info = (*src).info;
	asgnRefNoCycle((void**) (&(*result).typ), (*src).typ);
	(*result).flags = ((*src).flags & 13070);
	switch ((*src).kind) {
	case ((NU8) 5) ... ((NU8) 15):
	{
		(*result).kindU.S1.intval = (*src).kindU.S1.intval;
	}
	break;
	case ((NU8) 16) ... ((NU8) 19):
	{
		(*result).kindU.S2.floatval = (*src).kindU.S2.floatval;
	}
	break;
	case ((NU8) 3):
	{
		asgnRefNoCycle((void**) (&(*result).kindU.S4.sym), (*src).kindU.S4.sym);
	}
	break;
	case ((NU8) 2):
	{
		asgnRefNoCycle((void**) (&(*result).kindU.S5.ident), (*src).kindU.S5.ident);
	}
	break;
	case ((NU8) 20) ... ((NU8) 22):
	{
		NimStringDesc* LOC10;
		LOC10 = 0;
		LOC10 = (*result).kindU.S3.strval; (*result).kindU.S3.strval = copyStringRC1((*src).kindU.S3.strval);
		if (LOC10) nimGCunrefNoCycle(LOC10);
	}
	break;
	default:
	{
		NI LOC12;
		LOC12 = 0;
		LOC12 = sonslen_194403(src);
		if ((*result).kindU.S6.sons) nimGCunrefNoCycle((*result).kindU.S6.sons);
		(*result).kindU.S6.sons = (Tnodeseq191807*) newSeqRC1((&NTI191807), ((NI) (LOC12)));
		{
			NI i_196234;
			NI HEX3Atmp_196238;
			NI LOC14;
			NI res_196241;
			i_196234 = 0;
			HEX3Atmp_196238 = 0;
			LOC14 = 0;
			LOC14 = sonslen_194403(src);
			HEX3Atmp_196238 = (NI)(LOC14 - ((NI) 1));
			res_196241 = ((NI) 0);
			{
				while (1) {
					if (!(res_196241 <= HEX3Atmp_196238)) goto LA16;
					i_196234 = res_196241;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_196234]), copytree_196028((*src).kindU.S6.sons->data[i_196234]));
					res_196241 += ((NI) 1);
				} LA16: ;
			}
		}
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tsym191843*, originatingmodule_196736)(Tsym191843* s) {
	Tsym191843* result;
	result = 0;
	result = (*s).owner;
	{
		while (1) {
			if (!!(((*result).kind == ((NU8) 6)))) goto LA2;
			result = (*result).owner;
		} LA2: ;
	}
	return result;
}

N_NIMCALL(Tsym191843*, skipgenericowner_196695)(Tsym191843* s) {
	Tsym191843* result;
	result = 0;
	{
		NimStringDesc* LOC5;
		if (!!(((520192 &(1<<(((*s).kind)&31)))!=0))) goto LA3;
		LOC5 = 0;
		LOC5 = HEX24_166306(TMP2674);
		internalerror_166218(LOC5);
	}
	LA3: ;
	{
		if (!(((*s).flags &(1<<((((NU8) 2))&31)))!=0)) goto LA8;
		result = (*(*s).owner).owner;
	}
	goto LA6;
	LA8: ;
	{
		result = (*s).owner;
	}
	LA6: ;
	return result;
}

N_NIMCALL(Tnode191813*, newinttypenode_192620)(NU8 kind, NI64 intval, Ttype191849* typ) {
	Tnode191813* result;
	result = 0;
	result = newintnode_192608(kind, intval);
	asgnRefNoCycle((void**) (&(*result).typ), typ);
	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;
}

N_NIMCALL(NIM_BOOL, isgenericroutine_196651)(Tsym191843* s) {
	NIM_BOOL result;
	result = 0;
	switch ((*s).kind) {
	case ((NU8) 12):
	case ((NU8) 18):
	case ((NU8) 17):
	case ((NU8) 14):
	case ((NU8) 15):
	case ((NU8) 13):
	case ((NU8) 16):
	{
		NIM_BOOL LOC2;
		NIM_BOOL LOC4;
		Tnode191813* LOC6;
		LOC2 = 0;
		LOC2 = (((*s).flags &(1<<((((NU8) 2))&31)))!=0);
		if (LOC2) goto LA3;
		LOC4 = 0;
		LOC4 = !(((*s).ast == NIM_NIL));
		if (!(LOC4)) goto LA5;
		LOC6 = 0;
		LOC6 = HEX5BHEX5D_192244((*s).ast, ((NI) 2));
		LOC4 = !(((*LOC6).kind == ((NU8) 1)));
		LA5: ;
		LOC2 = LOC4;
		LA3: ;
		result = LOC2;
	}
	break;
	default:
	{
	}
	break;
	}
	return result;
}

N_NIMCALL(void, discardsons_192091)(Tnode191813* father) {
	genericSeqAssign((&(*father).kindU.S6.sons), NIM_NIL, (&NTI191807));
}

N_NIMCALL(void, appendtomodule_192911)(Tsym191843* m, Tnode191813* n) {
	{
		TY209680 LOC5;
		if (!((*m).ast == NIM_NIL)) goto LA3;
		asgnRefNoCycle((void**) (&(*m).ast), newnode_192401(((NU8) 115)));
		if ((*(*m).ast).kindU.S6.sons) nimGCunrefNoCycle((*(*m).ast).kindU.S6.sons);
		(*(*m).ast).kindU.S6.sons = (Tnodeseq191807*) newSeqRC1((&NTI191807), 1);
		memset((void*)LOC5, 0, sizeof(LOC5));
		LOC5[0] = n;
		asgnRefNoCycle((void**) (&(*(*m).ast).kindU.S6.sons->data[0]), LOC5[0]);
	}
	goto LA1;
	LA3: ;
	{
		(*(*m).ast).kindU.S6.sons = (Tnodeseq191807*) incrSeq(&((*(*m).ast).kindU.S6.sons)->Sup, sizeof(Tnode191813*));
		asgnRefNoCycle((void**) (&(*(*m).ast).kindU.S6.sons->data[(*(*m).ast).kindU.S6.sons->Sup.len-1]), n);
	}
	LA1: ;
}

N_NIMCALL(void, delson_195577)(Tnode191813* father, NI idx) {
	NI length;
{	{
		if (!(*father).kindU.S6.sons == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	length = sonslen_194403(father);
	{
		NI i_195603;
		NI HEX3Atmp_195618;
		NI res_195621;
		i_195603 = 0;
		HEX3Atmp_195618 = 0;
		HEX3Atmp_195618 = (NI)(length - ((NI) 2));
		res_195621 = idx;
		{
			while (1) {
				if (!(res_195621 <= HEX3Atmp_195618)) goto LA7;
				i_195603 = res_195621;
				asgnRefNoCycle((void**) (&(*father).kindU.S6.sons->data[i_195603]), (*father).kindU.S6.sons->data[(NI)(i_195603 + ((NI) 1))]);
				res_195621 += ((NI) 1);
			} LA7: ;
		}
	}
	(*father).kindU.S6.sons = (Tnodeseq191807*) setLengthSeq(&((*father).kindU.S6.sons)->Sup, sizeof(Tnode191813*), ((NI) ((NI)(length - ((NI) 1)))));
	}BeforeRet: ;
}

N_NIMCALL(Tnode191813*, newfloatnode_192632)(NU8 kind, NF floatval) {
	Tnode191813* result;
	result = 0;
	result = newnode_192401(kind);
	(*result).kindU.S2.floatval = floatval;
	return result;
}

N_NIMCALL(NIM_BOOL, iscallexpr_192071)(Tnode191813* n) {
	NIM_BOOL result;
	result = 0;
	result = ((*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));
	return result;
}

N_NIMCALL(Ttype191849*, skiptypesornil_195195)(Ttype191849* t, NU64 kinds) {
	Ttype191849* result;
{	result = 0;
	result = t;
	{
		while (1) {
			NIM_BOOL LOC3;
			LOC3 = 0;
			LOC3 = !((result == NIM_NIL));
			if (!(LOC3)) goto LA4;
			LOC3 = ((kinds &(IL64(1)<<(((*result).kind)&IL64(63))))!=0);
			LA4: ;
			if (!LOC3) goto LA2;
			{
				NI LOC7;
				LOC7 = 0;
				LOC7 = len_194377(result);
				if (!(LOC7 == ((NI) 0))) goto LA8;
				result = NIM_NIL;
				goto BeforeRet;
			}
			LA8: ;
			result = lastson_194442(result);
		} LA2: ;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, shallowcopy_195817)(Tnode191813* src) {
	Tnode191813* result;
{	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_192401((*src).kind);
	(*result).info = (*src).info;
	asgnRefNoCycle((void**) (&(*result).typ), (*src).typ);
	(*result).flags = ((*src).flags & 13070);
	switch ((*src).kind) {
	case ((NU8) 5) ... ((NU8) 15):
	{
		(*result).kindU.S1.intval = (*src).kindU.S1.intval;
	}
	break;
	case ((NU8) 16) ... ((NU8) 19):
	{
		(*result).kindU.S2.floatval = (*src).kindU.S2.floatval;
	}
	break;
	case ((NU8) 3):
	{
		asgnRefNoCycle((void**) (&(*result).kindU.S4.sym), (*src).kindU.S4.sym);
	}
	break;
	case ((NU8) 2):
	{
		asgnRefNoCycle((void**) (&(*result).kindU.S5.ident), (*src).kindU.S5.ident);
	}
	break;
	case ((NU8) 20) ... ((NU8) 22):
	{
		NimStringDesc* LOC10;
		LOC10 = 0;
		LOC10 = (*result).kindU.S3.strval; (*result).kindU.S3.strval = copyStringRC1((*src).kindU.S3.strval);
		if (LOC10) nimGCunrefNoCycle(LOC10);
	}
	break;
	default:
	{
		NI LOC12;
		LOC12 = 0;
		LOC12 = sonslen_194403(src);
		if ((*result).kindU.S6.sons) nimGCunrefNoCycle((*result).kindU.S6.sons);
		(*result).kindU.S6.sons = (Tnodeseq191807*) newSeqRC1((&NTI191807), ((NI) (LOC12)));
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(void, resetidtable_195077)(Tidtable191861* x) {
	(*x).counter = ((NI) 0);
	(*x).data = (Tidpairseq191859*) setLengthSeq(&((*x).data)->Sup, sizeof(Tidpair191857), ((NI) 0));
	(*x).data = (Tidpairseq191859*) setLengthSeq(&((*x).data)->Sup, sizeof(Tidpair191857), ((NI) 8));
}

N_NIMCALL(Tsym191843*, linkto_192884)(Tsym191843* s, Ttype191849* t) {
	Tsym191843* result;
	result = 0;
	asgnRefNoCycle((void**) (&(*t).sym), s);
	asgnRefNoCycle((void**) (&(*s).typ), t);
	result = s;
	return result;
}

N_NIMCALL(NI64, getint_196605)(Tnode191813* a) {
	NI64 result;
	result = 0;
	switch ((*a).kind) {
	case ((NU8) 6) ... ((NU8) 15):
	{
		result = (*a).kindU.S1.intval;
	}
	break;
	default:
	{
		internalerror_166199((*a).info, ((NimStringDesc*) &TMP3231));
		result = IL64(0);
	}
	break;
	}
	return result;
}

N_NIMCALL(NF, getfloat_196616)(Tnode191813* a) {
	NF result;
	result = 0;
	switch ((*a).kind) {
	case ((NU8) 16) ... ((NU8) 19):
	{
		result = (*a).kindU.S2.floatval;
	}
	break;
	default:
	{
		internalerror_166199((*a).info, ((NimStringDesc*) &TMP3232));
		result = 0.0;
	}
	break;
	}
	return result;
}

N_NIMCALL(NimStringDesc*, getstr_196628)(Tnode191813* a) {
	NimStringDesc* result;
	result = 0;
	switch ((*a).kind) {
	case ((NU8) 20) ... ((NU8) 22):
	{
		result = copyString((*a).kindU.S3.strval);
	}
	break;
	default:
	{
		internalerror_166199((*a).info, ((NimStringDesc*) &TMP3233));
		result = copyString(((NimStringDesc*) &TMP2070));
	}
	break;
	}
	return result;
}

N_NIMCALL(NimStringDesc*, getstrorchar_196639)(Tnode191813* a) {
	NimStringDesc* result;
	result = 0;
	switch ((*a).kind) {
	case ((NU8) 20) ... ((NU8) 22):
	{
		result = copyString((*a).kindU.S3.strval);
	}
	break;
	case ((NU8) 5) ... ((NU8) 15):
	{
		result = nimCharToStr(((NIM_CHAR) (((NI) (((NI) ((*a).kindU.S1.intval)))))));
	}
	break;
	default:
	{
		internalerror_166199((*a).info, ((NimStringDesc*) &TMP3236));
		result = copyString(((NimStringDesc*) &TMP2070));
	}
	break;
	}
	return result;
}
N_NIMCALL(void, TMP3256)(void* p, NI op) {
	Tidnodepairseq191865* a;
	NI LOC1;
	a = (Tidnodepairseq191865*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1].key, op);
	nimGCvisit((void*)a->data[LOC1].val, op);
	}
}

N_NIMCALL(void, initidnodetable_195127)(Tidnodetable191867* x) {
	(*x).counter = ((NI) 0);
	unsureAsgnRef((void**) (&(*x).data), (Tidnodepairseq191865*) newSeq((&NTI191865), ((NI) 8)));
}

N_NIMCALL(NIM_BOOL, containsnode_196365)(Tnode191813* n, TY433644 kinds) {
	NIM_BOOL result;
{	result = 0;
	{
		if (!(n == NIM_NIL)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	switch ((*n).kind) {
	case ((NU8) 1) ... ((NU8) 23):
	{
		result = ((kinds[(*n).kind/8] &(1<<((*n).kind%8)))!=0);
	}
	break;
	default:
	{
		{
			NI i_196404;
			NI HEX3Atmp_196417;
			NI LOC8;
			NI res_196420;
			i_196404 = 0;
			HEX3Atmp_196417 = 0;
			LOC8 = 0;
			LOC8 = sonslen_194403(n);
			HEX3Atmp_196417 = (NI)(LOC8 - ((NI) 1));
			res_196420 = ((NI) 0);
			{
				while (1) {
					if (!(res_196420 <= HEX3Atmp_196417)) goto LA10;
					i_196404 = res_196420;
					{
						NIM_BOOL LOC13;
						LOC13 = 0;
						LOC13 = ((kinds[(*n).kind/8] &(1<<((*n).kind%8)))!=0);
						if (LOC13) goto LA14;
						LOC13 = containsnode_196365((*n).kindU.S6.sons->data[i_196404], kinds);
						LA14: ;
						if (!LOC13) goto LA15;
						result = NIM_TRUE;
						goto BeforeRet;
					}
					LA15: ;
					res_196420 += ((NI) 1);
				} LA10: ;
			}
		}
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, hassubnodewith_196439)(Tnode191813* n, NU8 kind) {
	NIM_BOOL result;
{	result = 0;
	switch ((*n).kind) {
	case ((NU8) 1) ... ((NU8) 23):
	{
		result = ((*n).kind == kind);
	}
	break;
	default:
	{
		{
			NI i_196465;
			NI HEX3Atmp_196478;
			NI LOC4;
			NI res_196481;
			i_196465 = 0;
			HEX3Atmp_196478 = 0;
			LOC4 = 0;
			LOC4 = sonslen_194403(n);
			HEX3Atmp_196478 = (NI)(LOC4 - ((NI) 1));
			res_196481 = ((NI) 0);
			{
				while (1) {
					if (!(res_196481 <= HEX3Atmp_196478)) goto LA6;
					i_196465 = res_196481;
					{
						NIM_BOOL LOC9;
						LOC9 = 0;
						LOC9 = ((*(*n).kindU.S6.sons->data[i_196465]).kind == kind);
						if (LOC9) goto LA10;
						LOC9 = hassubnodewith_196439((*n).kindU.S6.sons->data[i_196465], kind);
						LA10: ;
						if (!LOC9) goto LA11;
						result = NIM_TRUE;
						goto BeforeRet;
					}
					LA11: ;
					res_196481 += ((NI) 1);
				} LA6: ;
			}
		}
		result = NIM_FALSE;
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, withinfo_193302)(Tnode191813* n, Tlineinfo164338 info) {
	Tnode191813* result;
{	result = 0;
	(*n).info = info;
	result = n;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tsym191843*, createmodulealias_194844)(Tsym191843* s, Tident168021* newident, Tlineinfo164338 info) {
	Tsym191843* result;
	result = 0;
	result = newsym_192656((*s).kind, newident, (*s).owner, info);
	asgnRefNoCycle((void**) (&(*result).ast), (*s).ast);
	(*result).Sup.id = (*s).Sup.id;
	(*result).flags = (*s).flags;
	(*result).kindU.S3.tab.counter = (*s).kindU.S3.tab.counter;
	asgnRefNoCycle((void**) (&(*result).kindU.S3.tab.data), (*s).kindU.S3.tab.data);
	(*result).options = (*s).options;
	(*result).position = (*s).position;
	genericAssign((void*)(&(*result).loc), (void*)(&(*s).loc), (&NTI191827));
	asgnRef((void**) (&(*result).annex), (*s).annex);
	return result;
}

N_NIMCALL(void, initnodetable_195147)(Tnodetable191873* x) {
	(*x).counter = ((NI) 0);
	unsureAsgnRef((void**) (&(*x).data), (Tnodepairseq191871*) newSeq((&NTI191871), ((NI) 8)));
}
NIM_EXTERNC N_NOINLINE(void, nimsrc_astInit)(void) {
	Tident168021* LOC1;
	Tlineinfo164338 LOC2;
	asgnRefNoCycle((void**) (&emptynode_192807), newnode_192401(((NU8) 1)));
	LOC1 = 0;
	LOC1 = getident_168463(((NimStringDesc*) &TMP792));
	LOC2 = unknownlineinfo_165027();
	asgnRefNoCycle((void**) (&anyglobal_192814), newsym_192656(((NU8) 8), LOC1, NIM_NIL, LOC2));
	asgnRefNoCycle((void**) (&emptyparams_194044), newnode_192401(((NU8) 76)));
	addson_193819(emptyparams_194044, emptynode_192807);
	asgnRefNoCycle((void**) (&opnot_196998), createmagic_196986(((NimStringDesc*) &TMP793), ((NU16) 109)));
	asgnRefNoCycle((void**) (&opcontains_196999), createmagic_196986(((NimStringDesc*) &TMP794), ((NU16) 159)));
}

NIM_EXTERNC N_NOINLINE(void, nimsrc_astDatInit)(void) {
static TNimNode* TMP729[5];
static TNimNode* TMP730[14];
static TNimNode* TMP731[62];
NI TMP733;
static char* NIM_CONST TMP732[62] = {
"tyNone", 
"tyBool", 
"tyChar", 
"tyEmpty", 
"tyArrayConstr", 
"tyNil", 
"tyExpr", 
"tyStmt", 
"tyTypeDesc", 
"tyGenericInvocation", 
"tyGenericBody", 
"tyGenericInst", 
"tyGenericParam", 
"tyDistinct", 
"tyEnum", 
"tyOrdinal", 
"tyArray", 
"tyObject", 
"tyTuple", 
"tySet", 
"tyRange", 
"tyPtr", 
"tyRef", 
"tyVar", 
"tySequence", 
"tyProc", 
"tyPointer", 
"tyOpenArray", 
"tyString", 
"tyCString", 
"tyForward", 
"tyInt", 
"tyInt8", 
"tyInt16", 
"tyInt32", 
"tyInt64", 
"tyFloat", 
"tyFloat32", 
"tyFloat64", 
"tyFloat128", 
"tyUInt", 
"tyUInt8", 
"tyUInt16", 
"tyUInt32", 
"tyUInt64", 
"tyBigNum", 
"tyConst", 
"tyMutable", 
"tyVarargs", 
"tyIter", 
"tyProxy", 
"tyBuiltInTypeClass", 
"tyUserTypeClass", 
"tyUserTypeClassInst", 
"tyCompositeTypeClass", 
"tyAnd", 
"tyOr", 
"tyNot", 
"tyAnything", 
"tyStatic", 
"tyFromExpr", 
"tyFieldAccessor"};
static TNimNode* TMP734[10];
NI TMP736;
static char* NIM_CONST TMP735[10] = {
"ccDefault", 
"ccStdCall", 
"ccCDecl", 
"ccSafeCall", 
"ccSysCall", 
"ccInline", 
"ccNoInline", 
"ccFastCall", 
"ccClosure", 
"ccNoConvention"};
static TNimNode* TMP737[28];
NI TMP739;
static char* NIM_CONST TMP738[28] = {
"tfVarargs", 
"tfNoSideEffect", 
"tfFinal", 
"tfInheritable", 
"tfAcyclic", 
"tfEnumHasHoles", 
"tfShallow", 
"tfThread", 
"tfFromGeneric", 
"tfUnresolved", 
"tfRetType", 
"tfCapturesEnv", 
"tfByCopy", 
"tfByRef", 
"tfIterator", 
"tfShared", 
"tfNotNil", 
"tfNeedsInit", 
"tfVarIsPtr", 
"tfHasMeta", 
"tfHasGCedMem", 
"tfPacked", 
"tfHasStatic", 
"tfGenericTypeParam", 
"tfImplicitTypeParam", 
"tfWildcard", 
"tfHasAsgn", 
"tfBorrowDot"};
static TNimNode* TMP741[14];
static TNimNode* TMP742[26];
NI TMP744;
static char* NIM_CONST TMP743[26] = {
"skUnknown", 
"skConditional", 
"skDynLib", 
"skParam", 
"skGenericParam", 
"skTemp", 
"skModule", 
"skType", 
"skVar", 
"skLet", 
"skConst", 
"skResult", 
"skProc", 
"skMethod", 
"skIterator", 
"skClosureIterator", 
"skConverter", 
"skMacro", 
"skTemplate", 
"skField", 
"skEnumField", 
"skForVar", 
"skLabel", 
"skStub", 
"skPackage", 
"skAlias"};
static TNimNode* TMP745[2];
static TNimNode* TMP746[4];
static TNimNode* TMP747[2];
static TNimNode* TMP751[2];
static TNimNode* TMP752[3];
static TNimNode* TMP756[2];
static TNimNode* TMP757[264];
NI TMP759;
static char* NIM_CONST TMP758[264] = {
"mNone", 
"mDefined", 
"mDefinedInScope", 
"mCompiles", 
"mLow", 
"mHigh", 
"mSizeOf", 
"mTypeTrait", 
"mIs", 
"mOf", 
"mAddr", 
"mTypeOf", 
"mRoof", 
"mPlugin", 
"mEcho", 
"mShallowCopy", 
"mSlurp", 
"mStaticExec", 
"mParseExprToAst", 
"mParseStmtToAst", 
"mExpandToAst", 
"mQuoteAst", 
"mUnaryLt", 
"mInc", 
"mDec", 
"mOrd", 
"mNew", 
"mNewFinalize", 
"mNewSeq", 
"mLengthOpenArray", 
"mLengthStr", 
"mLengthArray", 
"mLengthSeq", 
"mXLenStr", 
"mXLenSeq", 
"mIncl", 
"mExcl", 
"mCard", 
"mChr", 
"mGCref", 
"mGCunref", 
"mAddI", 
"mSubI", 
"mMulI", 
"mDivI", 
"mModI", 
"mAddI64", 
"mSubI64", 
"mMulI64", 
"mDivI64", 
"mModI64", 
"mSucc", 
"mPred", 
"mAddF64", 
"mSubF64", 
"mMulF64", 
"mDivF64", 
"mShrI", 
"mShlI", 
"mBitandI", 
"mBitorI", 
"mBitxorI", 
"mMinI", 
"mMaxI", 
"mShrI64", 
"mShlI64", 
"mBitandI64", 
"mBitorI64", 
"mBitxorI64", 
"mMinF64", 
"mMaxF64", 
"mAddU", 
"mSubU", 
"mMulU", 
"mDivU", 
"mModU", 
"mEqI", 
"mLeI", 
"mLtI", 
"mEqI64", 
"mLeI64", 
"mLtI64", 
"mEqF64", 
"mLeF64", 
"mLtF64", 
"mLeU", 
"mLtU", 
"mLeU64", 
"mLtU64", 
"mEqEnum", 
"mLeEnum", 
"mLtEnum", 
"mEqCh", 
"mLeCh", 
"mLtCh", 
"mEqB", 
"mLeB", 
"mLtB", 
"mEqRef", 
"mEqUntracedRef", 
"mLePtr", 
"mLtPtr", 
"mEqCString", 
"mXor", 
"mEqProc", 
"mUnaryMinusI", 
"mUnaryMinusI64", 
"mAbsI", 
"mAbsI64", 
"mNot", 
"mUnaryPlusI", 
"mBitnotI", 
"mBitnotI64", 
"mUnaryPlusF64", 
"mUnaryMinusF64", 
"mAbsF64", 
"mZe8ToI", 
"mZe8ToI64", 
"mZe16ToI", 
"mZe16ToI64", 
"mZe32ToI64", 
"mZeIToI64", 
"mToU8", 
"mToU16", 
"mToU32", 
"mToFloat", 
"mToBiggestFloat", 
"mToInt", 
"mToBiggestInt", 
"mCharToStr", 
"mBoolToStr", 
"mIntToStr", 
"mInt64ToStr", 
"mFloatToStr", 
"mCStrToStr", 
"mStrToStr", 
"mEnumToStr", 
"mAnd", 
"mOr", 
"mEqStr", 
"mLeStr", 
"mLtStr", 
"mEqSet", 
"mLeSet", 
"mLtSet", 
"mMulSet", 
"mPlusSet", 
"mMinusSet", 
"mSymDiffSet", 
"mConStrStr", 
"mSlice", 
"mDotDot", 
"mFields", 
"mFieldPairs", 
"mOmpParFor", 
"mAppendStrCh", 
"mAppendStrStr", 
"mAppendSeqElem", 
"mInRange", 
"mInSet", 
"mRepr", 
"mExit", 
"mSetLengthStr", 
"mSetLengthSeq", 
"mIsPartOf", 
"mAstToStr", 
"mParallel", 
"mSwap", 
"mIsNil", 
"mArrToSeq", 
"mCopyStr", 
"mCopyStrLast", 
"mNewString", 
"mNewStringOfCap", 
"mParseBiggestFloat", 
"mReset", 
"mArray", 
"mOpenArray", 
"mRange", 
"mSet", 
"mSeq", 
"mVarargs", 
"mOrdinal", 
"mInt", 
"mInt8", 
"mInt16", 
"mInt32", 
"mInt64", 
"mUInt", 
"mUInt8", 
"mUInt16", 
"mUInt32", 
"mUInt64", 
"mFloat", 
"mFloat32", 
"mFloat64", 
"mFloat128", 
"mBool", 
"mChar", 
"mString", 
"mCstring", 
"mPointer", 
"mEmptySet", 
"mIntSetBaseType", 
"mNil", 
"mExpr", 
"mStmt", 
"mTypeDesc", 
"mVoidType", 
"mPNimrodNode", 
"mShared", 
"mGuarded", 
"mLock", 
"mSpawn", 
"mDeepCopy", 
"mIsMainModule", 
"mCompileDate", 
"mCompileTime", 
"mProcCall", 
"mCpuEndian", 
"mHostOS", 
"mHostCPU", 
"mAppType", 
"mNaN", 
"mInf", 
"mNegInf", 
"mCompileOption", 
"mCompileOptionArg", 
"mNLen", 
"mNChild", 
"mNSetChild", 
"mNAdd", 
"mNAddMultiple", 
"mNDel", 
"mNKind", 
"mNIntVal", 
"mNFloatVal", 
"mNSymbol", 
"mNIdent", 
"mNGetType", 
"mNStrVal", 
"mNSetIntVal", 
"mNSetFloatVal", 
"mNSetSymbol", 
"mNSetIdent", 
"mNSetType", 
"mNSetStrVal", 
"mNLineInfo", 
"mNNewNimNode", 
"mNCopyNimNode", 
"mNCopyNimTree", 
"mStrToIdent", 
"mIdentToStr", 
"mNBindSym", 
"mLocals", 
"mNCallSite", 
"mEqIdent", 
"mEqNimrodNode", 
"mNHint", 
"mNWarning", 
"mNError", 
"mInstantiationInfo", 
"mGetTypeInfo", 
"mNGenSym"};
static TNimNode* TMP760[32];
NI TMP762;
static char* NIM_CONST TMP761[32] = {
"sfUsed", 
"sfExported", 
"sfFromGeneric", 
"sfGlobal", 
"sfForward", 
"sfImportc", 
"sfExportc", 
"sfVolatile", 
"sfRegister", 
"sfPure", 
"sfNoSideEffect", 
"sfSideEffect", 
"sfMainModule", 
"sfSystemModule", 
"sfNoReturn", 
"sfAddrTaken", 
"sfCompilerProc", 
"sfProcvar", 
"sfDiscriminant", 
"sfDeprecated", 
"sfError", 
"sfShadowed", 
"sfThread", 
"sfCompileTime", 
"sfConstructor", 
"sfDeadCodeElim", 
"sfBorrow", 
"sfInfixCall", 
"sfNamedParamCall", 
"sfDiscardable", 
"sfOverriden", 
"sfGenSym"};
static TNimNode* TMP766[6];
static TNimNode* TMP767[11];
NI TMP769;
static char* NIM_CONST TMP768[11] = {
"locNone", 
"locTemp", 
"locLocalVar", 
"locGlobalVar", 
"locParam", 
"locField", 
"locExpr", 
"locProc", 
"locData", 
"locCall", 
"locOther"};
static TNimNode* TMP770[3];
NI TMP772;
static char* NIM_CONST TMP771[3] = {
"OnUnknown", 
"OnStack", 
"OnHeap"};
static TNimNode* TMP773[9];
NI TMP775;
static char* NIM_CONST TMP774[9] = {
"lfIndirect", 
"lfFullExternalName", 
"lfNoDeepCopy", 
"lfNoDecl", 
"lfDynamicLib", 
"lfExportLib", 
"lfHeader", 
"lfImportCompilerProc", 
"lfSingleUse"};
static TNimNode* TMP778[5];
static TNimNode* TMP779[2];
NI TMP781;
static char* NIM_CONST TMP780[2] = {
"libHeader", 
"libDynamic"};
static TNimNode* TMP785[14];
NI TMP787;
static char* NIM_CONST TMP786[14] = {
"nfNone", 
"nfBase2", 
"nfBase8", 
"nfBase16", 
"nfAllConst", 
"nfTransf", 
"nfSem", 
"nfLL", 
"nfDotField", 
"nfDotSetter", 
"nfExplicitCall", 
"nfExprCall", 
"nfIsRef", 
"nfIsCursor"};
static TNimNode* TMP788[159];
NI TMP790;
static char* NIM_CONST TMP789[159] = {
"nkNone", 
"nkEmpty", 
"nkIdent", 
"nkSym", 
"nkType", 
"nkCharLit", 
"nkIntLit", 
"nkInt8Lit", 
"nkInt16Lit", 
"nkInt32Lit", 
"nkInt64Lit", 
"nkUIntLit", 
"nkUInt8Lit", 
"nkUInt16Lit", 
"nkUInt32Lit", 
"nkUInt64Lit", 
"nkFloatLit", 
"nkFloat32Lit", 
"nkFloat64Lit", 
"nkFloat128Lit", 
"nkStrLit", 
"nkRStrLit", 
"nkTripleStrLit", 
"nkNilLit", 
"nkMetaNode_Obsolete", 
"nkDotCall", 
"nkCommand", 
"nkCall", 
"nkCallStrLit", 
"nkInfix", 
"nkPrefix", 
"nkPostfix", 
"nkHiddenCallConv", 
"nkExprEqExpr", 
"nkExprColonExpr", 
"nkIdentDefs", 
"nkVarTuple", 
"nkPar", 
"nkObjConstr", 
"nkCurly", 
"nkCurlyExpr", 
"nkBracket", 
"nkBracketExpr", 
"nkPragmaExpr", 
"nkRange", 
"nkDotExpr", 
"nkCheckedFieldExpr", 
"nkDerefExpr", 
"nkIfExpr", 
"nkElifExpr", 
"nkElseExpr", 
"nkLambda", 
"nkDo", 
"nkAccQuoted", 
"nkTableConstr", 
"nkBind", 
"nkClosedSymChoice", 
"nkOpenSymChoice", 
"nkHiddenStdConv", 
"nkHiddenSubConv", 
"nkConv", 
"nkCast", 
"nkStaticExpr", 
"nkAddr", 
"nkHiddenAddr", 
"nkHiddenDeref", 
"nkObjDownConv", 
"nkObjUpConv", 
"nkChckRangeF", 
"nkChckRange64", 
"nkChckRange", 
"nkStringToCString", 
"nkCStringToString", 
"nkAsgn", 
"nkFastAsgn", 
"nkGenericParams", 
"nkFormalParams", 
"nkOfInherit", 
"nkImportAs", 
"nkProcDef", 
"nkMethodDef", 
"nkConverterDef", 
"nkMacroDef", 
"nkTemplateDef", 
"nkIteratorDef", 
"nkOfBranch", 
"nkElifBranch", 
"nkExceptBranch", 
"nkElse", 
"nkAsmStmt", 
"nkPragma", 
"nkPragmaBlock", 
"nkIfStmt", 
"nkWhenStmt", 
"nkForStmt", 
"nkParForStmt", 
"nkWhileStmt", 
"nkCaseStmt", 
"nkTypeSection", 
"nkVarSection", 
"nkLetSection", 
"nkConstSection", 
"nkConstDef", 
"nkTypeDef", 
"nkYieldStmt", 
"nkDefer", 
"nkTryStmt", 
"nkFinally", 
"nkRaiseStmt", 
"nkReturnStmt", 
"nkBreakStmt", 
"nkContinueStmt", 
"nkBlockStmt", 
"nkStaticStmt", 
"nkDiscardStmt", 
"nkStmtList", 
"nkImportStmt", 
"nkImportExceptStmt", 
"nkExportStmt", 
"nkExportExceptStmt", 
"nkFromStmt", 
"nkIncludeStmt", 
"nkBindStmt", 
"nkMixinStmt", 
"nkUsingStmt", 
"nkCommentStmt", 
"nkStmtListExpr", 
"nkBlockExpr", 
"nkStmtListType", 
"nkBlockType", 
"nkWith", 
"nkWithout", 
"nkTypeOfExpr", 
"nkObjectTy", 
"nkTupleTy", 
"nkTupleClassTy", 
"nkTypeClassTy", 
"nkStaticTy", 
"nkRecList", 
"nkRecCase", 
"nkRecWhen", 
"nkRefTy", 
"nkPtrTy", 
"nkVarTy", 
"nkConstTy", 
"nkMutableTy", 
"nkDistinctTy", 
"nkProcTy", 
"nkIteratorTy", 
"nkSharedTy", 
"nkEnumTy", 
"nkEnumFieldDef", 
"nkArgList", 
"nkPattern", 
"nkReturnToken", 
"nkClosure", 
"nkGotoState", 
"nkState", 
"nkBreakState"};
static TNimNode* TMP828[2];
static TNimNode* TMP829[2];
static TNimNode* TMP1055[2];
static TNimNode* TMP1056[3];
static TNimNode* TMP3254[2];
static TNimNode* TMP3255[2];
static TNimNode TMP723[733];
NTI191813.size = sizeof(Tnode191813);
NTI191813.kind = 18;
NTI191813.base = 0;
NTI191813.flags = 2;
TMP729[0] = &TMP723[1];
NTI191849.size = sizeof(Ttype191849);
NTI191849.kind = 17;
NTI191849.base = (&NTI168015);
NTI191849.flags = 2;
TMP730[0] = &TMP723[3];
NTI191260.size = sizeof(NU8);
NTI191260.kind = 14;
NTI191260.base = 0;
NTI191260.flags = 3;
for (TMP733 = 0; TMP733 < 62; TMP733++) {
TMP723[TMP733+4].kind = 1;
TMP723[TMP733+4].offset = TMP733;
TMP723[TMP733+4].name = TMP732[TMP733];
TMP731[TMP733] = &TMP723[TMP733+4];
}
TMP723[66].len = 62; TMP723[66].kind = 2; TMP723[66].sons = &TMP731[0];
NTI191260.node = &TMP723[66];
TMP723[3].kind = 1;
TMP723[3].offset = offsetof(Ttype191849, kind);
TMP723[3].typ = (&NTI191260);
TMP723[3].name = "kind";
TMP730[1] = &TMP723[67];
NTI191005.size = sizeof(NU8);
NTI191005.kind = 14;
NTI191005.base = 0;
NTI191005.flags = 3;
for (TMP736 = 0; TMP736 < 10; TMP736++) {
TMP723[TMP736+68].kind = 1;
TMP723[TMP736+68].offset = TMP736;
TMP723[TMP736+68].name = TMP735[TMP736];
TMP734[TMP736] = &TMP723[TMP736+68];
}
TMP723[78].len = 10; TMP723[78].kind = 2; TMP723[78].sons = &TMP734[0];
NTI191005.node = &TMP723[78];
TMP723[67].kind = 1;
TMP723[67].offset = offsetof(Ttype191849, callconv);
TMP723[67].typ = (&NTI191005);
TMP723[67].name = "callConv";
TMP730[2] = &TMP723[79];
NTI191437.size = sizeof(NU8);
NTI191437.kind = 14;
NTI191437.base = 0;
NTI191437.flags = 3;
for (TMP739 = 0; TMP739 < 28; TMP739++) {
TMP723[TMP739+80].kind = 1;
TMP723[TMP739+80].offset = TMP739;
TMP723[TMP739+80].name = TMP738[TMP739];
TMP737[TMP739] = &TMP723[TMP739+80];
}
TMP723[108].len = 28; TMP723[108].kind = 2; TMP723[108].sons = &TMP737[0];
NTI191437.node = &TMP723[108];
NTI191439.size = sizeof(NU32);
NTI191439.kind = 19;
NTI191439.base = (&NTI191437);
NTI191439.flags = 3;
TMP723[109].len = 0; TMP723[109].kind = 0;
NTI191439.node = &TMP723[109];
TMP723[79].kind = 1;
TMP723[79].offset = offsetof(Ttype191849, flags);
TMP723[79].typ = (&NTI191439);
TMP723[79].name = "flags";
TMP730[3] = &TMP723[110];
NTI191845.size = sizeof(Ttypeseq191845*);
NTI191845.kind = 24;
NTI191845.base = (&NTI191809);
NTI191845.flags = 2;
NTI191845.marker = TMP740;
TMP723[110].kind = 1;
TMP723[110].offset = offsetof(Ttype191849, sons);
TMP723[110].typ = (&NTI191845);
TMP723[110].name = "sons";
TMP730[4] = &TMP723[111];
TMP723[111].kind = 1;
TMP723[111].offset = offsetof(Ttype191849, n);
TMP723[111].typ = (&NTI191805);
TMP723[111].name = "n";
TMP730[5] = &TMP723[112];
NTI191843.size = sizeof(Tsym191843);
NTI191843.kind = 17;
NTI191843.base = (&NTI168015);
NTI191843.flags = 2;
TMP741[0] = &TMP723[114];
NTI191441.size = sizeof(NU8);
NTI191441.kind = 14;
NTI191441.base = 0;
NTI191441.flags = 3;
for (TMP744 = 0; TMP744 < 26; TMP744++) {
TMP723[TMP744+115].kind = 1;
TMP723[TMP744+115].offset = TMP744;
TMP723[TMP744+115].name = TMP743[TMP744];
TMP742[TMP744] = &TMP723[TMP744+115];
}
TMP723[141].len = 26; TMP723[141].kind = 2; TMP723[141].sons = &TMP742[0];
NTI191441.node = &TMP723[141];
TMP723[114].kind = 3;
TMP723[114].offset = offsetof(Tsym191843, kind);
TMP723[114].typ = (&NTI191441);
TMP723[114].name = "kind";
TMP723[114].sons = &NimDT_191843_kind[0];
TMP723[114].len = 26;
TMP745[0] = &TMP723[143];
TMP723[143].kind = 1;
TMP723[143].offset = offsetof(Tsym191843, kindU.S1.typeinstcache);
TMP723[143].typ = (&NTI191845);
TMP723[143].name = "typeInstCache";
TMP745[1] = &TMP723[144];
NTI191837.size = sizeof(Tscope191837);
NTI191837.kind = 18;
NTI191837.base = 0;
TMP746[0] = &TMP723[146];
TMP723[146].kind = 1;
TMP723[146].offset = offsetof(Tscope191837, depthlevel);
TMP723[146].typ = (&NTI108);
TMP723[146].name = "depthLevel";
TMP746[1] = &TMP723[147];
NTI191817.size = sizeof(Tstrtable191817);
NTI191817.kind = 18;
NTI191817.base = 0;
NTI191817.flags = 2;
TMP747[0] = &TMP723[149];
TMP723[149].kind = 1;
TMP723[149].offset = offsetof(Tstrtable191817, counter);
TMP723[149].typ = (&NTI108);
TMP723[149].name = "counter";
TMP747[1] = &TMP723[150];
NTI191815.size = sizeof(Tsymseq191815*);
NTI191815.kind = 24;
NTI191815.base = (&NTI191811);
NTI191815.flags = 2;
NTI191815.marker = TMP748;
TMP723[150].kind = 1;
TMP723[150].offset = offsetof(Tstrtable191817, data);
TMP723[150].typ = (&NTI191815);
TMP723[150].name = "data";
TMP723[148].len = 2; TMP723[148].kind = 2; TMP723[148].sons = &TMP747[0];
NTI191817.node = &TMP723[148];
TMP723[147].kind = 1;
TMP723[147].offset = offsetof(Tscope191837, symbols);
TMP723[147].typ = (&NTI191817);
TMP723[147].name = "symbols";
TMP746[2] = &TMP723[151];
NTI191807.size = sizeof(Tnodeseq191807*);
NTI191807.kind = 24;
NTI191807.base = (&NTI191805);
NTI191807.flags = 2;
NTI191807.marker = TMP749;
TMP723[151].kind = 1;
TMP723[151].offset = offsetof(Tscope191837, usingsyms);
TMP723[151].typ = (&NTI191807);
TMP723[151].name = "usingSyms";
TMP746[3] = &TMP723[152];
TMP723[152].kind = 1;
TMP723[152].offset = offsetof(Tscope191837, parent);
TMP723[152].typ = (&NTI191839);
TMP723[152].name = "parent";
TMP723[145].len = 4; TMP723[145].kind = 2; TMP723[145].sons = &TMP746[0];
NTI191837.node = &TMP723[145];
NTI191839.size = sizeof(Tscope191837*);
NTI191839.kind = 22;
NTI191839.base = (&NTI191837);
NTI191839.marker = TMP750;
TMP723[144].kind = 1;
TMP723[144].offset = offsetof(Tsym191843, kindU.S1.typscope);
TMP723[144].typ = (&NTI191839);
TMP723[144].name = "typScope";
TMP723[142].len = 2; TMP723[142].kind = 2; TMP723[142].sons = &TMP745[0];
NimDT_191843_kind[7] = &TMP723[142];
NimDT_191843_kind[4] = &TMP723[142];
TMP751[0] = &TMP723[154];
NTI191833.size = sizeof(Tinstantiation191833);
NTI191833.kind = 18;
NTI191833.base = 0;
NTI191833.flags = 2;
TMP752[0] = &TMP723[156];
TMP723[156].kind = 1;
TMP723[156].offset = offsetof(Tinstantiation191833, sym);
TMP723[156].typ = (&NTI191811);
TMP723[156].name = "sym";
TMP752[1] = &TMP723[157];
TMP723[157].kind = 1;
TMP723[157].offset = offsetof(Tinstantiation191833, concretetypes);
TMP723[157].typ = (&NTI191845);
TMP723[157].name = "concreteTypes";
TMP752[2] = &TMP723[158];
NTI191933.size = sizeof(TY191933*);
NTI191933.kind = 24;
NTI191933.base = (&NTI114);
NTI191933.flags = 2;
NTI191933.marker = TMP753;
TMP723[158].kind = 1;
TMP723[158].offset = offsetof(Tinstantiation191833, usedby);
TMP723[158].typ = (&NTI191933);
TMP723[158].name = "usedBy";
TMP723[155].len = 3; TMP723[155].kind = 2; TMP723[155].sons = &TMP752[0];
NTI191833.node = &TMP723[155];
NTI191835.size = sizeof(Tinstantiation191833*);
NTI191835.kind = 22;
NTI191835.base = (&NTI191833);
NTI191835.flags = 2;
NTI191835.marker = TMP754;
NTI191944.size = sizeof(TY191944*);
NTI191944.kind = 24;
NTI191944.base = (&NTI191835);
NTI191944.flags = 2;
NTI191944.marker = TMP755;
TMP723[154].kind = 1;
TMP723[154].offset = offsetof(Tsym191843, kindU.S2.procinstcache);
TMP723[154].typ = (&NTI191944);
TMP723[154].name = "procInstCache";
TMP751[1] = &TMP723[159];
TMP723[159].kind = 1;
TMP723[159].offset = offsetof(Tsym191843, kindU.S2.gcunsafetyreason);
TMP723[159].typ = (&NTI191811);
TMP723[159].name = "gcUnsafetyReason";
TMP723[153].len = 2; TMP723[153].kind = 2; TMP723[153].sons = &TMP751[0];
NimDT_191843_kind[12] = &TMP723[153];
NimDT_191843_kind[13] = &TMP723[153];
NimDT_191843_kind[14] = &TMP723[153];
NimDT_191843_kind[15] = &TMP723[153];
NimDT_191843_kind[16] = &TMP723[153];
NimDT_191843_kind[17] = &TMP723[153];
NimDT_191843_kind[18] = &TMP723[153];
TMP756[0] = &TMP723[161];
TMP723[161].kind = 1;
TMP723[161].offset = offsetof(Tsym191843, kindU.S3.usedgenerics);
TMP723[161].typ = (&NTI191944);
TMP723[161].name = "usedGenerics";
TMP756[1] = &TMP723[162];
TMP723[162].kind = 1;
TMP723[162].offset = offsetof(Tsym191843, kindU.S3.tab);
TMP723[162].typ = (&NTI191817);
TMP723[162].name = "tab";
TMP723[160].len = 2; TMP723[160].kind = 2; TMP723[160].sons = &TMP756[0];
NimDT_191843_kind[6] = &TMP723[160];
TMP723[163].kind = 1;
TMP723[163].offset = offsetof(Tsym191843, kindU.S4.guard);
TMP723[163].typ = (&NTI191811);
TMP723[163].name = "guard";
NimDT_191843_kind[9] = &TMP723[163];
NimDT_191843_kind[8] = &TMP723[163];
NimDT_191843_kind[19] = &TMP723[163];
NimDT_191843_kind[21] = &TMP723[163];
TMP723[164].len = 0; TMP723[164].kind = 2;
NimDT_191843_kind[26] = &TMP723[164];
TMP741[1] = &TMP723[165];
NTI191529.size = sizeof(NU16);
NTI191529.kind = 14;
NTI191529.base = 0;
NTI191529.flags = 3;
for (TMP759 = 0; TMP759 < 264; TMP759++) {
TMP723[TMP759+166].kind = 1;
TMP723[TMP759+166].offset = TMP759;
TMP723[TMP759+166].name = TMP758[TMP759];
TMP757[TMP759] = &TMP723[TMP759+166];
}
TMP723[430].len = 264; TMP723[430].kind = 2; TMP723[430].sons = &TMP757[0];
NTI191529.node = &TMP723[430];
TMP723[165].kind = 1;
TMP723[165].offset = offsetof(Tsym191843, magic);
TMP723[165].typ = (&NTI191529);
TMP723[165].name = "magic";
TMP741[2] = &TMP723[431];
TMP723[431].kind = 1;
TMP723[431].offset = offsetof(Tsym191843, typ);
TMP723[431].typ = (&NTI191809);
TMP723[431].name = "typ";
TMP741[3] = &TMP723[432];
TMP723[432].kind = 1;
TMP723[432].offset = offsetof(Tsym191843, name);
TMP723[432].typ = (&NTI168019);
TMP723[432].name = "name";
TMP741[4] = &TMP723[433];
TMP723[433].kind = 1;
TMP723[433].offset = offsetof(Tsym191843, info);
TMP723[433].typ = (&NTI164338);
TMP723[433].name = "info";
TMP741[5] = &TMP723[434];
TMP723[434].kind = 1;
TMP723[434].offset = offsetof(Tsym191843, owner);
TMP723[434].typ = (&NTI191811);
TMP723[434].name = "owner";
TMP741[6] = &TMP723[435];
NTI191195.size = sizeof(NU8);
NTI191195.kind = 14;
NTI191195.base = 0;
NTI191195.flags = 3;
for (TMP762 = 0; TMP762 < 32; TMP762++) {
TMP723[TMP762+436].kind = 1;
TMP723[TMP762+436].offset = TMP762;
TMP723[TMP762+436].name = TMP761[TMP762];
TMP760[TMP762] = &TMP723[TMP762+436];
}
TMP723[468].len = 32; TMP723[468].kind = 2; TMP723[468].sons = &TMP760[0];
NTI191195.node = &TMP723[468];
NTI191197.size = sizeof(NU32);
NTI191197.kind = 19;
NTI191197.base = (&NTI191195);
NTI191197.flags = 3;
TMP723[469].len = 0; TMP723[469].kind = 0;
NTI191197.node = &TMP723[469];
TMP723[435].kind = 1;
TMP723[435].offset = offsetof(Tsym191843, flags);
TMP723[435].typ = (&NTI191197);
TMP723[435].name = "flags";
TMP741[7] = &TMP723[470];
TMP723[470].kind = 1;
TMP723[470].offset = offsetof(Tsym191843, ast);
TMP723[470].typ = (&NTI191805);
TMP723[470].name = "ast";
TMP741[8] = &TMP723[471];
TMP723[471].kind = 1;
TMP723[471].offset = offsetof(Tsym191843, options);
TMP723[471].typ = (&NTI155016);
TMP723[471].name = "options";
TMP741[9] = &TMP723[472];
TMP723[472].kind = 1;
TMP723[472].offset = offsetof(Tsym191843, position);
TMP723[472].typ = (&NTI108);
TMP723[472].name = "position";
TMP741[10] = &TMP723[473];
TMP723[473].kind = 1;
TMP723[473].offset = offsetof(Tsym191843, offset);
TMP723[473].typ = (&NTI108);
TMP723[473].name = "offset";
TMP741[11] = &TMP723[474];
NTI191827.size = sizeof(Tloc191827);
NTI191827.kind = 18;
NTI191827.base = 0;
NTI191827.flags = 2;
TMP766[0] = &TMP723[476];
NTI191819.size = sizeof(NU8);
NTI191819.kind = 14;
NTI191819.base = 0;
NTI191819.flags = 3;
for (TMP769 = 0; TMP769 < 11; TMP769++) {
TMP723[TMP769+477].kind = 1;
TMP723[TMP769+477].offset = TMP769;
TMP723[TMP769+477].name = TMP768[TMP769];
TMP767[TMP769] = &TMP723[TMP769+477];
}
TMP723[488].len = 11; TMP723[488].kind = 2; TMP723[488].sons = &TMP767[0];
NTI191819.node = &TMP723[488];
TMP723[476].kind = 1;
TMP723[476].offset = offsetof(Tloc191827, k);
TMP723[476].typ = (&NTI191819);
TMP723[476].name = "k";
TMP766[1] = &TMP723[489];
NTI191823.size = sizeof(NU8);
NTI191823.kind = 14;
NTI191823.base = 0;
NTI191823.flags = 3;
for (TMP772 = 0; TMP772 < 3; TMP772++) {
TMP723[TMP772+490].kind = 1;
TMP723[TMP772+490].offset = TMP772;
TMP723[TMP772+490].name = TMP771[TMP772];
TMP770[TMP772] = &TMP723[TMP772+490];
}
TMP723[493].len = 3; TMP723[493].kind = 2; TMP723[493].sons = &TMP770[0];
NTI191823.node = &TMP723[493];
TMP723[489].kind = 1;
TMP723[489].offset = offsetof(Tloc191827, s);
TMP723[489].typ = (&NTI191823);
TMP723[489].name = "s";
TMP766[2] = &TMP723[494];
NTI191821.size = sizeof(NU8);
NTI191821.kind = 14;
NTI191821.base = 0;
NTI191821.flags = 3;
for (TMP775 = 0; TMP775 < 9; TMP775++) {
TMP723[TMP775+495].kind = 1;
TMP723[TMP775+495].offset = TMP775;
TMP723[TMP775+495].name = TMP774[TMP775];
TMP773[TMP775] = &TMP723[TMP775+495];
}
TMP723[504].len = 9; TMP723[504].kind = 2; TMP723[504].sons = &TMP773[0];
NTI191821.node = &TMP723[504];
NTI191825.size = sizeof(NU16);
NTI191825.kind = 19;
NTI191825.base = (&NTI191821);
NTI191825.flags = 3;
TMP723[505].len = 0; TMP723[505].kind = 0;
NTI191825.node = &TMP723[505];
TMP723[494].kind = 1;
TMP723[494].offset = offsetof(Tloc191827, flags);
TMP723[494].typ = (&NTI191825);
TMP723[494].name = "flags";
TMP766[3] = &TMP723[506];
TMP723[506].kind = 1;
TMP723[506].offset = offsetof(Tloc191827, t);
TMP723[506].typ = (&NTI191809);
TMP723[506].name = "t";
TMP766[4] = &TMP723[507];
TMP723[507].kind = 1;
TMP723[507].offset = offsetof(Tloc191827, r);
TMP723[507].typ = (&NTI162007);
TMP723[507].name = "r";
TMP766[5] = &TMP723[508];
TMP723[508].kind = 1;
TMP723[508].offset = offsetof(Tloc191827, heaproot);
TMP723[508].typ = (&NTI162007);
TMP723[508].name = "heapRoot";
TMP723[475].len = 6; TMP723[475].kind = 2; TMP723[475].sons = &TMP766[0];
NTI191827.node = &TMP723[475];
TMP723[474].kind = 1;
TMP723[474].offset = offsetof(Tsym191843, loc);
TMP723[474].typ = (&NTI191827);
TMP723[474].name = "loc";
TMP741[12] = &TMP723[509];
NTI191831.size = sizeof(Tlib191831);
NTI191831.kind = 17;
NTI191831.base = (&NTI130022);
TMP778[0] = &TMP723[511];
NTI191829.size = sizeof(NU8);
NTI191829.kind = 14;
NTI191829.base = 0;
NTI191829.flags = 3;
for (TMP781 = 0; TMP781 < 2; TMP781++) {
TMP723[TMP781+512].kind = 1;
TMP723[TMP781+512].offset = TMP781;
TMP723[TMP781+512].name = TMP780[TMP781];
TMP779[TMP781] = &TMP723[TMP781+512];
}
TMP723[514].len = 2; TMP723[514].kind = 2; TMP723[514].sons = &TMP779[0];
NTI191829.node = &TMP723[514];
TMP723[511].kind = 1;
TMP723[511].offset = offsetof(Tlib191831, kind);
TMP723[511].typ = (&NTI191829);
TMP723[511].name = "kind";
TMP778[1] = &TMP723[515];
TMP723[515].kind = 1;
TMP723[515].offset = offsetof(Tlib191831, generated);
TMP723[515].typ = (&NTI138);
TMP723[515].name = "generated";
TMP778[2] = &TMP723[516];
TMP723[516].kind = 1;
TMP723[516].offset = offsetof(Tlib191831, isoverriden);
TMP723[516].typ = (&NTI138);
TMP723[516].name = "isOverriden";
TMP778[3] = &TMP723[517];
TMP723[517].kind = 1;
TMP723[517].offset = offsetof(Tlib191831, name);
TMP723[517].typ = (&NTI162007);
TMP723[517].name = "name";
TMP778[4] = &TMP723[518];
TMP723[518].kind = 1;
TMP723[518].offset = offsetof(Tlib191831, path);
TMP723[518].typ = (&NTI191805);
TMP723[518].name = "path";
TMP723[510].len = 5; TMP723[510].kind = 2; TMP723[510].sons = &TMP778[0];
NTI191831.node = &TMP723[510];
NTI191841.size = sizeof(Tlib191831*);
NTI191841.kind = 22;
NTI191841.base = (&NTI191831);
NTI191841.marker = TMP782;
TMP723[509].kind = 1;
TMP723[509].offset = offsetof(Tsym191843, annex);
TMP723[509].typ = (&NTI191841);
TMP723[509].name = "annex";
TMP741[13] = &TMP723[519];
TMP723[519].kind = 1;
TMP723[519].offset = offsetof(Tsym191843, constraint);
TMP723[519].typ = (&NTI191805);
TMP723[519].name = "constraint";
TMP723[113].len = 14; TMP723[113].kind = 2; TMP723[113].sons = &TMP741[0];
NTI191843.node = &TMP723[113];
NTI191811.size = sizeof(Tsym191843*);
NTI191811.kind = 22;
NTI191811.base = (&NTI191843);
NTI191811.flags = 2;
NTI191811.marker = TMP783;
TMP723[112].kind = 1;
TMP723[112].offset = offsetof(Ttype191849, owner);
TMP723[112].typ = (&NTI191811);
TMP723[112].name = "owner";
TMP730[6] = &TMP723[520];
TMP723[520].kind = 1;
TMP723[520].offset = offsetof(Ttype191849, sym);
TMP723[520].typ = (&NTI191811);
TMP723[520].name = "sym";
TMP730[7] = &TMP723[521];
TMP723[521].kind = 1;
TMP723[521].offset = offsetof(Ttype191849, destructor);
TMP723[521].typ = (&NTI191811);
TMP723[521].name = "destructor";
TMP730[8] = &TMP723[522];
TMP723[522].kind = 1;
TMP723[522].offset = offsetof(Ttype191849, deepcopy);
TMP723[522].typ = (&NTI191811);
TMP723[522].name = "deepCopy";
TMP730[9] = &TMP723[523];
TMP723[523].kind = 1;
TMP723[523].offset = offsetof(Ttype191849, assignment);
TMP723[523].typ = (&NTI191811);
TMP723[523].name = "assignment";
TMP730[10] = &TMP723[524];
TMP723[524].kind = 1;
TMP723[524].offset = offsetof(Ttype191849, size);
TMP723[524].typ = (&NTI5710);
TMP723[524].name = "size";
TMP730[11] = &TMP723[525];
TMP723[525].kind = 1;
TMP723[525].offset = offsetof(Ttype191849, align);
TMP723[525].typ = (&NTI112);
TMP723[525].name = "align";
TMP730[12] = &TMP723[526];
TMP723[526].kind = 1;
TMP723[526].offset = offsetof(Ttype191849, locklevel);
TMP723[526].typ = (&NTI112);
TMP723[526].name = "lockLevel";
TMP730[13] = &TMP723[527];
TMP723[527].kind = 1;
TMP723[527].offset = offsetof(Ttype191849, loc);
TMP723[527].typ = (&NTI191827);
TMP723[527].name = "loc";
TMP723[2].len = 14; TMP723[2].kind = 2; TMP723[2].sons = &TMP730[0];
NTI191849.node = &TMP723[2];
NTI191809.size = sizeof(Ttype191849*);
NTI191809.kind = 22;
NTI191809.base = (&NTI191849);
NTI191809.flags = 2;
NTI191809.marker = TMP784;
TMP723[1].kind = 1;
TMP723[1].offset = offsetof(Tnode191813, typ);
TMP723[1].typ = (&NTI191809);
TMP723[1].name = "typ";
TMP729[1] = &TMP723[528];
TMP723[528].kind = 1;
TMP723[528].offset = offsetof(Tnode191813, info);
TMP723[528].typ = (&NTI164338);
TMP723[528].name = "info";
TMP729[2] = &TMP723[529];
NTI191433.size = sizeof(NU8);
NTI191433.kind = 14;
NTI191433.base = 0;
NTI191433.flags = 3;
for (TMP787 = 0; TMP787 < 14; TMP787++) {
TMP723[TMP787+530].kind = 1;
TMP723[TMP787+530].offset = TMP787;
TMP723[TMP787+530].name = TMP786[TMP787];
TMP785[TMP787] = &TMP723[TMP787+530];
}
TMP723[544].len = 14; TMP723[544].kind = 2; TMP723[544].sons = &TMP785[0];
NTI191433.node = &TMP723[544];
NTI191435.size = sizeof(NU16);
NTI191435.kind = 19;
NTI191435.base = (&NTI191433);
NTI191435.flags = 3;
TMP723[545].len = 0; TMP723[545].kind = 0;
NTI191435.node = &TMP723[545];
TMP723[529].kind = 1;
TMP723[529].offset = offsetof(Tnode191813, flags);
TMP723[529].typ = (&NTI191435);
TMP723[529].name = "flags";
TMP729[3] = &TMP723[546];
NTI191029.size = sizeof(NU8);
NTI191029.kind = 14;
NTI191029.base = 0;
NTI191029.flags = 3;
for (TMP790 = 0; TMP790 < 159; TMP790++) {
TMP723[TMP790+547].kind = 1;
TMP723[TMP790+547].offset = TMP790;
TMP723[TMP790+547].name = TMP789[TMP790];
TMP788[TMP790] = &TMP723[TMP790+547];
}
TMP723[706].len = 159; TMP723[706].kind = 2; TMP723[706].sons = &TMP788[0];
NTI191029.node = &TMP723[706];
TMP723[546].kind = 3;
TMP723[546].offset = offsetof(Tnode191813, kind);
TMP723[546].typ = (&NTI191029);
TMP723[546].name = "kind";
TMP723[546].sons = &NimDT_191813_kind[0];
TMP723[546].len = 159;
TMP723[707].kind = 1;
TMP723[707].offset = offsetof(Tnode191813, kindU.S1.intval);
TMP723[707].typ = (&NTI5710);
TMP723[707].name = "intVal";
NimDT_191813_kind[5] = &TMP723[707];
NimDT_191813_kind[6] = &TMP723[707];
NimDT_191813_kind[7] = &TMP723[707];
NimDT_191813_kind[8] = &TMP723[707];
NimDT_191813_kind[9] = &TMP723[707];
NimDT_191813_kind[10] = &TMP723[707];
NimDT_191813_kind[11] = &TMP723[707];
NimDT_191813_kind[12] = &TMP723[707];
NimDT_191813_kind[13] = &TMP723[707];
NimDT_191813_kind[14] = &TMP723[707];
NimDT_191813_kind[15] = &TMP723[707];
TMP723[708].kind = 1;
TMP723[708].offset = offsetof(Tnode191813, kindU.S2.floatval);
TMP723[708].typ = (&NTI5712);
TMP723[708].name = "floatVal";
NimDT_191813_kind[16] = &TMP723[708];
NimDT_191813_kind[17] = &TMP723[708];
NimDT_191813_kind[18] = &TMP723[708];
NimDT_191813_kind[19] = &TMP723[708];
TMP723[709].kind = 1;
TMP723[709].offset = offsetof(Tnode191813, kindU.S3.strval);
TMP723[709].typ = (&NTI149);
TMP723[709].name = "strVal";
NimDT_191813_kind[20] = &TMP723[709];
NimDT_191813_kind[21] = &TMP723[709];
NimDT_191813_kind[22] = &TMP723[709];
TMP723[710].kind = 1;
TMP723[710].offset = offsetof(Tnode191813, kindU.S4.sym);
TMP723[710].typ = (&NTI191811);
TMP723[710].name = "sym";
NimDT_191813_kind[3] = &TMP723[710];
TMP723[711].kind = 1;
TMP723[711].offset = offsetof(Tnode191813, kindU.S5.ident);
TMP723[711].typ = (&NTI168019);
TMP723[711].name = "ident";
NimDT_191813_kind[2] = &TMP723[711];
TMP723[712].kind = 1;
TMP723[712].offset = offsetof(Tnode191813, kindU.S6.sons);
TMP723[712].typ = (&NTI191807);
TMP723[712].name = "sons";
NimDT_191813_kind[159] = &TMP723[712];
TMP729[4] = &TMP723[713];
TMP723[713].kind = 1;
TMP723[713].offset = offsetof(Tnode191813, comment);
TMP723[713].typ = (&NTI149);
TMP723[713].name = "comment";
TMP723[0].len = 5; TMP723[0].kind = 2; TMP723[0].sons = &TMP729[0];
NTI191813.node = &TMP723[0];
NTI191805.size = sizeof(Tnode191813*);
NTI191805.kind = 22;
NTI191805.base = (&NTI191813);
NTI191805.flags = 2;
NTI191805.marker = TMP791;
NTI191861.size = sizeof(Tidtable191861);
NTI191861.kind = 18;
NTI191861.base = 0;
TMP828[0] = &TMP723[715];
TMP723[715].kind = 1;
TMP723[715].offset = offsetof(Tidtable191861, counter);
TMP723[715].typ = (&NTI108);
TMP723[715].name = "counter";
TMP828[1] = &TMP723[716];
NTI191857.size = sizeof(Tidpair191857);
NTI191857.kind = 18;
NTI191857.base = 0;
TMP829[0] = &TMP723[718];
TMP723[718].kind = 1;
TMP723[718].offset = offsetof(Tidpair191857, key);
TMP723[718].typ = (&NTI168017);
TMP723[718].name = "key";
TMP829[1] = &TMP723[719];
TMP723[719].kind = 1;
TMP723[719].offset = offsetof(Tidpair191857, val);
TMP723[719].typ = (&NTI3413);
TMP723[719].name = "val";
TMP723[717].len = 2; TMP723[717].kind = 2; TMP723[717].sons = &TMP829[0];
NTI191857.node = &TMP723[717];
NTI191859.size = sizeof(Tidpairseq191859*);
NTI191859.kind = 24;
NTI191859.base = (&NTI191857);
NTI191859.marker = TMP832;
TMP723[716].kind = 1;
TMP723[716].offset = offsetof(Tidtable191861, data);
TMP723[716].typ = (&NTI191859);
TMP723[716].name = "data";
TMP723[714].len = 2; TMP723[714].kind = 2; TMP723[714].sons = &TMP828[0];
NTI191861.node = &TMP723[714];
NTI191873.size = sizeof(Tnodetable191873);
NTI191873.kind = 18;
NTI191873.base = 0;
NTI191873.flags = 2;
TMP1055[0] = &TMP723[721];
TMP723[721].kind = 1;
TMP723[721].offset = offsetof(Tnodetable191873, counter);
TMP723[721].typ = (&NTI108);
TMP723[721].name = "counter";
TMP1055[1] = &TMP723[722];
NTI191869.size = sizeof(Tnodepair191869);
NTI191869.kind = 18;
NTI191869.base = 0;
NTI191869.flags = 2;
TMP1056[0] = &TMP723[724];
TMP723[724].kind = 1;
TMP723[724].offset = offsetof(Tnodepair191869, h);
TMP723[724].typ = (&NTI131021);
TMP723[724].name = "h";
TMP1056[1] = &TMP723[725];
TMP723[725].kind = 1;
TMP723[725].offset = offsetof(Tnodepair191869, key);
TMP723[725].typ = (&NTI191805);
TMP723[725].name = "key";
TMP1056[2] = &TMP723[726];
TMP723[726].kind = 1;
TMP723[726].offset = offsetof(Tnodepair191869, val);
TMP723[726].typ = (&NTI108);
TMP723[726].name = "val";
TMP723[723].len = 3; TMP723[723].kind = 2; TMP723[723].sons = &TMP1056[0];
NTI191869.node = &TMP723[723];
NTI191871.size = sizeof(Tnodepairseq191871*);
NTI191871.kind = 24;
NTI191871.base = (&NTI191869);
NTI191871.flags = 2;
NTI191871.marker = TMP1057;
TMP723[722].kind = 1;
TMP723[722].offset = offsetof(Tnodetable191873, data);
TMP723[722].typ = (&NTI191871);
TMP723[722].name = "data";
TMP723[720].len = 2; TMP723[720].kind = 2; TMP723[720].sons = &TMP1055[0];
NTI191873.node = &TMP723[720];
NTI385221.size = sizeof(Tnode191813**);
NTI385221.kind = 21;
NTI385221.base = (&NTI191805);
NTI385221.flags = 3;
NTI191867.size = sizeof(Tidnodetable191867);
NTI191867.kind = 18;
NTI191867.base = 0;
TMP3254[0] = &TMP723[728];
TMP723[728].kind = 1;
TMP723[728].offset = offsetof(Tidnodetable191867, counter);
TMP723[728].typ = (&NTI108);
TMP723[728].name = "counter";
TMP3254[1] = &TMP723[729];
NTI191863.size = sizeof(Tidnodepair191863);
NTI191863.kind = 18;
NTI191863.base = 0;
TMP3255[0] = &TMP723[731];
TMP723[731].kind = 1;
TMP723[731].offset = offsetof(Tidnodepair191863, key);
TMP723[731].typ = (&NTI168017);
TMP723[731].name = "key";
TMP3255[1] = &TMP723[732];
TMP723[732].kind = 1;
TMP723[732].offset = offsetof(Tidnodepair191863, val);
TMP723[732].typ = (&NTI191805);
TMP723[732].name = "val";
TMP723[730].len = 2; TMP723[730].kind = 2; TMP723[730].sons = &TMP3255[0];
NTI191863.node = &TMP723[730];
NTI191865.size = sizeof(Tidnodepairseq191865*);
NTI191865.kind = 24;
NTI191865.base = (&NTI191863);
NTI191865.marker = TMP3256;
TMP723[729].kind = 1;
TMP723[729].offset = offsetof(Tidnodetable191867, data);
TMP723[729].typ = (&NTI191865);
TMP723[729].name = "data";
TMP723[727].len = 2; TMP723[727].kind = 2; TMP723[727].sons = &TMP3254[0];
NTI191867.node = &TMP723[727];
}

