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

#include <string.h>
typedef struct tnode225816 tnode225816;
typedef struct tcell44935 tcell44935;
typedef struct TNimType TNimType;
typedef struct tcellseq44951 tcellseq44951;
typedef struct tgcheap47016 tgcheap47016;
typedef struct tcellset44947 tcellset44947;
typedef struct tpagedesc44943 tpagedesc44943;
typedef struct tmemregion27210 tmemregion27210;
typedef struct tsmallchunk26440 tsmallchunk26440;
typedef struct tllchunk27204 tllchunk27204;
typedef struct tbigchunk26442 tbigchunk26442;
typedef struct tintset26417 tintset26417;
typedef struct ttrunk26413 ttrunk26413;
typedef struct tavlnode27208 tavlnode27208;
typedef struct tgcstat47014 tgcstat47014;
typedef struct tsym225846 tsym225846;
typedef struct tident200021 tident200021;
typedef struct NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
typedef struct tlineinfo195539 tlineinfo195539;
typedef struct ttype225852 ttype225852;
typedef struct tnodeseq225810 tnodeseq225810;
typedef struct TNimNode TNimNode;
typedef struct tidobj200015 tidobj200015;
typedef struct TNimObject TNimObject;
typedef struct ttypeseq225848 ttypeseq225848;
typedef struct tloc225830 tloc225830;
typedef struct trope177009 trope177009;
typedef struct tscope225840 tscope225840;
typedef struct TY225947 TY225947;
typedef struct tinstantiation225836 tinstantiation225836;
typedef struct tstrtable225820 tstrtable225820;
typedef struct tsymseq225818 tsymseq225818;
typedef struct tlib225834 tlib225834;
typedef struct TY225936 TY225936;
typedef struct tlistentry127022 tlistentry127022;
typedef struct tidtable225864 tidtable225864;
typedef struct tidpairseq225862 tidpairseq225862;
typedef struct tidpair225860 tidpair225860;
typedef struct tnodetable225876 tnodetable225876;
typedef struct tnodepairseq225874 tnodepairseq225874;
typedef struct tnodepair225872 tnodepair225872;
typedef struct tidnodetable225870 tidnodetable225870;
typedef struct tidnodepairseq225868 tidnodepairseq225868;
typedef struct tidnodepair225866 tidnodepair225866;
typedef struct TY84745 TY84745;
typedef struct tbasechunk26438 tbasechunk26438;
typedef struct tfreecell26430 tfreecell26430;
struct  tcell44935  {
NI Refcount;
TNimType* Typ;
};
struct  tcellseq44951  {
NI Len;
NI Cap;
tcell44935** D;
};
struct  tcellset44947  {
NI Counter;
NI Max;
tpagedesc44943* Head;
tpagedesc44943** Data;
};
typedef tsmallchunk26440* TY27222[512];
typedef ttrunk26413* ttrunkbuckets26415[256];
struct  tintset26417  {
ttrunkbuckets26415 Data;
};
struct  tmemregion27210  {
NI Minlargeobj;
NI Maxlargeobj;
TY27222 Freesmallchunks;
tllchunk27204* Llmem;
NI Currmem;
NI Maxmem;
NI Freemem;
NI Lastsize;
tbigchunk26442* Freechunkslist;
tintset26417 Chunkstarts;
tavlnode27208* Root;
tavlnode27208* Deleted;
tavlnode27208* Last;
tavlnode27208* Freeavlnodes;
};
struct  tgcstat47014  {
NI Stackscans;
NI Cyclecollections;
NI Maxthreshold;
NI Maxstacksize;
NI Maxstackcells;
NI Cycletablesize;
NI64 Maxpause;
};
struct  tgcheap47016  {
void* Stackbottom;
NI Cyclethreshold;
tcellseq44951 Zct;
tcellseq44951 Decstack;
tcellset44947 Cycleroots;
tcellseq44951 Tempstack;
NI Recgclock;
tmemregion27210 Region;
tgcstat47014 Stat;
};
struct  TGenericSeq  {
NI len;
NI reserved;
};
struct  NimStringDesc  {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
struct  tlineinfo195539  {
NI16 Line;
NI16 Col;
NI32 Fileindex;
};
struct  tnode225816  {
ttype225852* Typ;
tlineinfo195539 Info;
NU16 Flags;
NU8 Kind;
union {
struct {NI64 Intval;
} S1;
struct {NF Floatval;
} S2;
struct {NimStringDesc* Strval;
} S3;
struct {tsym225846* Sym;
} S4;
struct {tident200021* Ident;
} S5;
struct {tnodeseq225810* Sons;
} S6;
} kindU;
NimStringDesc* Comment;
};
typedef N_NIMCALL_PTR(void, TY3089) (void* p, NI op);
typedef N_NIMCALL_PTR(void*, TY3094) (void* p);
struct  TNimType  {
NI size;
NU8 kind;
NU8 flags;
TNimType* base;
TNimNode* node;
void* finalizer;
TY3089 marker;
TY3094 deepcopy;
};
struct  TNimNode  {
NU8 kind;
NI offset;
TNimType* typ;
NCSTRING name;
NI len;
TNimNode** sons;
};
struct  TNimObject  {
TNimType* m_type;
};
struct  tidobj200015  {
  TNimObject Sup;
NI Id;
};
struct  tloc225830  {
NU8 K;
NU8 S;
NU8 Flags;
ttype225852* T;
trope177009* R;
trope177009* Heaproot;
};
struct  ttype225852  {
  tidobj200015 Sup;
NU8 Kind;
NU8 Callconv;
NU32 Flags;
ttypeseq225848* Sons;
tnode225816* N;
tsym225846* Owner;
tsym225846* Sym;
tsym225846* Destructor;
tsym225846* Deepcopy;
NI64 Size;
NI16 Align;
NI16 Locklevel;
tloc225830 Loc;
};
struct  tstrtable225820  {
NI Counter;
tsymseq225818* Data;
};
struct  tsym225846  {
  tidobj200015 Sup;
NU8 Kind;
union {
struct {ttypeseq225848* Typeinstcache;
tscope225840* Typscope;
} S1;
struct {TY225947* Procinstcache;
tscope225840* Scope;
} S2;
struct {TY225947* Usedgenerics;
tstrtable225820 Tab;
} S3;
struct {tsym225846* Guard;
} S4;
} kindU;
NU16 Magic;
ttype225852* Typ;
tident200021* Name;
tlineinfo195539 Info;
tsym225846* Owner;
NU32 Flags;
tnode225816* Ast;
NU32 Options;
NI Position;
NI Offset;
tloc225830 Loc;
tlib225834* Annex;
tnode225816* Constraint;
};
struct  tscope225840  {
NI Depthlevel;
tstrtable225820 Symbols;
tnodeseq225810* Usingsyms;
tscope225840* Parent;
};
struct  tinstantiation225836  {
tsym225846* Sym;
ttypeseq225848* Concretetypes;
TY225936* Usedby;
};
struct  tlistentry127022  {
  TNimObject Sup;
tlistentry127022* Prev;
tlistentry127022* Next;
};
struct  tlib225834  {
  tlistentry127022 Sup;
NU8 Kind;
NIM_BOOL Generated;
NIM_BOOL Isoverriden;
trope177009* Name;
tnode225816* Path;
};
struct  tidpair225860  {
tidobj200015* Key;
TNimObject* Val;
};
struct  tidtable225864  {
NI Counter;
tidpairseq225862* Data;
};
struct  tnodepair225872  {
NI H;
tnode225816* Key;
NI Val;
};
struct  tnodetable225876  {
NI Counter;
tnodepairseq225874* Data;
};
typedef tnode225816* TY228474[7];
typedef NimStringDesc* TY225020[10];
typedef tnode225816* TY246892[1];
struct  tidnodepair225866  {
tidobj200015* Key;
tnode225816* Val;
};
struct  tidnodetable225870  {
NI Counter;
tidnodepairseq225868* Data;
};
struct TY84745 {
NimStringDesc* Field0;
NI Field1;
};
typedef NU8 TY517462[20];
typedef NI TY26420[16];
struct  tpagedesc44943  {
tpagedesc44943* Next;
NI Key;
TY26420 Bits;
};
struct  tbasechunk26438  {
NI Prevsize;
NI Size;
NIM_BOOL Used;
};
struct  tsmallchunk26440  {
  tbasechunk26438 Sup;
tsmallchunk26440* Next;
tsmallchunk26440* Prev;
tfreecell26430* Freelist;
NI Free;
NI Acc;
NF Data;
};
struct  tllchunk27204  {
NI Size;
NI Acc;
tllchunk27204* Next;
};
struct  tbigchunk26442  {
  tbasechunk26438 Sup;
tbigchunk26442* Next;
tbigchunk26442* Prev;
NI Align;
NF Data;
};
struct  ttrunk26413  {
ttrunk26413* Next;
NI Key;
TY26420 Bits;
};
typedef tavlnode27208* TY27214[2];
struct  tavlnode27208  {
TY27214 Link;
NI Key;
NI Upperbound;
NI Level;
};
struct  tident200021  {
  tidobj200015 Sup;
NimStringDesc* S;
tident200021* Next;
NI H;
};
struct  trope177009  {
  TNimObject Sup;
trope177009* Left;
trope177009* Right;
NI Length;
NimStringDesc* Data;
};
struct  tfreecell26430  {
tfreecell26430* Next;
NI Zerofield;
};
struct tnodeseq225810 {
  TGenericSeq Sup;
  tnode225816* data[SEQ_DECL_SIZE];
};
struct ttypeseq225848 {
  TGenericSeq Sup;
  ttype225852* data[SEQ_DECL_SIZE];
};
struct TY225947 {
  TGenericSeq Sup;
  tinstantiation225836* data[SEQ_DECL_SIZE];
};
struct tsymseq225818 {
  TGenericSeq Sup;
  tsym225846* data[SEQ_DECL_SIZE];
};
struct TY225936 {
  TGenericSeq Sup;
  NI32 data[SEQ_DECL_SIZE];
};
struct tidpairseq225862 {
  TGenericSeq Sup;
  tidpair225860 data[SEQ_DECL_SIZE];
};
struct tnodepairseq225874 {
  TGenericSeq Sup;
  tnodepair225872 data[SEQ_DECL_SIZE];
};
struct tidnodepairseq225868 {
  TGenericSeq Sup;
  tidnodepair225866 data[SEQ_DECL_SIZE];
};
static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src);
static N_INLINE(tcell44935*, usrtocell_48646)(void* usr);
static N_INLINE(void, rtladdzct_50204)(tcell44935* c);
N_NOINLINE(void, addzct_48617)(tcellseq44951* s, tcell44935* c);
N_NIMCALL(tident200021*, getident_200472)(NimStringDesc* identifier);
N_NIMCALL(tlineinfo195539, unknownlineinfo_196405)(void);
N_NIMCALL(tnode225816*, newnode_226090)(NU8 kind);
N_NIMCALL(void, nimGCvisit)(void* d, NI op);
N_NIMCALL(void, TMP739)(void* p, NI op);
N_NIMCALL(void, TMP747)(void* p, NI op);
N_NIMCALL(void, TMP748)(void* p, NI op);
N_NIMCALL(void, TMP749)(void* p, NI op);
N_NIMCALL(void, TMP752)(void* p, NI op);
N_NIMCALL(void, TMP753)(void* p, NI op);
N_NIMCALL(void, TMP754)(void* p, NI op);
N_NIMCALL(void, TMP781)(void* p, NI op);
N_NIMCALL(void, TMP782)(void* p, NI op);
N_NIMCALL(void, TMP783)(void* p, NI op);
N_NIMCALL(void, TMP790)(void* p, NI op);
N_NIMCALL(void*, newObj)(TNimType* typ, NI size);
N_NIMCALL(void, TMP828)(void* p, NI op);
N_NIMCALL(void*, newSeq)(TNimType* typ, NI len);
N_NIMCALL(void, unsureAsgnRef)(void** dest, void* src);
static N_INLINE(NI, getid_224404)(void);
N_NIMCALL(void, TMP975)(void* p, NI op);
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(tnode225816*, newnodei_226138)(NU8 kind, tlineinfo195539 info);
N_NIMCALL(void, genericSeqAssign)(void* dest, void* src_79604, TNimType* mt);
N_NIMCALL(void, add_226498)(tnode225816* father, tnode225816* son);
N_NIMCALL(void, propagatetoowner_230318)(ttype225852* owner, ttype225852* elem);
N_NIMCALL(NIM_BOOL, ismetatype_226752)(ttype225852* t);
static N_INLINE(NIM_BOOL, isgcedmem_230276)(ttype225852* t);
N_NIMCALL(NimStringDesc*, copyStringRC1)(NimStringDesc* src);
N_NIMCALL(NimStringDesc*, copyString)(NimStringDesc* src);
N_NIMCALL(NimStringDesc*, nimIntToStr)(NI x);
static N_INLINE(ttype225852*, lastson_226267)(ttype225852* n);
static N_INLINE(NI, sonslen_226255)(ttype225852* n);
static N_INLINE(void, asgnRef)(void** dest, void* src);
static N_INLINE(void, incref_51025)(tcell44935* c);
static N_INLINE(NIM_BOOL, canbecycleroot_48667)(tcell44935* c);
static N_INLINE(void, rtladdcycleroot_49429)(tcell44935* c);
N_NOINLINE(void, incl_45671)(tcellset44947* s, tcell44935* cell);
static N_INLINE(void, decref_50604)(tcell44935* c);
N_NIMCALL(void, mergeloc_228607)(tloc225830* a, tloc225830 b);
N_NIMCALL(void, newsons_226280)(ttype225852* father, NI length);
N_NIMCALL(TGenericSeq*, setLengthSeq)(TGenericSeq* seq, NI elemsize, NI newlen);
N_NIMCALL(ttype225852*, newtype_226083)(NU8 kind, tsym225846* owner);
N_NIMCALL(void, assigntype_226210)(ttype225852* dest, ttype225852* src);
N_NIMCALL(tsym225846*, newsym_226074)(NU8 symkind, tident200021* name, tsym225846* owner, tlineinfo195539 info);
N_NIMCALL(void, copystrtable_226217)(tstrtable225820* dest, tstrtable225820 src);
N_NIMCALL(void, genericAssign)(void* dest, void* src, TNimType* mt);
N_NIMCALL(void, initstrtable_226153)(tstrtable225820* x);
static N_INLINE(NI, sonslen_226249)(tnode225816* n);
N_NIMCALL(tnode225816*, copytree_226329)(tnode225816* src);
N_NIMCALL(tnode225816*, newintnode_226096)(NU8 kind, NI64 intval);
static N_INLINE(tnode225816*, HEX5BHEX5D_226698)(tnode225816* n, NI i);
N_NIMCALL(void, internalerror_197987)(tlineinfo195539 info, NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, nimCharToStr)(NIM_CHAR x);
N_NIMCALL(void, TMP3130)(void* p, NI op);
N_NIMCALL(void, internalerror_198006)(NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, HEX24_198126)(TY84745 x_198130);
N_NIMCALL(NIM_BOOL, containsnode_232212)(tnode225816* n, TY517462 kinds);
N_NIMCALL(NIM_BOOL, hassubnodewith_226308)(tnode225816* n, NU8 kind);
N_NIMCALL(void, addson_226287)(tnode225816* father, tnode225816* son);
STRING_LITERAL(TMP727, "*", 1);
TNimNode* NimDT_225846_kind[27];
TNimNode* NimDT_225816_kind[159];
STRING_LITERAL(TMP2086, "", 0);
STRING_LITERAL(TMP2087, "stdcall", 7);
STRING_LITERAL(TMP2088, "cdecl", 5);
STRING_LITERAL(TMP2089, "safecall", 8);
STRING_LITERAL(TMP2090, "syscall", 7);
STRING_LITERAL(TMP2091, "inline", 6);
STRING_LITERAL(TMP2092, "noinline", 8);
STRING_LITERAL(TMP2093, "fastcall", 8);
STRING_LITERAL(TMP2094, "closure", 7);
STRING_LITERAL(TMP2095, "noconv", 6);
NIM_CONST TY225020 callingconvtostr_225019 = {((NimStringDesc*) &TMP2086),
((NimStringDesc*) &TMP2087),
((NimStringDesc*) &TMP2088),
((NimStringDesc*) &TMP2089),
((NimStringDesc*) &TMP2090),
((NimStringDesc*) &TMP2091),
((NimStringDesc*) &TMP2092),
((NimStringDesc*) &TMP2093),
((NimStringDesc*) &TMP2094),
((NimStringDesc*) &TMP2095)}
;
STRING_LITERAL(TMP2099, "<unspecified>", 13);
STRING_LITERAL(TMP2100, "<unknown>", 9);
STRING_LITERAL(TMP3105, "getInt", 6);
STRING_LITERAL(TMP3106, "getFloat", 8);
STRING_LITERAL(TMP3107, "getStr", 6);
STRING_LITERAL(TMP3110, "getStrOrChar", 12);
STRING_LITERAL(TMP3174, "compiler/ast.nim", 16);
NIM_CONST TY84745 TMP3173 = {((NimStringDesc*) &TMP3174),
1533}
;
tnode225816* emptynode_226738;
extern tgcheap47016 gch_47044;
tsym225846* anyglobal_226745;
tnode225816* emptyparams_228419;
TNimType NTI225816; /* TNode */
extern TNimType NTI200015; /* TIdObj */
TNimType NTI225852; /* TType */
TNimType NTI225258; /* TTypeKind */
TNimType NTI225005; /* TCallingConvention */
TNimType NTI225441; /* TTypeFlag */
TNimType NTI225443; /* TTypeFlags */
TNimType NTI225848; /* TTypeSeq */
TNimType NTI225846; /* TSym */
TNimType NTI225445; /* TSymKind */
TNimType NTI225840; /* TScope */
extern TNimType NTI108; /* int */
TNimType NTI225820; /* TStrTable */
TNimType NTI225818; /* TSymSeq */
TNimType NTI225810; /* TNodeSeq */
TNimType NTI225842; /* PScope */
TNimType NTI225836; /* TInstantiation */
extern TNimType NTI114; /* int32 */
TNimType NTI225936; /* seq[int32] */
TNimType NTI225838; /* PInstantiation */
TNimType NTI225947; /* seq[PInstantiation] */
TNimType NTI225532; /* TMagic */
extern TNimType NTI200019; /* PIdent */
extern TNimType NTI195539; /* TLineInfo */
TNimType NTI225194; /* TSymFlag */
TNimType NTI225196; /* TSymFlags */
extern TNimType NTI169016; /* TOptions */
TNimType NTI225830; /* TLoc */
TNimType NTI225822; /* TLocKind */
TNimType NTI225826; /* TStorageLoc */
TNimType NTI225824; /* TLocFlag */
TNimType NTI225828; /* TLocFlags */
extern TNimType NTI177007; /* PRope */
extern TNimType NTI127022; /* TListEntry */
TNimType NTI225834; /* TLib */
TNimType NTI225832; /* TLibKind */
extern TNimType NTI138; /* bool */
TNimType NTI225844; /* PLib */
TNimType NTI225814; /* PSym */
extern TNimType NTI5510; /* BiggestInt */
extern TNimType NTI112; /* int16 */
TNimType NTI225812; /* PType */
TNimType NTI225437; /* TNodeFlag */
TNimType NTI225439; /* TNodeFlags */
TNimType NTI225029; /* TNodeKind */
extern TNimType NTI5512; /* BiggestFloat */
extern TNimType NTI149; /* string */
TNimType NTI225808; /* PNode */
TNimType NTI225864; /* TIdTable */
TNimType NTI225860; /* TIdPair */
extern TNimType NTI200017; /* PIdObj */
extern TNimType NTI3213; /* RootRef */
TNimType NTI225862; /* TIdPairSeq */
extern NU32 goptions_169116;
extern NI gfrontendid_224012;
TNimType NTI225876; /* TNodeTable */
TNimType NTI225872; /* TNodePair */
extern TNimType NTI128021; /* THash */
TNimType NTI225874; /* TNodePairSeq */
TNimType NTI456221; /* ptr PNode */
TNimType NTI225870; /* TIdNodeTable */
TNimType NTI225866; /* TIdNodePair */
TNimType NTI225868; /* TIdNodePairSeq */

static N_INLINE(tcell44935*, usrtocell_48646)(void* usr) {
	tcell44935* result;
	result = 0;
	result = ((tcell44935*) ((NI)((NU32)(((NI) (usr))) - (NU32)(((NI)sizeof(tcell44935))))));
	return result;
}

static N_INLINE(void, rtladdzct_50204)(tcell44935* c) {
	addzct_48617((&gch_47044.Zct), c);
}

static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src) {
	{
		tcell44935* c;
		if (!!((src == NIM_NIL))) goto LA3;
		c = usrtocell_48646(src);
		(*c).Refcount += 8;
	}
	LA3: ;
	{
		tcell44935* c;
		if (!!(((*dest) == NIM_NIL))) goto LA7;
		c = usrtocell_48646((*dest));
		{
			(*c).Refcount -= 8;
			if (!((NU32)((*c).Refcount) < (NU32)(8))) goto LA11;
			rtladdzct_50204(c);
		}
		LA11: ;
	}
	LA7: ;
	(*dest) = src;
}
N_NIMCALL(void, TMP739)(void* p, NI op) {
	ttypeseq225848* a;
	NI LOC1;
	a = (ttypeseq225848*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP747)(void* p, NI op) {
	tsymseq225818* a;
	NI LOC1;
	a = (tsymseq225818*)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) {
	tnodeseq225810* a;
	NI LOC1;
	a = (tnodeseq225810*)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) {
	tscope225840* a;
	a = (tscope225840*)p;
	nimGCvisit((void*)(*a).Symbols.Data, op);
	nimGCvisit((void*)(*a).Usingsyms, op);
	nimGCvisit((void*)(*a).Parent, op);
}
N_NIMCALL(void, TMP752)(void* p, NI op) {
	TY225936* a;
	NI LOC1;
	a = (TY225936*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	}
}
N_NIMCALL(void, TMP753)(void* p, NI op) {
	tinstantiation225836* a;
	a = (tinstantiation225836*)p;
	nimGCvisit((void*)(*a).Sym, op);
	nimGCvisit((void*)(*a).Concretetypes, op);
	nimGCvisit((void*)(*a).Usedby, op);
}
N_NIMCALL(void, TMP754)(void* p, NI op) {
	TY225947* a;
	NI LOC1;
	a = (TY225947*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP781)(void* p, NI op) {
	tlib225834* a;
	a = (tlib225834*)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, TMP782)(void* p, NI op) {
	tsym225846* a;
	a = (tsym225846*)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.Scope, 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, TMP783)(void* p, NI op) {
	ttype225852* a;
	a = (ttype225852*)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).Loc.T, op);
	nimGCvisit((void*)(*a).Loc.R, op);
	nimGCvisit((void*)(*a).Loc.Heaproot, op);
}
N_NIMCALL(void, TMP790)(void* p, NI op) {
	tnode225816* a;
	a = (tnode225816*)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(tnode225816*, newnode_226090)(NU8 kind) {
	tnode225816* result;
	result = 0;
	result = (tnode225816*) newObj((&NTI225808), sizeof(tnode225816));
	(*result).Kind = kind;
	(*result).Info.Fileindex = ((NI32) -1);
	(*result).Info.Col = ((NI16) -1);
	(*result).Info.Line = ((NI16) -1);
	return result;
}
N_NIMCALL(void, TMP828)(void* p, NI op) {
	tidpairseq225862* a;
	NI LOC1;
	a = (tidpairseq225862*)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_226167)(tidtable225864* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) (&(*x).Data), (tidpairseq225862*) newSeq((&NTI225862), 8));
}

N_NIMCALL(void, initstrtable_226153)(tstrtable225820* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) (&(*x).Data), (tsymseq225818*) newSeq((&NTI225818), 8));
}

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

N_NIMCALL(tsym225846*, newsym_226074)(NU8 symkind, tident200021* name, tsym225846* owner, tlineinfo195539 info) {
	tsym225846* result;
	result = 0;
	result = (tsym225846*) newObj((&NTI225814), sizeof(tsym225846));
	(*result).Sup.Sup.m_type = (&NTI225846);
	asgnRefNoCycle((void**) (&(*result).Name), name);
	(*result).Kind = symkind;
	(*result).Flags = 0;
	(*result).Info = info;
	(*result).Options = goptions_169116;
	asgnRefNoCycle((void**) (&(*result).Owner), owner);
	(*result).Offset = -1;
	(*result).Sup.Id = getid_224404();
	return result;
}

N_NIMCALL(tnode225816*, newidentnode_226125)(tident200021* ident, tlineinfo195539 info) {
	tnode225816* result;
	result = 0;
	result = newnode_226090(((NU8) 2));
	asgnRefNoCycle((void**) (&(*result).kindU.S5.Ident), ident);
	(*result).Info = info;
	return result;
}
N_NIMCALL(void, TMP975)(void* p, NI op) {
	tnodepairseq225874* a;
	NI LOC1;
	a = (tnodepairseq225874*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1].Key, op);
	}
}

N_NIMCALL(tnode225816*, newnodei_226138)(NU8 kind, tlineinfo195539 info) {
	tnode225816* result;
	result = 0;
	result = (tnode225816*) newObj((&NTI225808), sizeof(tnode225816));
	(*result).Kind = kind;
	(*result).Info = info;
	return result;
}

static N_INLINE(void, nimGCunrefNoCycle)(void* p) {
	tcell44935* c;
	c = usrtocell_48646(p);
	{
		(*c).Refcount -= 8;
		if (!((NU32)((*c).Refcount) < (NU32)(8))) goto LA3;
		rtladdzct_50204(c);
	}
	LA3: ;
}

N_NIMCALL(void, addson_226287)(tnode225816* father, tnode225816* son) {
	{
		if (!(*father).kindU.S6.Sons == 0) goto LA3;
		if ((*father).kindU.S6.Sons) nimGCunrefNoCycle((*father).kindU.S6.Sons);
		(*father).kindU.S6.Sons = (tnodeseq225810*) newSeqRC1((&NTI225810), 0);
	}
	LA3: ;
	(*father).kindU.S6.Sons = (tnodeseq225810*) incrSeq(&((*father).kindU.S6.Sons)->Sup, sizeof(tnode225816*));
	asgnRefNoCycle((void**) (&(*father).kindU.S6.Sons->data[(*father).kindU.S6.Sons->Sup.len-1]), son);
}

N_NIMCALL(void, add_226498)(tnode225816* father, tnode225816* son) {
	{
		if (!(*father).kindU.S6.Sons == 0) goto LA3;
		if ((*father).kindU.S6.Sons) nimGCunrefNoCycle((*father).kindU.S6.Sons);
		(*father).kindU.S6.Sons = (tnodeseq225810*) newSeqRC1((&NTI225810), 0);
	}
	LA3: ;
	(*father).kindU.S6.Sons = (tnodeseq225810*) incrSeq(&((*father).kindU.S6.Sons)->Sup, sizeof(tnode225816*));
	asgnRefNoCycle((void**) (&(*father).kindU.S6.Sons->data[(*father).kindU.S6.Sons->Sup.len-1]), son);
}

N_NIMCALL(tnode225816*, newprocnode_228432)(NU8 kind, tlineinfo195539 info, tnode225816* body, tnode225816* params, tnode225816* name, tnode225816* pattern, tnode225816* genericparams, tnode225816* pragmas, tnode225816* exceptions) {
	tnode225816* result;
	TY228474 LOC1;
	result = 0;
	result = newnodei_226138(kind, info);
	if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
	(*result).kindU.S6.Sons = (tnodeseq225810*) newSeqRC1((&NTI225810), 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(tnode225816*, newnode_228207)(NU8 kind, tlineinfo195539 info, tnodeseq225810* sons, ttype225852* typ) {
	tnode225816* result;
	result = 0;
	result = (tnode225816*) newObj((&NTI225808), sizeof(tnode225816));
	(*result).Kind = kind;
	(*result).Info = info;
	asgnRefNoCycle((void**) (&(*result).Typ), typ);
	genericSeqAssign((&(*result).kindU.S6.Sons), sons, (&NTI225810));
	return result;
}

N_NIMCALL(tnode225816*, newnodei_228007)(NU8 kind, tlineinfo195539 info, NI children) {
	tnode225816* result;
	result = 0;
	result = (tnode225816*) newObj((&NTI225808), sizeof(tnode225816));
	(*result).Kind = kind;
	(*result).Info = info;
	{
		if (!(0 < children)) goto LA3;
		if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
		(*result).kindU.S6.Sons = (tnodeseq225810*) newSeqRC1((&NTI225810), children);
	}
	LA3: ;
	return result;
}

N_NIMCALL(tnode225816*, makestmtlist_233031)(tnode225816* n) {
	tnode225816* result;
	result = 0;
	{
		if (!((*n).Kind == ((NU8) 115))) goto LA3;
		result = n;
	}
	goto LA1;
	LA3: ;
	{
		result = newnodei_226138(((NU8) 115), (*n).Info);
		add_226498(result, n);
	}
	LA1: ;
	return result;
}

N_NIMCALL(void, addsonnilallowed_230898)(tnode225816* father, tnode225816* son) {
	{
		if (!(*father).kindU.S6.Sons == 0) goto LA3;
		if ((*father).kindU.S6.Sons) nimGCunrefNoCycle((*father).kindU.S6.Sons);
		(*father).kindU.S6.Sons = (tnodeseq225810*) newSeqRC1((&NTI225810), 0);
	}
	LA3: ;
	(*father).kindU.S6.Sons = (tnodeseq225810*) incrSeq(&((*father).kindU.S6.Sons)->Sup, sizeof(tnode225816*));
	asgnRefNoCycle((void**) (&(*father).kindU.S6.Sons->data[(*father).kindU.S6.Sons->Sup.len-1]), son);
}

N_NIMCALL(NIM_BOOL, ismetatype_226752)(ttype225852* 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_230276)(ttype225852* 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_230318)(ttype225852* owner, ttype225852* elem) {
	(*owner).Flags = ((*owner).Flags | ((*elem).Flags & 786432));
	{
		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)))) 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))) goto LA18;
		}
		goto LA16;
		LA18: ;
		{
			(*owner).Flags |= ((NI32)1)<<((((NU8) 17))%(sizeof(NI32)*8));
		}
		LA16: ;
	}
	LA14: ;
	{
		if (!(((*elem).Flags &(1<<((((NU8) 15))&31)))!=0)) goto LA23;
		(*owner).Flags |= ((NI32)1)<<((((NU8) 18))%(sizeof(NI32)*8));
	}
	LA23: ;
	{
		NIM_BOOL LOC27;
		LOC27 = 0;
		LOC27 = ismetatype_226752(elem);
		if (!LOC27) goto LA28;
		(*owner).Flags |= ((NI32)1)<<((((NU8) 19))%(sizeof(NI32)*8));
	}
	LA28: ;
	{
		if (!!(((*owner).Kind == ((NU8) 25)))) goto LA32;
		{
			NIM_BOOL LOC36;
			LOC36 = 0;
			LOC36 = isgcedmem_230276(elem);
			if (LOC36) goto LA37;
			LOC36 = (((*elem).Flags &(1<<((((NU8) 20))&31)))!=0);
			LA37: ;
			if (!LOC36) goto LA38;
			(*owner).Flags |= ((NI32)1)<<((((NU8) 20))%(sizeof(NI32)*8));
		}
		LA38: ;
	}
	LA32: ;
}

N_NIMCALL(void, rawaddson_230562)(ttype225852* father, ttype225852* son) {
	{
		if (!(*father).Sons == 0) goto LA3;
		if ((*father).Sons) nimGCunrefNoCycle((*father).Sons);
		(*father).Sons = (ttypeseq225848*) newSeqRC1((&NTI225848), 0);
	}
	LA3: ;
	(*father).Sons = (ttypeseq225848*) incrSeq(&((*father).Sons)->Sup, sizeof(ttype225852*));
	asgnRefNoCycle((void**) (&(*father).Sons->data[(*father).Sons->Sup.len-1]), son);
	{
		if (!!(son == 0)) goto LA7;
		propagatetoowner_230318(father, son);
	}
	LA7: ;
}

N_NIMCALL(tnode225816*, newstrnode_226118)(NU8 kind, NimStringDesc* strval) {
	tnode225816* result;
	NimStringDesc* LOC1;
	result = 0;
	result = newnode_226090(kind);
	LOC1 = 0;
	LOC1 = (*result).kindU.S3.Strval; (*result).kindU.S3.Strval = copyStringRC1(strval);
	if (LOC1) nimGCunrefNoCycle(LOC1);
	return result;
}

N_NIMCALL(NI, len_230005)(ttype225852* n) {
	NI result;
	result = 0;
	{
		if (!(*n).Sons == 0) goto LA3;
		result = 0;
	}
	goto LA1;
	LA3: ;
	{
		result = (*n).Sons->Sup.len;
	}
	LA1: ;
	return result;
}

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

static N_INLINE(NI, sonslen_226255)(ttype225852* n) {
	NI result;
	result = 0;
	{
		if (!(*n).Sons == 0) goto LA3;
		result = 0;
	}
	goto LA1;
	LA3: ;
	{
		result = (*n).Sons->Sup.len;
	}
	LA1: ;
	return result;
}

static N_INLINE(ttype225852*, lastson_226267)(ttype225852* n) {
	ttype225852* result;
	NI LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = sonslen_226255(n);
	result = (*n).Sons->data[(NI32)(LOC1 - 1)];
	return result;
}

N_NIMCALL(ttype225852*, skiptypes_230245)(ttype225852* t, NU64 kinds) {
	ttype225852* result;
	result = 0;
	result = t;
	{
		while (1) {
			if (!((kinds &(IL64(1)<<(((*result).Kind)&IL64(63))))!=0)) goto LA2;
			result = lastson_226267(result);
		} LA2: ;
	}
	return result;
}

static N_INLINE(NIM_BOOL, canbecycleroot_48667)(tcell44935* c) {
	NIM_BOOL result;
	result = 0;
	result = !((((*(*c).Typ).flags &(1<<((((NU8) 1))&7)))!=0));
	return result;
}

static N_INLINE(void, rtladdcycleroot_49429)(tcell44935* c) {
	{
		if (!!((((NI) ((NI)((*c).Refcount & 3))) == 3))) goto LA3;
		(*c).Refcount = (NI)((NI)((*c).Refcount & -4) | 3);
		incl_45671((&gch_47044.Cycleroots), c);
	}
	LA3: ;
}

static N_INLINE(void, incref_51025)(tcell44935* c) {
	(*c).Refcount = (NI)((NU32)((*c).Refcount) + (NU32)(8));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = canbecycleroot_48667(c);
		if (!LOC3) goto LA4;
		rtladdcycleroot_49429(c);
	}
	LA4: ;
}

static N_INLINE(void, decref_50604)(tcell44935* c) {
	{
		(*c).Refcount -= 8;
		if (!((NU32)((*c).Refcount) < (NU32)(8))) goto LA3;
		rtladdzct_50204(c);
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC6;
		LOC6 = 0;
		LOC6 = canbecycleroot_48667(c);
		if (!LOC6) goto LA7;
		rtladdcycleroot_49429(c);
	}
	goto LA1;
	LA7: ;
	LA1: ;
}

static N_INLINE(void, asgnRef)(void** dest, void* src) {
	{
		tcell44935* LOC5;
		if (!!((src == NIM_NIL))) goto LA3;
		LOC5 = 0;
		LOC5 = usrtocell_48646(src);
		incref_51025(LOC5);
	}
	LA3: ;
	{
		tcell44935* LOC10;
		if (!!(((*dest) == NIM_NIL))) goto LA8;
		LOC10 = 0;
		LOC10 = usrtocell_48646((*dest));
		decref_50604(LOC10);
	}
	LA8: ;
	(*dest) = src;
}

N_NIMCALL(void, mergeloc_228607)(tloc225830* a, tloc225830 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_226280)(ttype225852* father, NI length) {
	{
		if (!(*father).Sons == 0) goto LA3;
		if ((*father).Sons) nimGCunrefNoCycle((*father).Sons);
		(*father).Sons = (ttypeseq225848*) newSeqRC1((&NTI225848), length);
	}
	goto LA1;
	LA3: ;
	{
		(*father).Sons = (ttypeseq225848*) setLengthSeq(&((*father).Sons)->Sup, sizeof(ttype225852*), length);
	}
	LA1: ;
}

N_NIMCALL(void, assigntype_226210)(ttype225852* dest, ttype225852* 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);
	(*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_228607((&(*(*dest).Sym).Loc), (*(*src).Sym).Loc);
		}
		goto LA5;
		LA7: ;
		{
			asgnRefNoCycle((void**) (&(*dest).Sym), (*src).Sym);
		}
		LA5: ;
	}
	LA3: ;
	LOC14 = 0;
	LOC14 = sonslen_226255(src);
	newsons_226280(dest, LOC14);
	{
		NI i_228772;
		NI HEX3Atmp_228774;
		NI LOC16;
		NI res_228777;
		i_228772 = 0;
		HEX3Atmp_228774 = 0;
		LOC16 = 0;
		LOC16 = sonslen_226255(src);
		HEX3Atmp_228774 = (NI32)(LOC16 - 1);
		res_228777 = 0;
		{
			while (1) {
				if (!(res_228777 <= HEX3Atmp_228774)) goto LA18;
				i_228772 = res_228777;
				asgnRefNoCycle((void**) (&(*dest).Sons->data[i_228772]), (*src).Sons->data[i_228772]);
				res_228777 += 1;
			} LA18: ;
		}
	}
}

N_NIMCALL(ttype225852*, newtype_226083)(NU8 kind, tsym225846* owner) {
	ttype225852* result;
	result = 0;
	result = (ttype225852*) newObj((&NTI225812), sizeof(ttype225852));
	(*result).Sup.Sup.m_type = (&NTI225852);
	(*result).Kind = kind;
	asgnRefNoCycle((void**) (&(*result).Owner), owner);
	(*result).Size = IL64(-1);
	(*result).Align = ((NI16) 2);
	(*result).Sup.Id = getid_224404();
	(*result).Locklevel = ((NI16) -1);
	return result;
}

N_NIMCALL(tnode225816*, newintnode_226096)(NU8 kind, NI64 intval) {
	tnode225816* result;
	result = 0;
	result = newnode_226090(kind);
	(*result).kindU.S1.Intval = intval;
	return result;
}

N_NIMCALL(void, copyidtable_226241)(tidtable225864* dest, tidtable225864 src) {
	(*dest).Counter = src.Counter;
	{
		if (!src.Data == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	unsureAsgnRef((void**) (&(*dest).Data), (tidpairseq225862*) newSeq((&NTI225862), src.Data->Sup.len));
	{
		NI i_227176;
		NI HEX3Atmp_227178;
		NI res_227181;
		i_227176 = 0;
		HEX3Atmp_227178 = 0;
		HEX3Atmp_227178 = (src.Data->Sup.len-1);
		res_227181 = 0;
		{
			while (1) {
				if (!(res_227181 <= HEX3Atmp_227178)) goto LA7;
				i_227176 = res_227181;
				asgnRef((void**) (&(*dest).Data->data[i_227176].Key), src.Data->data[i_227176].Key);
				asgnRef((void**) (&(*dest).Data->data[i_227176].Val), src.Data->data[i_227176].Val);
				res_227181 += 1;
			} LA7: ;
		}
	}
	BeforeRet: ;
}

N_NIMCALL(ttype225852*, copytype_226195)(ttype225852* t, tsym225846* owner, NIM_BOOL keepid) {
	ttype225852* result;
	result = 0;
	result = newtype_226083((*t).Kind, owner);
	assigntype_226210(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(tnode225816*, copynode_226323)(tnode225816* src) {
	tnode225816* result;
	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_226090((*src).Kind);
	(*result).Info = (*src).Info;
	asgnRefNoCycle((void**) (&(*result).Typ), (*src).Typ);
	(*result).Flags = ((*src).Flags & 4878);
	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(void, copystrtable_226217)(tstrtable225820* dest, tstrtable225820 src) {
	(*dest).Counter = src.Counter;
	{
		if (!src.Data == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	(*dest).Data = (tsymseq225818*) setLengthSeq(&((*dest).Data)->Sup, sizeof(tsym225846*), src.Data->Sup.len);
	{
		NI i_227099;
		NI HEX3Atmp_227101;
		NI res_227104;
		i_227099 = 0;
		HEX3Atmp_227101 = 0;
		HEX3Atmp_227101 = (src.Data->Sup.len-1);
		res_227104 = 0;
		{
			while (1) {
				if (!(res_227104 <= HEX3Atmp_227101)) goto LA7;
				i_227099 = res_227104;
				asgnRefNoCycle((void**) (&(*dest).Data->data[i_227099]), src.Data->data[i_227099]);
				res_227104 += 1;
			} LA7: ;
		}
	}
	BeforeRet: ;
}

N_NIMCALL(tsym225846*, copysym_226203)(tsym225846* s, NIM_BOOL keepid) {
	tsym225846* result;
	result = 0;
	result = newsym_226074((*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_224404();
	}
	LA1: ;
	(*result).Flags = (*s).Flags;
	(*result).Magic = (*s).Magic;
	{
		if (!((*s).Kind == ((NU8) 6))) goto LA8;
		copystrtable_226217((&(*result).kindU.S3.Tab), (*s).kindU.S3.Tab);
	}
	LA8: ;
	(*result).Options = (*s).Options;
	(*result).Position = (*s).Position;
	genericAssign((void*)(&(*result).Loc), (void*)(&(*s).Loc), (&NTI225830));
	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(tnode225816*, newsymnode_226132)(tsym225846* sym) {
	tnode225816* result;
	result = 0;
	result = newnode_226090(((NU8) 3));
	asgnRefNoCycle((void**) (&(*result).kindU.S4.Sym), sym);
	asgnRefNoCycle((void**) (&(*result).Typ), (*sym).Typ);
	(*result).Info = (*sym).Info;
	return result;
}

N_NIMCALL(void, newsons_226273)(tnode225816* 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 = (tnodeseq225810*) newSeqRC1((&NTI225810), length);
	}
	goto LA1;
	LA3: ;
	{
		(*father).kindU.S6.Sons = (tnodeseq225810*) setLengthSeq(&((*father).kindU.S6.Sons)->Sup, sizeof(tnode225816*), length);
	}
	LA1: ;
}

N_NIMCALL(void, newstrtable_229833)(tstrtable225820* Result) {
	initstrtable_226153(Result);
}

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

N_NIMCALL(tnode225816*, copytree_226329)(tnode225816* src) {
	tnode225816* result;
	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_226090((*src).Kind);
	(*result).Info = (*src).Info;
	asgnRefNoCycle((void**) (&(*result).Typ), (*src).Typ);
	(*result).Flags = ((*src).Flags & 4878);
	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_226249(src);
		if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
		(*result).kindU.S6.Sons = (tnodeseq225810*) newSeqRC1((&NTI225810), LOC12);
		{
			NI i_231983;
			NI HEX3Atmp_232013;
			NI LOC14;
			NI res_232016;
			i_231983 = 0;
			HEX3Atmp_232013 = 0;
			LOC14 = 0;
			LOC14 = sonslen_226249(src);
			HEX3Atmp_232013 = (NI32)(LOC14 - 1);
			res_232016 = 0;
			{
				while (1) {
					if (!(res_232016 <= HEX3Atmp_232013)) goto LA16;
					i_231983 = res_232016;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.Sons->data[i_231983]), copytree_226329((*src).kindU.S6.Sons->data[i_231983]));
					res_232016 += 1;
				} LA16: ;
			}
		}
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tnode225816*, newsymnode_227755)(tsym225846* sym, tlineinfo195539 info) {
	tnode225816* result;
	result = 0;
	result = newnode_226090(((NU8) 3));
	asgnRefNoCycle((void**) (&(*result).kindU.S4.Sym), sym);
	asgnRefNoCycle((void**) (&(*result).Typ), (*sym).Typ);
	(*result).Info = info;
	return result;
}

N_NIMCALL(tnode225816*, newnodeit_226145)(NU8 kind, tlineinfo195539 info, ttype225852* typ) {
	tnode225816* result;
	result = 0;
	result = newnode_226090(kind);
	(*result).Info = info;
	asgnRefNoCycle((void**) (&(*result).Typ), typ);
	return result;
}

N_NIMCALL(tsym225846*, originatingmodule_232754)(tsym225846* s) {
	tsym225846* result;
	result = 0;
	result = (*s).Owner;
	{
		while (1) {
			if (!!(((*result).Kind == ((NU8) 6)))) goto LA2;
			result = (*result).Owner;
		} LA2: ;
	}
	return result;
}

N_NIMCALL(tnode225816*, newinttypenode_226103)(NU8 kind, NI64 intval, ttype225852* typ) {
	tnode225816* result;
	result = 0;
	result = newintnode_226096(kind, intval);
	asgnRefNoCycle((void**) (&(*result).Typ), typ);
	return result;
}

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

N_NIMCALL(NIM_BOOL, isgenericroutine_232649)(tsym225846* 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;
		tnode225816* 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_226698((*s).Ast, 2);
		LOC4 = !(((*LOC6).Kind == ((NU8) 1)));
		LA5: ;
		LOC2 = LOC4;
		LA3: ;
		result = LOC2;
	}
	break;
	default:
	{
	}
	break;
	}
	return result;
}

N_NIMCALL(void, discardsons_226358)(tnode225816* father) {
	genericSeqAssign((&(*father).kindU.S6.Sons), NIM_NIL, (&NTI225810));
}

N_NIMCALL(void, appendtomodule_226851)(tsym225846* m, tnode225816* n) {
	{
		TY246892 LOC5;
		if (!((*m).Ast == NIM_NIL)) goto LA3;
		asgnRefNoCycle((void**) (&(*m).Ast), newnode_226090(((NU8) 115)));
		if ((*(*m).Ast).kindU.S6.Sons) nimGCunrefNoCycle((*(*m).Ast).kindU.S6.Sons);
		(*(*m).Ast).kindU.S6.Sons = (tnodeseq225810*) newSeqRC1((&NTI225810), 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 = (tnodeseq225810*) incrSeq(&((*(*m).Ast).kindU.S6.Sons)->Sup, sizeof(tnode225816*));
		asgnRefNoCycle((void**) (&(*(*m).Ast).kindU.S6.Sons->data[(*(*m).Ast).kindU.S6.Sons->Sup.len-1]), n);
	}
	LA1: ;
}

N_NIMCALL(void, delson_226294)(tnode225816* father, NI idx) {
	NI length;
	{
		if (!(*father).kindU.S6.Sons == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	length = sonslen_226249(father);
	{
		NI i_231041;
		NI HEX3Atmp_231101;
		NI res_231104;
		i_231041 = 0;
		HEX3Atmp_231101 = 0;
		HEX3Atmp_231101 = (NI32)(length - 2);
		res_231104 = idx;
		{
			while (1) {
				if (!(res_231104 <= HEX3Atmp_231101)) goto LA7;
				i_231041 = res_231104;
				asgnRefNoCycle((void**) (&(*father).kindU.S6.Sons->data[i_231041]), (*father).kindU.S6.Sons->data[(NI32)(i_231041 + 1)]);
				res_231104 += 1;
			} LA7: ;
		}
	}
	(*father).kindU.S6.Sons = (tnodeseq225810*) setLengthSeq(&((*father).kindU.S6.Sons)->Sup, sizeof(tnode225816*), (NI32)(length - 1));
	BeforeRet: ;
}

N_NIMCALL(NIM_BOOL, iscallexpr_226335)(tnode225816* 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(tnode225816*, shallowcopy_231347)(tnode225816* src) {
	tnode225816* result;
	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_226090((*src).Kind);
	(*result).Info = (*src).Info;
	asgnRefNoCycle((void**) (&(*result).Typ), (*src).Typ);
	(*result).Flags = ((*src).Flags & 4878);
	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_226249(src);
		if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
		(*result).kindU.S6.Sons = (tnodeseq225810*) newSeqRC1((&NTI225810), LOC12);
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tsym225846*, linkto_226825)(tsym225846* s, ttype225852* t) {
	tsym225846* result;
	result = 0;
	asgnRefNoCycle((void**) (&(*t).Sym), s);
	asgnRefNoCycle((void**) (&(*s).Typ), t);
	result = s;
	return result;
}

N_NIMCALL(tnode225816*, newfloatnode_226111)(NU8 kind, NF floatval) {
	tnode225816* result;
	result = 0;
	result = newnode_226090(kind);
	(*result).kindU.S2.Floatval = floatval;
	return result;
}

N_NIMCALL(NI64, getint_232538)(tnode225816* a) {
	NI64 result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 6) ... ((NU8) 15):
	{
		result = (*a).kindU.S1.Intval;
	}
	break;
	default:
	{
		internalerror_197987((*a).Info, ((NimStringDesc*) &TMP3105));
		result = IL64(0);
	}
	break;
	}
	return result;
}

N_NIMCALL(NF, getfloat_232562)(tnode225816* a) {
	NF result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 16) ... ((NU8) 19):
	{
		result = (*a).kindU.S2.Floatval;
	}
	break;
	default:
	{
		internalerror_197987((*a).Info, ((NimStringDesc*) &TMP3106));
		result = 0.0;
	}
	break;
	}
	return result;
}

N_NIMCALL(NimStringDesc*, getstr_232587)(tnode225816* a) {
	NimStringDesc* result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 20) ... ((NU8) 22):
	{
		result = copyString((*a).kindU.S3.Strval);
	}
	break;
	default:
	{
		internalerror_197987((*a).Info, ((NimStringDesc*) &TMP3107));
		result = copyString(((NimStringDesc*) &TMP2086));
	}
	break;
	}
	return result;
}

N_NIMCALL(NimStringDesc*, getstrorchar_232611)(tnode225816* a) {
	NimStringDesc* result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 20) ... ((NU8) 22):
	{
		result = copyString((*a).kindU.S3.Strval);
	}
	break;
	case ((NU8) 5):
	{
		result = nimCharToStr(((NIM_CHAR) (((NI) (((NI) ((*a).kindU.S1.Intval)))))));
	}
	break;
	default:
	{
		internalerror_197987((*a).Info, ((NimStringDesc*) &TMP3110));
		result = copyString(((NimStringDesc*) &TMP2086));
	}
	break;
	}
	return result;
}
N_NIMCALL(void, TMP3130)(void* p, NI op) {
	tidnodepairseq225868* a;
	NI LOC1;
	a = (tidnodepairseq225868*)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_226181)(tidnodetable225870* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) (&(*x).Data), (tidnodepairseq225868*) newSeq((&NTI225868), 8));
}

N_NIMCALL(tsym225846*, skipgenericowner_232698)(tsym225846* s) {
	tsym225846* result;
	result = 0;
	{
		NimStringDesc* LOC5;
		if (!!(((520192 &(1<<(((*s).Kind)&31)))!=0))) goto LA3;
		LOC5 = 0;
		LOC5 = HEX24_198126(TMP3173);
		internalerror_198006(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(NIM_BOOL, containsnode_232212)(tnode225816* n, TY517462 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_232259;
			NI HEX3Atmp_232288;
			NI LOC8;
			NI res_232291;
			i_232259 = 0;
			HEX3Atmp_232288 = 0;
			LOC8 = 0;
			LOC8 = sonslen_226249(n);
			HEX3Atmp_232288 = (NI32)(LOC8 - 1);
			res_232291 = 0;
			{
				while (1) {
					if (!(res_232291 <= HEX3Atmp_232288)) goto LA10;
					i_232259 = res_232291;
					{
						NIM_BOOL LOC13;
						LOC13 = 0;
						LOC13 = ((kinds[(*n).Kind/8] &(1<<((*n).Kind%8)))!=0);
						if (LOC13) goto LA14;
						LOC13 = containsnode_232212((*n).kindU.S6.Sons->data[i_232259], kinds);
						LA14: ;
						if (!LOC13) goto LA15;
						result = NIM_TRUE;
						goto BeforeRet;
					}
					LA15: ;
					res_232291 += 1;
				} LA10: ;
			}
		}
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, hassubnodewith_226308)(tnode225816* n, NU8 kind) {
	NIM_BOOL result;
	result = 0;
	switch ((*n).Kind) {
	case ((NU8) 1) ... ((NU8) 23):
	{
		result = ((*n).Kind == kind);
	}
	break;
	default:
	{
		{
			NI i_232334;
			NI HEX3Atmp_232373;
			NI LOC4;
			NI res_232376;
			i_232334 = 0;
			HEX3Atmp_232373 = 0;
			LOC4 = 0;
			LOC4 = sonslen_226249(n);
			HEX3Atmp_232373 = (NI32)(LOC4 - 1);
			res_232376 = 0;
			{
				while (1) {
					if (!(res_232376 <= HEX3Atmp_232373)) goto LA6;
					i_232334 = res_232376;
					{
						NIM_BOOL LOC9;
						LOC9 = 0;
						LOC9 = ((*(*n).kindU.S6.Sons->data[i_232334]).Kind == kind);
						if (LOC9) goto LA10;
						LOC9 = hassubnodewith_226308((*n).kindU.S6.Sons->data[i_232334], kind);
						LA10: ;
						if (!LOC9) goto LA11;
						result = NIM_TRUE;
						goto BeforeRet;
					}
					LA11: ;
					res_232376 += 1;
				} LA6: ;
			}
		}
		result = NIM_FALSE;
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tnode225816*, withinfo_227695)(tnode225816* n, tlineinfo195539 info) {
	tnode225816* result;
	result = 0;
	(*n).Info = info;
	result = n;
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, hassonwith_226301)(tnode225816* n, NU8 kind) {
	NIM_BOOL result;
	result = 0;
	{
		NI i_232084;
		NI HEX3Atmp_232109;
		NI LOC2;
		NI res_232112;
		i_232084 = 0;
		HEX3Atmp_232109 = 0;
		LOC2 = 0;
		LOC2 = sonslen_226249(n);
		HEX3Atmp_232109 = (NI32)(LOC2 - 1);
		res_232112 = 0;
		{
			while (1) {
				if (!(res_232112 <= HEX3Atmp_232109)) goto LA4;
				i_232084 = res_232112;
				{
					if (!((*(*n).kindU.S6.Sons->data[i_232084]).Kind == kind)) goto LA7;
					result = NIM_TRUE;
					goto BeforeRet;
				}
				LA7: ;
				res_232112 += 1;
			} LA4: ;
		}
	}
	result = NIM_FALSE;
	BeforeRet: ;
	return result;
}

N_NIMCALL(tsym225846*, createmodulealias_229287)(tsym225846* s, tident200021* newident, tlineinfo195539 info) {
	tsym225846* result;
	result = 0;
	result = newsym_226074((*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), (&NTI225830));
	asgnRef((void**) (&(*result).Annex), (*s).Annex);
	return result;
}

N_NIMCALL(void, initnodetable_226188)(tnodetable225876* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) (&(*x).Data), (tnodepairseq225874*) newSeq((&NTI225874), 8));
}
NIM_EXTERNC N_NOINLINE(void, HEX00_astInit)(void) {
	tident200021* LOC1;
	tlineinfo195539 LOC2;
	asgnRefNoCycle((void**) (&emptynode_226738), newnode_226090(((NU8) 1)));
	LOC1 = 0;
	LOC1 = getident_200472(((NimStringDesc*) &TMP727));
	LOC2 = unknownlineinfo_196405();
	asgnRefNoCycle((void**) (&anyglobal_226745), newsym_226074(((NU8) 8), LOC1, NIM_NIL, LOC2));
	asgnRefNoCycle((void**) (&emptyparams_228419), newnode_226090(((NU8) 76)));
	addson_226287(emptyparams_228419, emptynode_226738);
}

NIM_EXTERNC N_NOINLINE(void, HEX00_astDatInit)(void) {
static TNimNode* TMP728[5];
static TNimNode* TMP729[13];
static TNimNode* TMP730[62];
NI TMP732;
static char* NIM_CONST TMP731[62] = {
"tyNone", 
"tyBool", 
"tyChar", 
"tyEmpty", 
"tyArrayConstr", 
"tyNil", 
"tyExpr", 
"tyStmt", 
"tyTypeDesc", 
"tyGenericInvokation", 
"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* TMP733[10];
NI TMP735;
static char* NIM_CONST TMP734[10] = {
"ccDefault", 
"ccStdCall", 
"ccCDecl", 
"ccSafeCall", 
"ccSysCall", 
"ccInline", 
"ccNoInline", 
"ccFastCall", 
"ccClosure", 
"ccNoConvention"};
static TNimNode* TMP736[28];
NI TMP738;
static char* NIM_CONST TMP737[28] = {
"tfVarargs", 
"tfNoSideEffect", 
"tfFinal", 
"tfInheritable", 
"tfAcyclic", 
"tfEnumHasHoles", 
"tfShallow", 
"tfThread", 
"tfFromGeneric", 
"tfUnresolved", 
"tfRetType", 
"tfCapturesEnv", 
"tfByCopy", 
"tfByRef", 
"tfIterator", 
"tfShared", 
"tfNotNil", 
"tfNeedsInit", 
"tfHasShared", 
"tfHasMeta", 
"tfHasGCedMem", 
"tfPacked", 
"tfHasStatic", 
"tfGenericTypeParam", 
"tfImplicitTypeParam", 
"tfWildcard", 
"tfGuarded", 
"tfBorrowDot"};
static TNimNode* TMP740[14];
static TNimNode* TMP741[26];
NI TMP743;
static char* NIM_CONST TMP742[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* TMP744[2];
static TNimNode* TMP745[4];
static TNimNode* TMP746[2];
static TNimNode* TMP750[2];
static TNimNode* TMP751[3];
static TNimNode* TMP755[2];
static TNimNode* TMP756[264];
NI TMP758;
static char* NIM_CONST TMP757[264] = {
"mNone", 
"mDefined", 
"mDefinedInScope", 
"mCompiles", 
"mLow", 
"mHigh", 
"mSizeOf", 
"mTypeTrait", 
"mIs", 
"mOf", 
"mEcho", 
"mShallowCopy", 
"mSlurp", 
"mStaticExec", 
"mParseExprToAst", 
"mParseStmtToAst", 
"mExpandToAst", 
"mQuoteAst", 
"mUnaryLt", 
"mSucc", 
"mPred", 
"mInc", 
"mDec", 
"mOrd", 
"mNew", 
"mNewFinalize", 
"mNewSeq", 
"mLengthOpenArray", 
"mLengthStr", 
"mLengthArray", 
"mLengthSeq", 
"mIncl", 
"mExcl", 
"mCard", 
"mChr", 
"mGCref", 
"mGCunref", 
"mAddI", 
"mSubI", 
"mMulI", 
"mDivI", 
"mModI", 
"mAddI64", 
"mSubI64", 
"mMulI64", 
"mDivI64", 
"mModI64", 
"mAddF64", 
"mSubF64", 
"mMulF64", 
"mDivF64", 
"mShrI", 
"mShlI", 
"mBitandI", 
"mBitorI", 
"mBitxorI", 
"mMinI", 
"mMaxI", 
"mShrI64", 
"mShlI64", 
"mBitandI64", 
"mBitorI64", 
"mBitxorI64", 
"mMinI64", 
"mMaxI64", 
"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", 
"mUnaryPlusI64", 
"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", 
"mConArrArr", 
"mConArrT", 
"mConTArr", 
"mConTT", 
"mSlice", 
"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* TMP759[32];
NI TMP761;
static char* NIM_CONST TMP760[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", 
"sfMerge", 
"sfDeadCodeElim", 
"sfBorrow", 
"sfInfixCall", 
"sfNamedParamCall", 
"sfDiscardable", 
"sfOverriden", 
"sfGenSym"};
static TNimNode* TMP765[6];
static TNimNode* TMP766[12];
NI TMP768;
static char* NIM_CONST TMP767[12] = {
"locNone", 
"locTemp", 
"locLocalVar", 
"locGlobalVar", 
"locParam", 
"locField", 
"locArrayElem", 
"locExpr", 
"locProc", 
"locData", 
"locCall", 
"locOther"};
static TNimNode* TMP769[3];
NI TMP771;
static char* NIM_CONST TMP770[3] = {
"OnUnknown", 
"OnStack", 
"OnHeap"};
static TNimNode* TMP772[8];
NI TMP774;
static char* NIM_CONST TMP773[8] = {
"lfIndirect", 
"lfParamCopy", 
"lfNoDeepCopy", 
"lfNoDecl", 
"lfDynamicLib", 
"lfExportLib", 
"lfHeader", 
"lfImportCompilerProc"};
static TNimNode* TMP777[5];
static TNimNode* TMP778[2];
NI TMP780;
static char* NIM_CONST TMP779[2] = {
"libHeader", 
"libDynamic"};
static TNimNode* TMP784[13];
NI TMP786;
static char* NIM_CONST TMP785[13] = {
"nfNone", 
"nfBase2", 
"nfBase8", 
"nfBase16", 
"nfAllConst", 
"nfTransf", 
"nfSem", 
"nfLL", 
"nfDotField", 
"nfDotSetter", 
"nfExplicitCall", 
"nfExprCall", 
"nfIsRef"};
static TNimNode* TMP787[158];
NI TMP789;
static char* NIM_CONST TMP788[158] = {
"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", 
"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* TMP824[2];
static TNimNode* TMP825[2];
static TNimNode* TMP973[2];
static TNimNode* TMP974[3];
static TNimNode* TMP3128[2];
static TNimNode* TMP3129[2];
static TNimNode TMP721[730];
NTI225816.size = sizeof(tnode225816);
NTI225816.kind = 18;
NTI225816.base = 0;
NTI225816.flags = 2;
TMP728[0] = &TMP721[1];
NTI225852.size = sizeof(ttype225852);
NTI225852.kind = 17;
NTI225852.base = (&NTI200015);
NTI225852.flags = 2;
TMP729[0] = &TMP721[3];
NTI225258.size = sizeof(NU8);
NTI225258.kind = 14;
NTI225258.base = 0;
NTI225258.flags = 3;
for (TMP732 = 0; TMP732 < 62; TMP732++) {
TMP721[TMP732+4].kind = 1;
TMP721[TMP732+4].offset = TMP732;
TMP721[TMP732+4].name = TMP731[TMP732];
TMP730[TMP732] = &TMP721[TMP732+4];
}
TMP721[66].len = 62; TMP721[66].kind = 2; TMP721[66].sons = &TMP730[0];
NTI225258.node = &TMP721[66];
TMP721[3].kind = 1;
TMP721[3].offset = offsetof(ttype225852, Kind);
TMP721[3].typ = (&NTI225258);
TMP721[3].name = "kind";
TMP729[1] = &TMP721[67];
NTI225005.size = sizeof(NU8);
NTI225005.kind = 14;
NTI225005.base = 0;
NTI225005.flags = 3;
for (TMP735 = 0; TMP735 < 10; TMP735++) {
TMP721[TMP735+68].kind = 1;
TMP721[TMP735+68].offset = TMP735;
TMP721[TMP735+68].name = TMP734[TMP735];
TMP733[TMP735] = &TMP721[TMP735+68];
}
TMP721[78].len = 10; TMP721[78].kind = 2; TMP721[78].sons = &TMP733[0];
NTI225005.node = &TMP721[78];
TMP721[67].kind = 1;
TMP721[67].offset = offsetof(ttype225852, Callconv);
TMP721[67].typ = (&NTI225005);
TMP721[67].name = "callConv";
TMP729[2] = &TMP721[79];
NTI225441.size = sizeof(NU8);
NTI225441.kind = 14;
NTI225441.base = 0;
NTI225441.flags = 3;
for (TMP738 = 0; TMP738 < 28; TMP738++) {
TMP721[TMP738+80].kind = 1;
TMP721[TMP738+80].offset = TMP738;
TMP721[TMP738+80].name = TMP737[TMP738];
TMP736[TMP738] = &TMP721[TMP738+80];
}
TMP721[108].len = 28; TMP721[108].kind = 2; TMP721[108].sons = &TMP736[0];
NTI225441.node = &TMP721[108];
NTI225443.size = sizeof(NU32);
NTI225443.kind = 19;
NTI225443.base = (&NTI225441);
NTI225443.flags = 3;
TMP721[109].len = 0; TMP721[109].kind = 0;
NTI225443.node = &TMP721[109];
TMP721[79].kind = 1;
TMP721[79].offset = offsetof(ttype225852, Flags);
TMP721[79].typ = (&NTI225443);
TMP721[79].name = "flags";
TMP729[3] = &TMP721[110];
NTI225848.size = sizeof(ttypeseq225848*);
NTI225848.kind = 24;
NTI225848.base = (&NTI225812);
NTI225848.flags = 2;
NTI225848.marker = TMP739;
TMP721[110].kind = 1;
TMP721[110].offset = offsetof(ttype225852, Sons);
TMP721[110].typ = (&NTI225848);
TMP721[110].name = "sons";
TMP729[4] = &TMP721[111];
TMP721[111].kind = 1;
TMP721[111].offset = offsetof(ttype225852, N);
TMP721[111].typ = (&NTI225808);
TMP721[111].name = "n";
TMP729[5] = &TMP721[112];
NTI225846.size = sizeof(tsym225846);
NTI225846.kind = 17;
NTI225846.base = (&NTI200015);
NTI225846.flags = 2;
TMP740[0] = &TMP721[114];
NTI225445.size = sizeof(NU8);
NTI225445.kind = 14;
NTI225445.base = 0;
NTI225445.flags = 3;
for (TMP743 = 0; TMP743 < 26; TMP743++) {
TMP721[TMP743+115].kind = 1;
TMP721[TMP743+115].offset = TMP743;
TMP721[TMP743+115].name = TMP742[TMP743];
TMP741[TMP743] = &TMP721[TMP743+115];
}
TMP721[141].len = 26; TMP721[141].kind = 2; TMP721[141].sons = &TMP741[0];
NTI225445.node = &TMP721[141];
TMP721[114].kind = 3;
TMP721[114].offset = offsetof(tsym225846, Kind);
TMP721[114].typ = (&NTI225445);
TMP721[114].name = "kind";
TMP721[114].sons = &NimDT_225846_kind[0];
TMP721[114].len = 26;
TMP744[0] = &TMP721[143];
TMP721[143].kind = 1;
TMP721[143].offset = offsetof(tsym225846, kindU.S1.Typeinstcache);
TMP721[143].typ = (&NTI225848);
TMP721[143].name = "typeInstCache";
TMP744[1] = &TMP721[144];
NTI225840.size = sizeof(tscope225840);
NTI225840.kind = 18;
NTI225840.base = 0;
TMP745[0] = &TMP721[146];
TMP721[146].kind = 1;
TMP721[146].offset = offsetof(tscope225840, Depthlevel);
TMP721[146].typ = (&NTI108);
TMP721[146].name = "depthLevel";
TMP745[1] = &TMP721[147];
NTI225820.size = sizeof(tstrtable225820);
NTI225820.kind = 18;
NTI225820.base = 0;
NTI225820.flags = 2;
TMP746[0] = &TMP721[149];
TMP721[149].kind = 1;
TMP721[149].offset = offsetof(tstrtable225820, Counter);
TMP721[149].typ = (&NTI108);
TMP721[149].name = "counter";
TMP746[1] = &TMP721[150];
NTI225818.size = sizeof(tsymseq225818*);
NTI225818.kind = 24;
NTI225818.base = (&NTI225814);
NTI225818.flags = 2;
NTI225818.marker = TMP747;
TMP721[150].kind = 1;
TMP721[150].offset = offsetof(tstrtable225820, Data);
TMP721[150].typ = (&NTI225818);
TMP721[150].name = "data";
TMP721[148].len = 2; TMP721[148].kind = 2; TMP721[148].sons = &TMP746[0];
NTI225820.node = &TMP721[148];
TMP721[147].kind = 1;
TMP721[147].offset = offsetof(tscope225840, Symbols);
TMP721[147].typ = (&NTI225820);
TMP721[147].name = "symbols";
TMP745[2] = &TMP721[151];
NTI225810.size = sizeof(tnodeseq225810*);
NTI225810.kind = 24;
NTI225810.base = (&NTI225808);
NTI225810.flags = 2;
NTI225810.marker = TMP748;
TMP721[151].kind = 1;
TMP721[151].offset = offsetof(tscope225840, Usingsyms);
TMP721[151].typ = (&NTI225810);
TMP721[151].name = "usingSyms";
TMP745[3] = &TMP721[152];
TMP721[152].kind = 1;
TMP721[152].offset = offsetof(tscope225840, Parent);
TMP721[152].typ = (&NTI225842);
TMP721[152].name = "parent";
TMP721[145].len = 4; TMP721[145].kind = 2; TMP721[145].sons = &TMP745[0];
NTI225840.node = &TMP721[145];
NTI225842.size = sizeof(tscope225840*);
NTI225842.kind = 22;
NTI225842.base = (&NTI225840);
NTI225842.marker = TMP749;
TMP721[144].kind = 1;
TMP721[144].offset = offsetof(tsym225846, kindU.S1.Typscope);
TMP721[144].typ = (&NTI225842);
TMP721[144].name = "typScope";
TMP721[142].len = 2; TMP721[142].kind = 2; TMP721[142].sons = &TMP744[0];
NimDT_225846_kind[7] = &TMP721[142];
NimDT_225846_kind[4] = &TMP721[142];
TMP750[0] = &TMP721[154];
NTI225836.size = sizeof(tinstantiation225836);
NTI225836.kind = 18;
NTI225836.base = 0;
NTI225836.flags = 2;
TMP751[0] = &TMP721[156];
TMP721[156].kind = 1;
TMP721[156].offset = offsetof(tinstantiation225836, Sym);
TMP721[156].typ = (&NTI225814);
TMP721[156].name = "sym";
TMP751[1] = &TMP721[157];
TMP721[157].kind = 1;
TMP721[157].offset = offsetof(tinstantiation225836, Concretetypes);
TMP721[157].typ = (&NTI225848);
TMP721[157].name = "concreteTypes";
TMP751[2] = &TMP721[158];
NTI225936.size = sizeof(TY225936*);
NTI225936.kind = 24;
NTI225936.base = (&NTI114);
NTI225936.flags = 2;
NTI225936.marker = TMP752;
TMP721[158].kind = 1;
TMP721[158].offset = offsetof(tinstantiation225836, Usedby);
TMP721[158].typ = (&NTI225936);
TMP721[158].name = "usedBy";
TMP721[155].len = 3; TMP721[155].kind = 2; TMP721[155].sons = &TMP751[0];
NTI225836.node = &TMP721[155];
NTI225838.size = sizeof(tinstantiation225836*);
NTI225838.kind = 22;
NTI225838.base = (&NTI225836);
NTI225838.flags = 2;
NTI225838.marker = TMP753;
NTI225947.size = sizeof(TY225947*);
NTI225947.kind = 24;
NTI225947.base = (&NTI225838);
NTI225947.flags = 2;
NTI225947.marker = TMP754;
TMP721[154].kind = 1;
TMP721[154].offset = offsetof(tsym225846, kindU.S2.Procinstcache);
TMP721[154].typ = (&NTI225947);
TMP721[154].name = "procInstCache";
TMP750[1] = &TMP721[159];
TMP721[159].kind = 1;
TMP721[159].offset = offsetof(tsym225846, kindU.S2.Scope);
TMP721[159].typ = (&NTI225842);
TMP721[159].name = "scope";
TMP721[153].len = 2; TMP721[153].kind = 2; TMP721[153].sons = &TMP750[0];
NimDT_225846_kind[12] = &TMP721[153];
NimDT_225846_kind[13] = &TMP721[153];
NimDT_225846_kind[14] = &TMP721[153];
NimDT_225846_kind[15] = &TMP721[153];
NimDT_225846_kind[16] = &TMP721[153];
NimDT_225846_kind[17] = &TMP721[153];
NimDT_225846_kind[18] = &TMP721[153];
TMP755[0] = &TMP721[161];
TMP721[161].kind = 1;
TMP721[161].offset = offsetof(tsym225846, kindU.S3.Usedgenerics);
TMP721[161].typ = (&NTI225947);
TMP721[161].name = "usedGenerics";
TMP755[1] = &TMP721[162];
TMP721[162].kind = 1;
TMP721[162].offset = offsetof(tsym225846, kindU.S3.Tab);
TMP721[162].typ = (&NTI225820);
TMP721[162].name = "tab";
TMP721[160].len = 2; TMP721[160].kind = 2; TMP721[160].sons = &TMP755[0];
NimDT_225846_kind[6] = &TMP721[160];
TMP721[163].kind = 1;
TMP721[163].offset = offsetof(tsym225846, kindU.S4.Guard);
TMP721[163].typ = (&NTI225814);
TMP721[163].name = "guard";
NimDT_225846_kind[9] = &TMP721[163];
NimDT_225846_kind[8] = &TMP721[163];
NimDT_225846_kind[19] = &TMP721[163];
NimDT_225846_kind[21] = &TMP721[163];
TMP721[164].len = 0; TMP721[164].kind = 2;
NimDT_225846_kind[26] = &TMP721[164];
TMP740[1] = &TMP721[165];
NTI225532.size = sizeof(NU16);
NTI225532.kind = 14;
NTI225532.base = 0;
NTI225532.flags = 3;
for (TMP758 = 0; TMP758 < 264; TMP758++) {
TMP721[TMP758+166].kind = 1;
TMP721[TMP758+166].offset = TMP758;
TMP721[TMP758+166].name = TMP757[TMP758];
TMP756[TMP758] = &TMP721[TMP758+166];
}
TMP721[430].len = 264; TMP721[430].kind = 2; TMP721[430].sons = &TMP756[0];
NTI225532.node = &TMP721[430];
TMP721[165].kind = 1;
TMP721[165].offset = offsetof(tsym225846, Magic);
TMP721[165].typ = (&NTI225532);
TMP721[165].name = "magic";
TMP740[2] = &TMP721[431];
TMP721[431].kind = 1;
TMP721[431].offset = offsetof(tsym225846, Typ);
TMP721[431].typ = (&NTI225812);
TMP721[431].name = "typ";
TMP740[3] = &TMP721[432];
TMP721[432].kind = 1;
TMP721[432].offset = offsetof(tsym225846, Name);
TMP721[432].typ = (&NTI200019);
TMP721[432].name = "name";
TMP740[4] = &TMP721[433];
TMP721[433].kind = 1;
TMP721[433].offset = offsetof(tsym225846, Info);
TMP721[433].typ = (&NTI195539);
TMP721[433].name = "info";
TMP740[5] = &TMP721[434];
TMP721[434].kind = 1;
TMP721[434].offset = offsetof(tsym225846, Owner);
TMP721[434].typ = (&NTI225814);
TMP721[434].name = "owner";
TMP740[6] = &TMP721[435];
NTI225194.size = sizeof(NU8);
NTI225194.kind = 14;
NTI225194.base = 0;
NTI225194.flags = 3;
for (TMP761 = 0; TMP761 < 32; TMP761++) {
TMP721[TMP761+436].kind = 1;
TMP721[TMP761+436].offset = TMP761;
TMP721[TMP761+436].name = TMP760[TMP761];
TMP759[TMP761] = &TMP721[TMP761+436];
}
TMP721[468].len = 32; TMP721[468].kind = 2; TMP721[468].sons = &TMP759[0];
NTI225194.node = &TMP721[468];
NTI225196.size = sizeof(NU32);
NTI225196.kind = 19;
NTI225196.base = (&NTI225194);
NTI225196.flags = 3;
TMP721[469].len = 0; TMP721[469].kind = 0;
NTI225196.node = &TMP721[469];
TMP721[435].kind = 1;
TMP721[435].offset = offsetof(tsym225846, Flags);
TMP721[435].typ = (&NTI225196);
TMP721[435].name = "flags";
TMP740[7] = &TMP721[470];
TMP721[470].kind = 1;
TMP721[470].offset = offsetof(tsym225846, Ast);
TMP721[470].typ = (&NTI225808);
TMP721[470].name = "ast";
TMP740[8] = &TMP721[471];
TMP721[471].kind = 1;
TMP721[471].offset = offsetof(tsym225846, Options);
TMP721[471].typ = (&NTI169016);
TMP721[471].name = "options";
TMP740[9] = &TMP721[472];
TMP721[472].kind = 1;
TMP721[472].offset = offsetof(tsym225846, Position);
TMP721[472].typ = (&NTI108);
TMP721[472].name = "position";
TMP740[10] = &TMP721[473];
TMP721[473].kind = 1;
TMP721[473].offset = offsetof(tsym225846, Offset);
TMP721[473].typ = (&NTI108);
TMP721[473].name = "offset";
TMP740[11] = &TMP721[474];
NTI225830.size = sizeof(tloc225830);
NTI225830.kind = 18;
NTI225830.base = 0;
NTI225830.flags = 2;
TMP765[0] = &TMP721[476];
NTI225822.size = sizeof(NU8);
NTI225822.kind = 14;
NTI225822.base = 0;
NTI225822.flags = 3;
for (TMP768 = 0; TMP768 < 12; TMP768++) {
TMP721[TMP768+477].kind = 1;
TMP721[TMP768+477].offset = TMP768;
TMP721[TMP768+477].name = TMP767[TMP768];
TMP766[TMP768] = &TMP721[TMP768+477];
}
TMP721[489].len = 12; TMP721[489].kind = 2; TMP721[489].sons = &TMP766[0];
NTI225822.node = &TMP721[489];
TMP721[476].kind = 1;
TMP721[476].offset = offsetof(tloc225830, K);
TMP721[476].typ = (&NTI225822);
TMP721[476].name = "k";
TMP765[1] = &TMP721[490];
NTI225826.size = sizeof(NU8);
NTI225826.kind = 14;
NTI225826.base = 0;
NTI225826.flags = 3;
for (TMP771 = 0; TMP771 < 3; TMP771++) {
TMP721[TMP771+491].kind = 1;
TMP721[TMP771+491].offset = TMP771;
TMP721[TMP771+491].name = TMP770[TMP771];
TMP769[TMP771] = &TMP721[TMP771+491];
}
TMP721[494].len = 3; TMP721[494].kind = 2; TMP721[494].sons = &TMP769[0];
NTI225826.node = &TMP721[494];
TMP721[490].kind = 1;
TMP721[490].offset = offsetof(tloc225830, S);
TMP721[490].typ = (&NTI225826);
TMP721[490].name = "s";
TMP765[2] = &TMP721[495];
NTI225824.size = sizeof(NU8);
NTI225824.kind = 14;
NTI225824.base = 0;
NTI225824.flags = 3;
for (TMP774 = 0; TMP774 < 8; TMP774++) {
TMP721[TMP774+496].kind = 1;
TMP721[TMP774+496].offset = TMP774;
TMP721[TMP774+496].name = TMP773[TMP774];
TMP772[TMP774] = &TMP721[TMP774+496];
}
TMP721[504].len = 8; TMP721[504].kind = 2; TMP721[504].sons = &TMP772[0];
NTI225824.node = &TMP721[504];
NTI225828.size = sizeof(NU8);
NTI225828.kind = 19;
NTI225828.base = (&NTI225824);
NTI225828.flags = 3;
TMP721[505].len = 0; TMP721[505].kind = 0;
NTI225828.node = &TMP721[505];
TMP721[495].kind = 1;
TMP721[495].offset = offsetof(tloc225830, Flags);
TMP721[495].typ = (&NTI225828);
TMP721[495].name = "flags";
TMP765[3] = &TMP721[506];
TMP721[506].kind = 1;
TMP721[506].offset = offsetof(tloc225830, T);
TMP721[506].typ = (&NTI225812);
TMP721[506].name = "t";
TMP765[4] = &TMP721[507];
TMP721[507].kind = 1;
TMP721[507].offset = offsetof(tloc225830, R);
TMP721[507].typ = (&NTI177007);
TMP721[507].name = "r";
TMP765[5] = &TMP721[508];
TMP721[508].kind = 1;
TMP721[508].offset = offsetof(tloc225830, Heaproot);
TMP721[508].typ = (&NTI177007);
TMP721[508].name = "heapRoot";
TMP721[475].len = 6; TMP721[475].kind = 2; TMP721[475].sons = &TMP765[0];
NTI225830.node = &TMP721[475];
TMP721[474].kind = 1;
TMP721[474].offset = offsetof(tsym225846, Loc);
TMP721[474].typ = (&NTI225830);
TMP721[474].name = "loc";
TMP740[12] = &TMP721[509];
NTI225834.size = sizeof(tlib225834);
NTI225834.kind = 17;
NTI225834.base = (&NTI127022);
TMP777[0] = &TMP721[511];
NTI225832.size = sizeof(NU8);
NTI225832.kind = 14;
NTI225832.base = 0;
NTI225832.flags = 3;
for (TMP780 = 0; TMP780 < 2; TMP780++) {
TMP721[TMP780+512].kind = 1;
TMP721[TMP780+512].offset = TMP780;
TMP721[TMP780+512].name = TMP779[TMP780];
TMP778[TMP780] = &TMP721[TMP780+512];
}
TMP721[514].len = 2; TMP721[514].kind = 2; TMP721[514].sons = &TMP778[0];
NTI225832.node = &TMP721[514];
TMP721[511].kind = 1;
TMP721[511].offset = offsetof(tlib225834, Kind);
TMP721[511].typ = (&NTI225832);
TMP721[511].name = "kind";
TMP777[1] = &TMP721[515];
TMP721[515].kind = 1;
TMP721[515].offset = offsetof(tlib225834, Generated);
TMP721[515].typ = (&NTI138);
TMP721[515].name = "generated";
TMP777[2] = &TMP721[516];
TMP721[516].kind = 1;
TMP721[516].offset = offsetof(tlib225834, Isoverriden);
TMP721[516].typ = (&NTI138);
TMP721[516].name = "isOverriden";
TMP777[3] = &TMP721[517];
TMP721[517].kind = 1;
TMP721[517].offset = offsetof(tlib225834, Name);
TMP721[517].typ = (&NTI177007);
TMP721[517].name = "name";
TMP777[4] = &TMP721[518];
TMP721[518].kind = 1;
TMP721[518].offset = offsetof(tlib225834, Path);
TMP721[518].typ = (&NTI225808);
TMP721[518].name = "path";
TMP721[510].len = 5; TMP721[510].kind = 2; TMP721[510].sons = &TMP777[0];
NTI225834.node = &TMP721[510];
NTI225844.size = sizeof(tlib225834*);
NTI225844.kind = 22;
NTI225844.base = (&NTI225834);
NTI225844.marker = TMP781;
TMP721[509].kind = 1;
TMP721[509].offset = offsetof(tsym225846, Annex);
TMP721[509].typ = (&NTI225844);
TMP721[509].name = "annex";
TMP740[13] = &TMP721[519];
TMP721[519].kind = 1;
TMP721[519].offset = offsetof(tsym225846, Constraint);
TMP721[519].typ = (&NTI225808);
TMP721[519].name = "constraint";
TMP721[113].len = 14; TMP721[113].kind = 2; TMP721[113].sons = &TMP740[0];
NTI225846.node = &TMP721[113];
NTI225814.size = sizeof(tsym225846*);
NTI225814.kind = 22;
NTI225814.base = (&NTI225846);
NTI225814.flags = 2;
NTI225814.marker = TMP782;
TMP721[112].kind = 1;
TMP721[112].offset = offsetof(ttype225852, Owner);
TMP721[112].typ = (&NTI225814);
TMP721[112].name = "owner";
TMP729[6] = &TMP721[520];
TMP721[520].kind = 1;
TMP721[520].offset = offsetof(ttype225852, Sym);
TMP721[520].typ = (&NTI225814);
TMP721[520].name = "sym";
TMP729[7] = &TMP721[521];
TMP721[521].kind = 1;
TMP721[521].offset = offsetof(ttype225852, Destructor);
TMP721[521].typ = (&NTI225814);
TMP721[521].name = "destructor";
TMP729[8] = &TMP721[522];
TMP721[522].kind = 1;
TMP721[522].offset = offsetof(ttype225852, Deepcopy);
TMP721[522].typ = (&NTI225814);
TMP721[522].name = "deepCopy";
TMP729[9] = &TMP721[523];
TMP721[523].kind = 1;
TMP721[523].offset = offsetof(ttype225852, Size);
TMP721[523].typ = (&NTI5510);
TMP721[523].name = "size";
TMP729[10] = &TMP721[524];
TMP721[524].kind = 1;
TMP721[524].offset = offsetof(ttype225852, Align);
TMP721[524].typ = (&NTI112);
TMP721[524].name = "align";
TMP729[11] = &TMP721[525];
TMP721[525].kind = 1;
TMP721[525].offset = offsetof(ttype225852, Locklevel);
TMP721[525].typ = (&NTI112);
TMP721[525].name = "lockLevel";
TMP729[12] = &TMP721[526];
TMP721[526].kind = 1;
TMP721[526].offset = offsetof(ttype225852, Loc);
TMP721[526].typ = (&NTI225830);
TMP721[526].name = "loc";
TMP721[2].len = 13; TMP721[2].kind = 2; TMP721[2].sons = &TMP729[0];
NTI225852.node = &TMP721[2];
NTI225812.size = sizeof(ttype225852*);
NTI225812.kind = 22;
NTI225812.base = (&NTI225852);
NTI225812.flags = 2;
NTI225812.marker = TMP783;
TMP721[1].kind = 1;
TMP721[1].offset = offsetof(tnode225816, Typ);
TMP721[1].typ = (&NTI225812);
TMP721[1].name = "typ";
TMP728[1] = &TMP721[527];
TMP721[527].kind = 1;
TMP721[527].offset = offsetof(tnode225816, Info);
TMP721[527].typ = (&NTI195539);
TMP721[527].name = "info";
TMP728[2] = &TMP721[528];
NTI225437.size = sizeof(NU8);
NTI225437.kind = 14;
NTI225437.base = 0;
NTI225437.flags = 3;
for (TMP786 = 0; TMP786 < 13; TMP786++) {
TMP721[TMP786+529].kind = 1;
TMP721[TMP786+529].offset = TMP786;
TMP721[TMP786+529].name = TMP785[TMP786];
TMP784[TMP786] = &TMP721[TMP786+529];
}
TMP721[542].len = 13; TMP721[542].kind = 2; TMP721[542].sons = &TMP784[0];
NTI225437.node = &TMP721[542];
NTI225439.size = sizeof(NU16);
NTI225439.kind = 19;
NTI225439.base = (&NTI225437);
NTI225439.flags = 3;
TMP721[543].len = 0; TMP721[543].kind = 0;
NTI225439.node = &TMP721[543];
TMP721[528].kind = 1;
TMP721[528].offset = offsetof(tnode225816, Flags);
TMP721[528].typ = (&NTI225439);
TMP721[528].name = "flags";
TMP728[3] = &TMP721[544];
NTI225029.size = sizeof(NU8);
NTI225029.kind = 14;
NTI225029.base = 0;
NTI225029.flags = 3;
for (TMP789 = 0; TMP789 < 158; TMP789++) {
TMP721[TMP789+545].kind = 1;
TMP721[TMP789+545].offset = TMP789;
TMP721[TMP789+545].name = TMP788[TMP789];
TMP787[TMP789] = &TMP721[TMP789+545];
}
TMP721[703].len = 158; TMP721[703].kind = 2; TMP721[703].sons = &TMP787[0];
NTI225029.node = &TMP721[703];
TMP721[544].kind = 3;
TMP721[544].offset = offsetof(tnode225816, Kind);
TMP721[544].typ = (&NTI225029);
TMP721[544].name = "kind";
TMP721[544].sons = &NimDT_225816_kind[0];
TMP721[544].len = 158;
TMP721[704].kind = 1;
TMP721[704].offset = offsetof(tnode225816, kindU.S1.Intval);
TMP721[704].typ = (&NTI5510);
TMP721[704].name = "intVal";
NimDT_225816_kind[5] = &TMP721[704];
NimDT_225816_kind[6] = &TMP721[704];
NimDT_225816_kind[7] = &TMP721[704];
NimDT_225816_kind[8] = &TMP721[704];
NimDT_225816_kind[9] = &TMP721[704];
NimDT_225816_kind[10] = &TMP721[704];
NimDT_225816_kind[11] = &TMP721[704];
NimDT_225816_kind[12] = &TMP721[704];
NimDT_225816_kind[13] = &TMP721[704];
NimDT_225816_kind[14] = &TMP721[704];
NimDT_225816_kind[15] = &TMP721[704];
TMP721[705].kind = 1;
TMP721[705].offset = offsetof(tnode225816, kindU.S2.Floatval);
TMP721[705].typ = (&NTI5512);
TMP721[705].name = "floatVal";
NimDT_225816_kind[16] = &TMP721[705];
NimDT_225816_kind[17] = &TMP721[705];
NimDT_225816_kind[18] = &TMP721[705];
NimDT_225816_kind[19] = &TMP721[705];
TMP721[706].kind = 1;
TMP721[706].offset = offsetof(tnode225816, kindU.S3.Strval);
TMP721[706].typ = (&NTI149);
TMP721[706].name = "strVal";
NimDT_225816_kind[20] = &TMP721[706];
NimDT_225816_kind[21] = &TMP721[706];
NimDT_225816_kind[22] = &TMP721[706];
TMP721[707].kind = 1;
TMP721[707].offset = offsetof(tnode225816, kindU.S4.Sym);
TMP721[707].typ = (&NTI225814);
TMP721[707].name = "sym";
NimDT_225816_kind[3] = &TMP721[707];
TMP721[708].kind = 1;
TMP721[708].offset = offsetof(tnode225816, kindU.S5.Ident);
TMP721[708].typ = (&NTI200019);
TMP721[708].name = "ident";
NimDT_225816_kind[2] = &TMP721[708];
TMP721[709].kind = 1;
TMP721[709].offset = offsetof(tnode225816, kindU.S6.Sons);
TMP721[709].typ = (&NTI225810);
TMP721[709].name = "sons";
NimDT_225816_kind[158] = &TMP721[709];
TMP728[4] = &TMP721[710];
TMP721[710].kind = 1;
TMP721[710].offset = offsetof(tnode225816, Comment);
TMP721[710].typ = (&NTI149);
TMP721[710].name = "comment";
TMP721[0].len = 5; TMP721[0].kind = 2; TMP721[0].sons = &TMP728[0];
NTI225816.node = &TMP721[0];
NTI225808.size = sizeof(tnode225816*);
NTI225808.kind = 22;
NTI225808.base = (&NTI225816);
NTI225808.flags = 2;
NTI225808.marker = TMP790;
NTI225864.size = sizeof(tidtable225864);
NTI225864.kind = 18;
NTI225864.base = 0;
TMP824[0] = &TMP721[712];
TMP721[712].kind = 1;
TMP721[712].offset = offsetof(tidtable225864, Counter);
TMP721[712].typ = (&NTI108);
TMP721[712].name = "counter";
TMP824[1] = &TMP721[713];
NTI225860.size = sizeof(tidpair225860);
NTI225860.kind = 18;
NTI225860.base = 0;
TMP825[0] = &TMP721[715];
TMP721[715].kind = 1;
TMP721[715].offset = offsetof(tidpair225860, Key);
TMP721[715].typ = (&NTI200017);
TMP721[715].name = "key";
TMP825[1] = &TMP721[716];
TMP721[716].kind = 1;
TMP721[716].offset = offsetof(tidpair225860, Val);
TMP721[716].typ = (&NTI3213);
TMP721[716].name = "val";
TMP721[714].len = 2; TMP721[714].kind = 2; TMP721[714].sons = &TMP825[0];
NTI225860.node = &TMP721[714];
NTI225862.size = sizeof(tidpairseq225862*);
NTI225862.kind = 24;
NTI225862.base = (&NTI225860);
NTI225862.marker = TMP828;
TMP721[713].kind = 1;
TMP721[713].offset = offsetof(tidtable225864, Data);
TMP721[713].typ = (&NTI225862);
TMP721[713].name = "data";
TMP721[711].len = 2; TMP721[711].kind = 2; TMP721[711].sons = &TMP824[0];
NTI225864.node = &TMP721[711];
NTI225876.size = sizeof(tnodetable225876);
NTI225876.kind = 18;
NTI225876.base = 0;
NTI225876.flags = 2;
TMP973[0] = &TMP721[718];
TMP721[718].kind = 1;
TMP721[718].offset = offsetof(tnodetable225876, Counter);
TMP721[718].typ = (&NTI108);
TMP721[718].name = "counter";
TMP973[1] = &TMP721[719];
NTI225872.size = sizeof(tnodepair225872);
NTI225872.kind = 18;
NTI225872.base = 0;
NTI225872.flags = 2;
TMP974[0] = &TMP721[721];
TMP721[721].kind = 1;
TMP721[721].offset = offsetof(tnodepair225872, H);
TMP721[721].typ = (&NTI128021);
TMP721[721].name = "h";
TMP974[1] = &TMP721[722];
TMP721[722].kind = 1;
TMP721[722].offset = offsetof(tnodepair225872, Key);
TMP721[722].typ = (&NTI225808);
TMP721[722].name = "key";
TMP974[2] = &TMP721[723];
TMP721[723].kind = 1;
TMP721[723].offset = offsetof(tnodepair225872, Val);
TMP721[723].typ = (&NTI108);
TMP721[723].name = "val";
TMP721[720].len = 3; TMP721[720].kind = 2; TMP721[720].sons = &TMP974[0];
NTI225872.node = &TMP721[720];
NTI225874.size = sizeof(tnodepairseq225874*);
NTI225874.kind = 24;
NTI225874.base = (&NTI225872);
NTI225874.flags = 2;
NTI225874.marker = TMP975;
TMP721[719].kind = 1;
TMP721[719].offset = offsetof(tnodetable225876, Data);
TMP721[719].typ = (&NTI225874);
TMP721[719].name = "data";
TMP721[717].len = 2; TMP721[717].kind = 2; TMP721[717].sons = &TMP973[0];
NTI225876.node = &TMP721[717];
NTI456221.size = sizeof(tnode225816**);
NTI456221.kind = 21;
NTI456221.base = (&NTI225808);
NTI456221.flags = 3;
NTI225870.size = sizeof(tidnodetable225870);
NTI225870.kind = 18;
NTI225870.base = 0;
TMP3128[0] = &TMP721[725];
TMP721[725].kind = 1;
TMP721[725].offset = offsetof(tidnodetable225870, Counter);
TMP721[725].typ = (&NTI108);
TMP721[725].name = "counter";
TMP3128[1] = &TMP721[726];
NTI225866.size = sizeof(tidnodepair225866);
NTI225866.kind = 18;
NTI225866.base = 0;
TMP3129[0] = &TMP721[728];
TMP721[728].kind = 1;
TMP721[728].offset = offsetof(tidnodepair225866, Key);
TMP721[728].typ = (&NTI200017);
TMP721[728].name = "key";
TMP3129[1] = &TMP721[729];
TMP721[729].kind = 1;
TMP721[729].offset = offsetof(tidnodepair225866, Val);
TMP721[729].typ = (&NTI225808);
TMP721[729].name = "val";
TMP721[727].len = 2; TMP721[727].kind = 2; TMP721[727].sons = &TMP3129[0];
NTI225866.node = &TMP721[727];
NTI225868.size = sizeof(tidnodepairseq225868*);
NTI225868.kind = 24;
NTI225868.base = (&NTI225866);
NTI225868.marker = TMP3130;
TMP721[726].kind = 1;
TMP721[726].offset = offsetof(tidnodetable225870, Data);
TMP721[726].typ = (&NTI225868);
TMP721[726].name = "data";
TMP721[724].len = 2; TMP721[724].kind = 2; TMP721[724].sons = &TMP3128[0];
NTI225870.node = &TMP721[724];
}

