/* 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 tnode226816 tnode226816;
typedef struct tcell44933 tcell44933;
typedef struct TNimType TNimType;
typedef struct tcellseq44949 tcellseq44949;
typedef struct tgcheap47016 tgcheap47016;
typedef struct tcellset44945 tcellset44945;
typedef struct tpagedesc44941 tpagedesc44941;
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 tsym226846 tsym226846;
typedef struct tident201021 tident201021;
typedef struct NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
typedef struct tlineinfo196539 tlineinfo196539;
typedef struct ttype226852 ttype226852;
typedef struct tnodeseq226810 tnodeseq226810;
typedef struct TNimNode TNimNode;
typedef struct tidobj201015 tidobj201015;
typedef struct TNimObject TNimObject;
typedef struct ttypeseq226848 ttypeseq226848;
typedef struct tloc226830 tloc226830;
typedef struct trope178009 trope178009;
typedef struct tscope226840 tscope226840;
typedef struct TY226947 TY226947;
typedef struct tinstantiation226836 tinstantiation226836;
typedef struct tstrtable226820 tstrtable226820;
typedef struct tsymseq226818 tsymseq226818;
typedef struct tlib226834 tlib226834;
typedef struct TY226936 TY226936;
typedef struct tlistentry127022 tlistentry127022;
typedef struct tidtable226864 tidtable226864;
typedef struct tidpairseq226862 tidpairseq226862;
typedef struct tidpair226860 tidpair226860;
typedef struct tnodetable226876 tnodetable226876;
typedef struct tnodepairseq226874 tnodepairseq226874;
typedef struct tnodepair226872 tnodepair226872;
typedef struct tidnodetable226870 tidnodetable226870;
typedef struct tidnodepairseq226868 tidnodepairseq226868;
typedef struct tidnodepair226866 tidnodepair226866;
typedef struct TY84945 TY84945;
typedef struct tbasechunk26438 tbasechunk26438;
typedef struct tfreecell26430 tfreecell26430;
struct  tcell44933  {
NI Refcount;
TNimType* Typ;
};
struct  tcellseq44949  {
NI Len;
NI Cap;
tcell44933** D;
};
struct  tcellset44945  {
NI Counter;
NI Max;
tpagedesc44941* Head;
tpagedesc44941** 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;
tcellseq44949 Zct;
tcellseq44949 Decstack;
tcellset44945 Cycleroots;
tcellseq44949 Tempstack;
NI Recgclock;
tmemregion27210 Region;
tgcstat47014 Stat;
};
struct  TGenericSeq  {
NI len;
NI reserved;
};
struct  NimStringDesc  {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
struct  tlineinfo196539  {
NI16 Line;
NI16 Col;
NI32 Fileindex;
};
struct  tnode226816  {
ttype226852* Typ;
tlineinfo196539 Info;
NU16 Flags;
NU8 Kind;
union {
struct {NI64 Intval;
} S1;
struct {NF Floatval;
} S2;
struct {NimStringDesc* Strval;
} S3;
struct {tsym226846* Sym;
} S4;
struct {tident201021* Ident;
} S5;
struct {tnodeseq226810* 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  tidobj201015  {
  TNimObject Sup;
NI Id;
};
struct  tloc226830  {
NU8 K;
NU8 S;
NU8 Flags;
ttype226852* T;
trope178009* R;
trope178009* Heaproot;
};
struct  ttype226852  {
  tidobj201015 Sup;
NU8 Kind;
NU8 Callconv;
NU32 Flags;
ttypeseq226848* Sons;
tnode226816* N;
tsym226846* Owner;
tsym226846* Sym;
tsym226846* Destructor;
tsym226846* Deepcopy;
NI64 Size;
NI16 Align;
NI16 Locklevel;
tloc226830 Loc;
};
struct  tstrtable226820  {
NI Counter;
tsymseq226818* Data;
};
struct  tsym226846  {
  tidobj201015 Sup;
NU8 Kind;
union {
struct {ttypeseq226848* Typeinstcache;
tscope226840* Typscope;
} S1;
struct {TY226947* Procinstcache;
tscope226840* Scope;
} S2;
struct {TY226947* Usedgenerics;
tstrtable226820 Tab;
} S3;
struct {tsym226846* Guard;
} S4;
} kindU;
NU16 Magic;
ttype226852* Typ;
tident201021* Name;
tlineinfo196539 Info;
tsym226846* Owner;
NU32 Flags;
tnode226816* Ast;
NU32 Options;
NI Position;
NI Offset;
tloc226830 Loc;
tlib226834* Annex;
tnode226816* Constraint;
};
struct  tscope226840  {
NI Depthlevel;
tstrtable226820 Symbols;
tnodeseq226810* Usingsyms;
tscope226840* Parent;
};
struct  tinstantiation226836  {
tsym226846* Sym;
ttypeseq226848* Concretetypes;
TY226936* Usedby;
};
struct  tlistentry127022  {
  TNimObject Sup;
tlistentry127022* Prev;
tlistentry127022* Next;
};
struct  tlib226834  {
  tlistentry127022 Sup;
NU8 Kind;
NIM_BOOL Generated;
NIM_BOOL Isoverriden;
trope178009* Name;
tnode226816* Path;
};
struct  tidpair226860  {
tidobj201015* Key;
TNimObject* Val;
};
struct  tidtable226864  {
NI Counter;
tidpairseq226862* Data;
};
struct  tnodepair226872  {
NI H;
tnode226816* Key;
NI Val;
};
struct  tnodetable226876  {
NI Counter;
tnodepairseq226874* Data;
};
typedef tnode226816* TY229474[7];
typedef NimStringDesc* TY226020[10];
typedef tnode226816* TY247892[1];
struct  tidnodepair226866  {
tidobj201015* Key;
tnode226816* Val;
};
struct  tidnodetable226870  {
NI Counter;
tidnodepairseq226868* Data;
};
struct TY84945 {
NimStringDesc* Field0;
NI Field1;
};
typedef NU8 TY518462[20];
typedef NI TY26420[16];
struct  tpagedesc44941  {
tpagedesc44941* 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  tident201021  {
  tidobj201015 Sup;
NimStringDesc* S;
tident201021* Next;
NI H;
};
struct  trope178009  {
  TNimObject Sup;
trope178009* Left;
trope178009* Right;
NI Length;
NimStringDesc* Data;
};
struct  tfreecell26430  {
tfreecell26430* Next;
NI Zerofield;
};
struct tnodeseq226810 {
  TGenericSeq Sup;
  tnode226816* data[SEQ_DECL_SIZE];
};
struct ttypeseq226848 {
  TGenericSeq Sup;
  ttype226852* data[SEQ_DECL_SIZE];
};
struct TY226947 {
  TGenericSeq Sup;
  tinstantiation226836* data[SEQ_DECL_SIZE];
};
struct tsymseq226818 {
  TGenericSeq Sup;
  tsym226846* data[SEQ_DECL_SIZE];
};
struct TY226936 {
  TGenericSeq Sup;
  NI32 data[SEQ_DECL_SIZE];
};
struct tidpairseq226862 {
  TGenericSeq Sup;
  tidpair226860 data[SEQ_DECL_SIZE];
};
struct tnodepairseq226874 {
  TGenericSeq Sup;
  tnodepair226872 data[SEQ_DECL_SIZE];
};
struct tidnodepairseq226868 {
  TGenericSeq Sup;
  tidnodepair226866 data[SEQ_DECL_SIZE];
};
static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src);
static N_INLINE(tcell44933*, usrtocell_48646)(void* usr);
static N_INLINE(void, rtladdzct_50204)(tcell44933* c);
N_NOINLINE(void, addzct_48617)(tcellseq44949* s, tcell44933* c);
N_NIMCALL(tident201021*, getident_201472)(NimStringDesc* identifier);
N_NIMCALL(tlineinfo196539, unknownlineinfo_197405)(void);
N_NIMCALL(tnode226816*, newnode_227090)(NU8 kind);
N_NIMCALL(void, nimGCvisit)(void* d, NI op);
N_NIMCALL(void, TMP741)(void* p, NI op);
N_NIMCALL(void, TMP749)(void* p, NI op);
N_NIMCALL(void, TMP750)(void* p, NI op);
N_NIMCALL(void, TMP751)(void* p, NI op);
N_NIMCALL(void, TMP754)(void* p, NI op);
N_NIMCALL(void, TMP755)(void* p, NI op);
N_NIMCALL(void, TMP756)(void* p, NI op);
N_NIMCALL(void, TMP783)(void* p, NI op);
N_NIMCALL(void, TMP784)(void* p, NI op);
N_NIMCALL(void, TMP785)(void* p, NI op);
N_NIMCALL(void, TMP792)(void* p, NI op);
N_NIMCALL(void*, newObj)(TNimType* typ, NI size);
N_NIMCALL(void, TMP830)(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_225404)(void);
N_NIMCALL(void, TMP977)(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(tnode226816*, newnodei_227138)(NU8 kind, tlineinfo196539 info);
N_NIMCALL(void, genericSeqAssign)(void* dest, void* src_79804, TNimType* mt);
N_NIMCALL(void, add_227498)(tnode226816* father, tnode226816* son);
N_NIMCALL(void, propagatetoowner_231318)(ttype226852* owner, ttype226852* elem);
N_NIMCALL(NIM_BOOL, ismetatype_227752)(ttype226852* t);
static N_INLINE(NIM_BOOL, isgcedmem_231276)(ttype226852* t);
N_NIMCALL(NimStringDesc*, copyStringRC1)(NimStringDesc* src);
N_NIMCALL(NimStringDesc*, copyString)(NimStringDesc* src);
N_NIMCALL(NimStringDesc*, nimIntToStr)(NI x);
static N_INLINE(ttype226852*, lastson_227267)(ttype226852* n);
static N_INLINE(NI, sonslen_227255)(ttype226852* n);
static N_INLINE(void, asgnRef)(void** dest, void* src);
static N_INLINE(void, incref_51025)(tcell44933* c);
static N_INLINE(NIM_BOOL, canbecycleroot_48667)(tcell44933* c);
static N_INLINE(void, rtladdcycleroot_49429)(tcell44933* c);
N_NOINLINE(void, incl_45671)(tcellset44945* s, tcell44933* cell);
static N_INLINE(void, decref_50604)(tcell44933* c);
N_NIMCALL(void, mergeloc_229607)(tloc226830* a, tloc226830 b);
N_NIMCALL(void, newsons_227280)(ttype226852* father, NI length);
N_NIMCALL(TGenericSeq*, setLengthSeq)(TGenericSeq* seq, NI elemsize, NI newlen);
N_NIMCALL(ttype226852*, newtype_227083)(NU8 kind, tsym226846* owner);
N_NIMCALL(void, assigntype_227210)(ttype226852* dest, ttype226852* src);
N_NIMCALL(tsym226846*, newsym_227074)(NU8 symkind, tident201021* name, tsym226846* owner, tlineinfo196539 info);
N_NIMCALL(void, copystrtable_227217)(tstrtable226820* dest, tstrtable226820 src);
N_NIMCALL(void, genericAssign)(void* dest, void* src, TNimType* mt);
N_NIMCALL(void, initstrtable_227153)(tstrtable226820* x);
static N_INLINE(NI, sonslen_227249)(tnode226816* n);
N_NIMCALL(tnode226816*, copytree_227329)(tnode226816* src);
N_NIMCALL(tnode226816*, newintnode_227096)(NU8 kind, NI64 intval);
static N_INLINE(tnode226816*, HEX5BHEX5D_227698)(tnode226816* n, NI i);
N_NIMCALL(void, internalerror_198987)(tlineinfo196539 info, NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, nimCharToStr)(NIM_CHAR x);
N_NIMCALL(void, TMP3132)(void* p, NI op);
N_NIMCALL(void, internalerror_199006)(NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, HEX24_199126)(TY84945 x_199130);
N_NIMCALL(NIM_BOOL, containsnode_233212)(tnode226816* n, TY518462 kinds);
N_NIMCALL(NIM_BOOL, hassubnodewith_227308)(tnode226816* n, NU8 kind);
N_NIMCALL(void, addson_227287)(tnode226816* father, tnode226816* son);
STRING_LITERAL(TMP729, "*", 1);
TNimNode* NimDT_226846_kind[27];
TNimNode* NimDT_226816_kind[159];
STRING_LITERAL(TMP2088, "", 0);
STRING_LITERAL(TMP2089, "stdcall", 7);
STRING_LITERAL(TMP2090, "cdecl", 5);
STRING_LITERAL(TMP2091, "safecall", 8);
STRING_LITERAL(TMP2092, "syscall", 7);
STRING_LITERAL(TMP2093, "inline", 6);
STRING_LITERAL(TMP2094, "noinline", 8);
STRING_LITERAL(TMP2095, "fastcall", 8);
STRING_LITERAL(TMP2096, "closure", 7);
STRING_LITERAL(TMP2097, "noconv", 6);
NIM_CONST TY226020 callingconvtostr_226019 = {((NimStringDesc*) &TMP2088),
((NimStringDesc*) &TMP2089),
((NimStringDesc*) &TMP2090),
((NimStringDesc*) &TMP2091),
((NimStringDesc*) &TMP2092),
((NimStringDesc*) &TMP2093),
((NimStringDesc*) &TMP2094),
((NimStringDesc*) &TMP2095),
((NimStringDesc*) &TMP2096),
((NimStringDesc*) &TMP2097)}
;
STRING_LITERAL(TMP2101, "<unspecified>", 13);
STRING_LITERAL(TMP2102, "<unknown>", 9);
STRING_LITERAL(TMP3107, "getInt", 6);
STRING_LITERAL(TMP3108, "getFloat", 8);
STRING_LITERAL(TMP3109, "getStr", 6);
STRING_LITERAL(TMP3112, "getStrOrChar", 12);
STRING_LITERAL(TMP3176, "compiler/ast.nim", 16);
NIM_CONST TY84945 TMP3175 = {((NimStringDesc*) &TMP3176),
1533}
;
tnode226816* emptynode_227738;
extern tgcheap47016 gch_47044;
tsym226846* anyglobal_227745;
tnode226816* emptyparams_229419;
TNimType NTI226816; /* TNode */
extern TNimType NTI201015; /* TIdObj */
TNimType NTI226852; /* TType */
TNimType NTI226258; /* TTypeKind */
TNimType NTI226005; /* TCallingConvention */
TNimType NTI226441; /* TTypeFlag */
TNimType NTI226443; /* TTypeFlags */
TNimType NTI226848; /* TTypeSeq */
TNimType NTI226846; /* TSym */
TNimType NTI226445; /* TSymKind */
TNimType NTI226840; /* TScope */
extern TNimType NTI108; /* int */
TNimType NTI226820; /* TStrTable */
TNimType NTI226818; /* TSymSeq */
TNimType NTI226810; /* TNodeSeq */
TNimType NTI226842; /* PScope */
TNimType NTI226836; /* TInstantiation */
extern TNimType NTI114; /* int32 */
TNimType NTI226936; /* seq[int32] */
TNimType NTI226838; /* PInstantiation */
TNimType NTI226947; /* seq[PInstantiation] */
TNimType NTI226532; /* TMagic */
extern TNimType NTI201019; /* PIdent */
extern TNimType NTI196539; /* TLineInfo */
TNimType NTI226194; /* TSymFlag */
TNimType NTI226196; /* TSymFlags */
extern TNimType NTI170016; /* TOptions */
TNimType NTI226830; /* TLoc */
TNimType NTI226822; /* TLocKind */
TNimType NTI226826; /* TStorageLoc */
TNimType NTI226824; /* TLocFlag */
TNimType NTI226828; /* TLocFlags */
extern TNimType NTI178007; /* PRope */
extern TNimType NTI127022; /* TListEntry */
TNimType NTI226834; /* TLib */
TNimType NTI226832; /* TLibKind */
extern TNimType NTI138; /* bool */
TNimType NTI226844; /* PLib */
TNimType NTI226814; /* PSym */
extern TNimType NTI5510; /* BiggestInt */
extern TNimType NTI112; /* int16 */
TNimType NTI226812; /* PType */
TNimType NTI226437; /* TNodeFlag */
TNimType NTI226439; /* TNodeFlags */
TNimType NTI226029; /* TNodeKind */
extern TNimType NTI5512; /* BiggestFloat */
extern TNimType NTI149; /* string */
TNimType NTI226808; /* PNode */
TNimType NTI226864; /* TIdTable */
TNimType NTI226860; /* TIdPair */
extern TNimType NTI201017; /* PIdObj */
extern TNimType NTI3213; /* RootRef */
TNimType NTI226862; /* TIdPairSeq */
extern NU32 goptions_170116;
extern NI gfrontendid_225012;
TNimType NTI226876; /* TNodeTable */
TNimType NTI226872; /* TNodePair */
extern TNimType NTI128021; /* THash */
TNimType NTI226874; /* TNodePairSeq */
TNimType NTI457221; /* ptr PNode */
TNimType NTI226870; /* TIdNodeTable */
TNimType NTI226866; /* TIdNodePair */
TNimType NTI226868; /* TIdNodePairSeq */

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

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

static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src) {
	{
		tcell44933* c;
		if (!!((src == NIM_NIL))) goto LA3;
		c = usrtocell_48646(src);
		(*c).Refcount += 8;
	}
	LA3: ;
	{
		tcell44933* 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, TMP741)(void* p, NI op) {
	ttypeseq226848* a;
	NI LOC1;
	a = (ttypeseq226848*)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) {
	tsymseq226818* a;
	NI LOC1;
	a = (tsymseq226818*)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) {
	tnodeseq226810* a;
	NI LOC1;
	a = (tnodeseq226810*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP751)(void* p, NI op) {
	tscope226840* a;
	a = (tscope226840*)p;
	nimGCvisit((void*)(*a).Symbols.Data, op);
	nimGCvisit((void*)(*a).Usingsyms, op);
	nimGCvisit((void*)(*a).Parent, op);
}
N_NIMCALL(void, TMP754)(void* p, NI op) {
	TY226936* a;
	NI LOC1;
	a = (TY226936*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	}
}
N_NIMCALL(void, TMP755)(void* p, NI op) {
	tinstantiation226836* a;
	a = (tinstantiation226836*)p;
	nimGCvisit((void*)(*a).Sym, op);
	nimGCvisit((void*)(*a).Concretetypes, op);
	nimGCvisit((void*)(*a).Usedby, op);
}
N_NIMCALL(void, TMP756)(void* p, NI op) {
	TY226947* a;
	NI LOC1;
	a = (TY226947*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP783)(void* p, NI op) {
	tlib226834* a;
	a = (tlib226834*)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, TMP784)(void* p, NI op) {
	tsym226846* a;
	a = (tsym226846*)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, TMP785)(void* p, NI op) {
	ttype226852* a;
	a = (ttype226852*)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, TMP792)(void* p, NI op) {
	tnode226816* a;
	a = (tnode226816*)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(tnode226816*, newnode_227090)(NU8 kind) {
	tnode226816* result;
	result = 0;
	result = (tnode226816*) newObj((&NTI226808), sizeof(tnode226816));
	(*result).Kind = kind;
	(*result).Info.Fileindex = ((NI32) -1);
	(*result).Info.Col = ((NI16) -1);
	(*result).Info.Line = ((NI16) -1);
	return result;
}
N_NIMCALL(void, TMP830)(void* p, NI op) {
	tidpairseq226862* a;
	NI LOC1;
	a = (tidpairseq226862*)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_227167)(tidtable226864* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) (&(*x).Data), (tidpairseq226862*) newSeq((&NTI226862), 8));
}

N_NIMCALL(void, initstrtable_227153)(tstrtable226820* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) (&(*x).Data), (tsymseq226818*) newSeq((&NTI226818), 8));
}

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

N_NIMCALL(tsym226846*, newsym_227074)(NU8 symkind, tident201021* name, tsym226846* owner, tlineinfo196539 info) {
	tsym226846* result;
	result = 0;
	result = (tsym226846*) newObj((&NTI226814), sizeof(tsym226846));
	(*result).Sup.Sup.m_type = (&NTI226846);
	asgnRefNoCycle((void**) (&(*result).Name), name);
	(*result).Kind = symkind;
	(*result).Flags = 0;
	(*result).Info = info;
	(*result).Options = goptions_170116;
	asgnRefNoCycle((void**) (&(*result).Owner), owner);
	(*result).Offset = -1;
	(*result).Sup.Id = getid_225404();
	return result;
}

N_NIMCALL(tnode226816*, newidentnode_227125)(tident201021* ident, tlineinfo196539 info) {
	tnode226816* result;
	result = 0;
	result = newnode_227090(((NU8) 2));
	asgnRefNoCycle((void**) (&(*result).kindU.S5.Ident), ident);
	(*result).Info = info;
	return result;
}
N_NIMCALL(void, TMP977)(void* p, NI op) {
	tnodepairseq226874* a;
	NI LOC1;
	a = (tnodepairseq226874*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1].Key, op);
	}
}

N_NIMCALL(tnode226816*, newnodei_227138)(NU8 kind, tlineinfo196539 info) {
	tnode226816* result;
	result = 0;
	result = (tnode226816*) newObj((&NTI226808), sizeof(tnode226816));
	(*result).Kind = kind;
	(*result).Info = info;
	return result;
}

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

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

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

N_NIMCALL(tnode226816*, newprocnode_229432)(NU8 kind, tlineinfo196539 info, tnode226816* body, tnode226816* params, tnode226816* name, tnode226816* pattern, tnode226816* genericparams, tnode226816* pragmas, tnode226816* exceptions) {
	tnode226816* result;
	TY229474 LOC1;
	result = 0;
	result = newnodei_227138(kind, info);
	if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
	(*result).kindU.S6.Sons = (tnodeseq226810*) newSeqRC1((&NTI226810), 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(tnode226816*, newnode_229207)(NU8 kind, tlineinfo196539 info, tnodeseq226810* sons, ttype226852* typ) {
	tnode226816* result;
	result = 0;
	result = (tnode226816*) newObj((&NTI226808), sizeof(tnode226816));
	(*result).Kind = kind;
	(*result).Info = info;
	asgnRefNoCycle((void**) (&(*result).Typ), typ);
	genericSeqAssign((&(*result).kindU.S6.Sons), sons, (&NTI226810));
	return result;
}

N_NIMCALL(tnode226816*, newnodei_229007)(NU8 kind, tlineinfo196539 info, NI children) {
	tnode226816* result;
	result = 0;
	result = (tnode226816*) newObj((&NTI226808), sizeof(tnode226816));
	(*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 = (tnodeseq226810*) newSeqRC1((&NTI226810), children);
	}
	LA3: ;
	return result;
}

N_NIMCALL(tnode226816*, makestmtlist_234031)(tnode226816* n) {
	tnode226816* result;
	result = 0;
	{
		if (!((*n).Kind == ((NU8) 115))) goto LA3;
		result = n;
	}
	goto LA1;
	LA3: ;
	{
		result = newnodei_227138(((NU8) 115), (*n).Info);
		add_227498(result, n);
	}
	LA1: ;
	return result;
}

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

N_NIMCALL(NIM_BOOL, ismetatype_227752)(ttype226852* 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_231276)(ttype226852* 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_231318)(ttype226852* owner, ttype226852* 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_227752(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_231276(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_231562)(ttype226852* father, ttype226852* son) {
	{
		if (!(*father).Sons == 0) goto LA3;
		if ((*father).Sons) nimGCunrefNoCycle((*father).Sons);
		(*father).Sons = (ttypeseq226848*) newSeqRC1((&NTI226848), 0);
	}
	LA3: ;
	(*father).Sons = (ttypeseq226848*) incrSeq(&((*father).Sons)->Sup, sizeof(ttype226852*));
	asgnRefNoCycle((void**) (&(*father).Sons->data[(*father).Sons->Sup.len-1]), son);
	{
		if (!!(son == 0)) goto LA7;
		propagatetoowner_231318(father, son);
	}
	LA7: ;
}

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

N_NIMCALL(NI, len_231005)(ttype226852* 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_229488)(NI16 x) {
	NimStringDesc* result;
	result = 0;
	{
		if (!(((NI) (x)) == -1)) goto LA3;
		result = copyString(((NimStringDesc*) &TMP2101));
	}
	goto LA1;
	LA3: ;
	{
		if (!(((NI) (x)) == 1001)) goto LA6;
		result = copyString(((NimStringDesc*) &TMP2102));
	}
	goto LA1;
	LA6: ;
	{
		result = nimIntToStr(((NI) (x)));
	}
	LA1: ;
	return result;
}

static N_INLINE(NI, sonslen_227255)(ttype226852* 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(ttype226852*, lastson_227267)(ttype226852* n) {
	ttype226852* result;
	NI LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = sonslen_227255(n);
	result = (*n).Sons->data[(NI32)(LOC1 - 1)];
	return result;
}

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

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

static N_INLINE(void, rtladdcycleroot_49429)(tcell44933* 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)(tcell44933* 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)(tcell44933* 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) {
	{
		tcell44933* LOC5;
		if (!!((src == NIM_NIL))) goto LA3;
		LOC5 = 0;
		LOC5 = usrtocell_48646(src);
		incref_51025(LOC5);
	}
	LA3: ;
	{
		tcell44933* LOC10;
		if (!!(((*dest) == NIM_NIL))) goto LA8;
		LOC10 = 0;
		LOC10 = usrtocell_48646((*dest));
		decref_50604(LOC10);
	}
	LA8: ;
	(*dest) = src;
}

N_NIMCALL(void, mergeloc_229607)(tloc226830* a, tloc226830 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_227280)(ttype226852* father, NI length) {
	{
		if (!(*father).Sons == 0) goto LA3;
		if ((*father).Sons) nimGCunrefNoCycle((*father).Sons);
		(*father).Sons = (ttypeseq226848*) newSeqRC1((&NTI226848), length);
	}
	goto LA1;
	LA3: ;
	{
		(*father).Sons = (ttypeseq226848*) setLengthSeq(&((*father).Sons)->Sup, sizeof(ttype226852*), length);
	}
	LA1: ;
}

N_NIMCALL(void, assigntype_227210)(ttype226852* dest, ttype226852* 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_229607((&(*(*dest).Sym).Loc), (*(*src).Sym).Loc);
		}
		goto LA5;
		LA7: ;
		{
			asgnRefNoCycle((void**) (&(*dest).Sym), (*src).Sym);
		}
		LA5: ;
	}
	LA3: ;
	LOC14 = 0;
	LOC14 = sonslen_227255(src);
	newsons_227280(dest, LOC14);
	{
		NI i_229772;
		NI HEX3Atmp_229774;
		NI LOC16;
		NI res_229777;
		i_229772 = 0;
		HEX3Atmp_229774 = 0;
		LOC16 = 0;
		LOC16 = sonslen_227255(src);
		HEX3Atmp_229774 = (NI32)(LOC16 - 1);
		res_229777 = 0;
		{
			while (1) {
				if (!(res_229777 <= HEX3Atmp_229774)) goto LA18;
				i_229772 = res_229777;
				asgnRefNoCycle((void**) (&(*dest).Sons->data[i_229772]), (*src).Sons->data[i_229772]);
				res_229777 += 1;
			} LA18: ;
		}
	}
}

N_NIMCALL(ttype226852*, newtype_227083)(NU8 kind, tsym226846* owner) {
	ttype226852* result;
	result = 0;
	result = (ttype226852*) newObj((&NTI226812), sizeof(ttype226852));
	(*result).Sup.Sup.m_type = (&NTI226852);
	(*result).Kind = kind;
	asgnRefNoCycle((void**) (&(*result).Owner), owner);
	(*result).Size = IL64(-1);
	(*result).Align = ((NI16) 2);
	(*result).Sup.Id = getid_225404();
	(*result).Locklevel = ((NI16) -1);
	return result;
}

N_NIMCALL(tnode226816*, newintnode_227096)(NU8 kind, NI64 intval) {
	tnode226816* result;
	result = 0;
	result = newnode_227090(kind);
	(*result).kindU.S1.Intval = intval;
	return result;
}

N_NIMCALL(void, copyidtable_227241)(tidtable226864* dest, tidtable226864 src) {
	(*dest).Counter = src.Counter;
	{
		if (!src.Data == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	unsureAsgnRef((void**) (&(*dest).Data), (tidpairseq226862*) newSeq((&NTI226862), src.Data->Sup.len));
	{
		NI i_228176;
		NI HEX3Atmp_228178;
		NI res_228181;
		i_228176 = 0;
		HEX3Atmp_228178 = 0;
		HEX3Atmp_228178 = (src.Data->Sup.len-1);
		res_228181 = 0;
		{
			while (1) {
				if (!(res_228181 <= HEX3Atmp_228178)) goto LA7;
				i_228176 = res_228181;
				asgnRef((void**) (&(*dest).Data->data[i_228176].Key), src.Data->data[i_228176].Key);
				asgnRef((void**) (&(*dest).Data->data[i_228176].Val), src.Data->data[i_228176].Val);
				res_228181 += 1;
			} LA7: ;
		}
	}
	BeforeRet: ;
}

N_NIMCALL(ttype226852*, copytype_227195)(ttype226852* t, tsym226846* owner, NIM_BOOL keepid) {
	ttype226852* result;
	result = 0;
	result = newtype_227083((*t).Kind, owner);
	assigntype_227210(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(tnode226816*, copynode_227323)(tnode226816* src) {
	tnode226816* result;
	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_227090((*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_227217)(tstrtable226820* dest, tstrtable226820 src) {
	(*dest).Counter = src.Counter;
	{
		if (!src.Data == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	(*dest).Data = (tsymseq226818*) setLengthSeq(&((*dest).Data)->Sup, sizeof(tsym226846*), src.Data->Sup.len);
	{
		NI i_228099;
		NI HEX3Atmp_228101;
		NI res_228104;
		i_228099 = 0;
		HEX3Atmp_228101 = 0;
		HEX3Atmp_228101 = (src.Data->Sup.len-1);
		res_228104 = 0;
		{
			while (1) {
				if (!(res_228104 <= HEX3Atmp_228101)) goto LA7;
				i_228099 = res_228104;
				asgnRefNoCycle((void**) (&(*dest).Data->data[i_228099]), src.Data->data[i_228099]);
				res_228104 += 1;
			} LA7: ;
		}
	}
	BeforeRet: ;
}

N_NIMCALL(tsym226846*, copysym_227203)(tsym226846* s, NIM_BOOL keepid) {
	tsym226846* result;
	result = 0;
	result = newsym_227074((*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_225404();
	}
	LA1: ;
	(*result).Flags = (*s).Flags;
	(*result).Magic = (*s).Magic;
	{
		if (!((*s).Kind == ((NU8) 6))) goto LA8;
		copystrtable_227217((&(*result).kindU.S3.Tab), (*s).kindU.S3.Tab);
	}
	LA8: ;
	(*result).Options = (*s).Options;
	(*result).Position = (*s).Position;
	genericAssign((void*)(&(*result).Loc), (void*)(&(*s).Loc), (&NTI226830));
	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(tnode226816*, newsymnode_227132)(tsym226846* sym) {
	tnode226816* result;
	result = 0;
	result = newnode_227090(((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_227273)(tnode226816* 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 = (tnodeseq226810*) newSeqRC1((&NTI226810), length);
	}
	goto LA1;
	LA3: ;
	{
		(*father).kindU.S6.Sons = (tnodeseq226810*) setLengthSeq(&((*father).kindU.S6.Sons)->Sup, sizeof(tnode226816*), length);
	}
	LA1: ;
}

N_NIMCALL(void, newstrtable_230833)(tstrtable226820* Result) {
	initstrtable_227153(Result);
}

static N_INLINE(NI, sonslen_227249)(tnode226816* 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(tnode226816*, copytree_227329)(tnode226816* src) {
	tnode226816* result;
	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_227090((*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_227249(src);
		if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
		(*result).kindU.S6.Sons = (tnodeseq226810*) newSeqRC1((&NTI226810), LOC12);
		{
			NI i_232983;
			NI HEX3Atmp_233013;
			NI LOC14;
			NI res_233016;
			i_232983 = 0;
			HEX3Atmp_233013 = 0;
			LOC14 = 0;
			LOC14 = sonslen_227249(src);
			HEX3Atmp_233013 = (NI32)(LOC14 - 1);
			res_233016 = 0;
			{
				while (1) {
					if (!(res_233016 <= HEX3Atmp_233013)) goto LA16;
					i_232983 = res_233016;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.Sons->data[i_232983]), copytree_227329((*src).kindU.S6.Sons->data[i_232983]));
					res_233016 += 1;
				} LA16: ;
			}
		}
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tnode226816*, newsymnode_228755)(tsym226846* sym, tlineinfo196539 info) {
	tnode226816* result;
	result = 0;
	result = newnode_227090(((NU8) 3));
	asgnRefNoCycle((void**) (&(*result).kindU.S4.Sym), sym);
	asgnRefNoCycle((void**) (&(*result).Typ), (*sym).Typ);
	(*result).Info = info;
	return result;
}

N_NIMCALL(tnode226816*, newnodeit_227145)(NU8 kind, tlineinfo196539 info, ttype226852* typ) {
	tnode226816* result;
	result = 0;
	result = newnode_227090(kind);
	(*result).Info = info;
	asgnRefNoCycle((void**) (&(*result).Typ), typ);
	return result;
}

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

N_NIMCALL(tnode226816*, newinttypenode_227103)(NU8 kind, NI64 intval, ttype226852* typ) {
	tnode226816* result;
	result = 0;
	result = newintnode_227096(kind, intval);
	asgnRefNoCycle((void**) (&(*result).Typ), typ);
	return result;
}

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

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

N_NIMCALL(void, discardsons_227358)(tnode226816* father) {
	genericSeqAssign((&(*father).kindU.S6.Sons), NIM_NIL, (&NTI226810));
}

N_NIMCALL(void, appendtomodule_227851)(tsym226846* m, tnode226816* n) {
	{
		TY247892 LOC5;
		if (!((*m).Ast == NIM_NIL)) goto LA3;
		asgnRefNoCycle((void**) (&(*m).Ast), newnode_227090(((NU8) 115)));
		if ((*(*m).Ast).kindU.S6.Sons) nimGCunrefNoCycle((*(*m).Ast).kindU.S6.Sons);
		(*(*m).Ast).kindU.S6.Sons = (tnodeseq226810*) newSeqRC1((&NTI226810), 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 = (tnodeseq226810*) incrSeq(&((*(*m).Ast).kindU.S6.Sons)->Sup, sizeof(tnode226816*));
		asgnRefNoCycle((void**) (&(*(*m).Ast).kindU.S6.Sons->data[(*(*m).Ast).kindU.S6.Sons->Sup.len-1]), n);
	}
	LA1: ;
}

N_NIMCALL(void, delson_227294)(tnode226816* father, NI idx) {
	NI length;
	{
		if (!(*father).kindU.S6.Sons == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	length = sonslen_227249(father);
	{
		NI i_232041;
		NI HEX3Atmp_232101;
		NI res_232104;
		i_232041 = 0;
		HEX3Atmp_232101 = 0;
		HEX3Atmp_232101 = (NI32)(length - 2);
		res_232104 = idx;
		{
			while (1) {
				if (!(res_232104 <= HEX3Atmp_232101)) goto LA7;
				i_232041 = res_232104;
				asgnRefNoCycle((void**) (&(*father).kindU.S6.Sons->data[i_232041]), (*father).kindU.S6.Sons->data[(NI32)(i_232041 + 1)]);
				res_232104 += 1;
			} LA7: ;
		}
	}
	(*father).kindU.S6.Sons = (tnodeseq226810*) setLengthSeq(&((*father).kindU.S6.Sons)->Sup, sizeof(tnode226816*), (NI32)(length - 1));
	BeforeRet: ;
}

N_NIMCALL(NIM_BOOL, iscallexpr_227335)(tnode226816* 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(tnode226816*, shallowcopy_232347)(tnode226816* src) {
	tnode226816* result;
	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_227090((*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_227249(src);
		if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
		(*result).kindU.S6.Sons = (tnodeseq226810*) newSeqRC1((&NTI226810), LOC12);
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tsym226846*, linkto_227825)(tsym226846* s, ttype226852* t) {
	tsym226846* result;
	result = 0;
	asgnRefNoCycle((void**) (&(*t).Sym), s);
	asgnRefNoCycle((void**) (&(*s).Typ), t);
	result = s;
	return result;
}

N_NIMCALL(tnode226816*, newfloatnode_227111)(NU8 kind, NF floatval) {
	tnode226816* result;
	result = 0;
	result = newnode_227090(kind);
	(*result).kindU.S2.Floatval = floatval;
	return result;
}

N_NIMCALL(NI64, getint_233538)(tnode226816* a) {
	NI64 result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 6) ... ((NU8) 15):
	{
		result = (*a).kindU.S1.Intval;
	}
	break;
	default:
	{
		internalerror_198987((*a).Info, ((NimStringDesc*) &TMP3107));
		result = IL64(0);
	}
	break;
	}
	return result;
}

N_NIMCALL(NF, getfloat_233562)(tnode226816* a) {
	NF result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 16) ... ((NU8) 19):
	{
		result = (*a).kindU.S2.Floatval;
	}
	break;
	default:
	{
		internalerror_198987((*a).Info, ((NimStringDesc*) &TMP3108));
		result = 0.0;
	}
	break;
	}
	return result;
}

N_NIMCALL(NimStringDesc*, getstr_233587)(tnode226816* a) {
	NimStringDesc* result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 20) ... ((NU8) 22):
	{
		result = copyString((*a).kindU.S3.Strval);
	}
	break;
	default:
	{
		internalerror_198987((*a).Info, ((NimStringDesc*) &TMP3109));
		result = copyString(((NimStringDesc*) &TMP2088));
	}
	break;
	}
	return result;
}

N_NIMCALL(NimStringDesc*, getstrorchar_233611)(tnode226816* 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_198987((*a).Info, ((NimStringDesc*) &TMP3112));
		result = copyString(((NimStringDesc*) &TMP2088));
	}
	break;
	}
	return result;
}
N_NIMCALL(void, TMP3132)(void* p, NI op) {
	tidnodepairseq226868* a;
	NI LOC1;
	a = (tidnodepairseq226868*)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_227181)(tidnodetable226870* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) (&(*x).Data), (tidnodepairseq226868*) newSeq((&NTI226868), 8));
}

N_NIMCALL(tsym226846*, skipgenericowner_233698)(tsym226846* s) {
	tsym226846* result;
	result = 0;
	{
		NimStringDesc* LOC5;
		if (!!(((520192 &(1<<(((*s).Kind)&31)))!=0))) goto LA3;
		LOC5 = 0;
		LOC5 = HEX24_199126(TMP3175);
		internalerror_199006(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_233212)(tnode226816* n, TY518462 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_233259;
			NI HEX3Atmp_233288;
			NI LOC8;
			NI res_233291;
			i_233259 = 0;
			HEX3Atmp_233288 = 0;
			LOC8 = 0;
			LOC8 = sonslen_227249(n);
			HEX3Atmp_233288 = (NI32)(LOC8 - 1);
			res_233291 = 0;
			{
				while (1) {
					if (!(res_233291 <= HEX3Atmp_233288)) goto LA10;
					i_233259 = res_233291;
					{
						NIM_BOOL LOC13;
						LOC13 = 0;
						LOC13 = ((kinds[(*n).Kind/8] &(1<<((*n).Kind%8)))!=0);
						if (LOC13) goto LA14;
						LOC13 = containsnode_233212((*n).kindU.S6.Sons->data[i_233259], kinds);
						LA14: ;
						if (!LOC13) goto LA15;
						result = NIM_TRUE;
						goto BeforeRet;
					}
					LA15: ;
					res_233291 += 1;
				} LA10: ;
			}
		}
	}
	break;
	}
	BeforeRet: ;
	return result;
}

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

N_NIMCALL(tnode226816*, withinfo_228695)(tnode226816* n, tlineinfo196539 info) {
	tnode226816* result;
	result = 0;
	(*n).Info = info;
	result = n;
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, hassonwith_227301)(tnode226816* n, NU8 kind) {
	NIM_BOOL result;
	result = 0;
	{
		NI i_233084;
		NI HEX3Atmp_233109;
		NI LOC2;
		NI res_233112;
		i_233084 = 0;
		HEX3Atmp_233109 = 0;
		LOC2 = 0;
		LOC2 = sonslen_227249(n);
		HEX3Atmp_233109 = (NI32)(LOC2 - 1);
		res_233112 = 0;
		{
			while (1) {
				if (!(res_233112 <= HEX3Atmp_233109)) goto LA4;
				i_233084 = res_233112;
				{
					if (!((*(*n).kindU.S6.Sons->data[i_233084]).Kind == kind)) goto LA7;
					result = NIM_TRUE;
					goto BeforeRet;
				}
				LA7: ;
				res_233112 += 1;
			} LA4: ;
		}
	}
	result = NIM_FALSE;
	BeforeRet: ;
	return result;
}

N_NIMCALL(tsym226846*, createmodulealias_230287)(tsym226846* s, tident201021* newident, tlineinfo196539 info) {
	tsym226846* result;
	result = 0;
	result = newsym_227074((*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), (&NTI226830));
	asgnRef((void**) (&(*result).Annex), (*s).Annex);
	return result;
}

N_NIMCALL(void, initnodetable_227188)(tnodetable226876* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) (&(*x).Data), (tnodepairseq226874*) newSeq((&NTI226874), 8));
}
NIM_EXTERNC N_NOINLINE(void, HEX00_astInit)(void) {
	tident201021* LOC1;
	tlineinfo196539 LOC2;
	asgnRefNoCycle((void**) (&emptynode_227738), newnode_227090(((NU8) 1)));
	LOC1 = 0;
	LOC1 = getident_201472(((NimStringDesc*) &TMP729));
	LOC2 = unknownlineinfo_197405();
	asgnRefNoCycle((void**) (&anyglobal_227745), newsym_227074(((NU8) 8), LOC1, NIM_NIL, LOC2));
	asgnRefNoCycle((void**) (&emptyparams_229419), newnode_227090(((NU8) 76)));
	addson_227287(emptyparams_229419, emptynode_227738);
}

NIM_EXTERNC N_NOINLINE(void, HEX00_astDatInit)(void) {
static TNimNode* TMP730[5];
static TNimNode* TMP731[13];
static TNimNode* TMP732[62];
NI TMP734;
static char* NIM_CONST TMP733[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* TMP735[10];
NI TMP737;
static char* NIM_CONST TMP736[10] = {
"ccDefault", 
"ccStdCall", 
"ccCDecl", 
"ccSafeCall", 
"ccSysCall", 
"ccInline", 
"ccNoInline", 
"ccFastCall", 
"ccClosure", 
"ccNoConvention"};
static TNimNode* TMP738[28];
NI TMP740;
static char* NIM_CONST TMP739[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* TMP742[14];
static TNimNode* TMP743[26];
NI TMP745;
static char* NIM_CONST TMP744[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* TMP746[2];
static TNimNode* TMP747[4];
static TNimNode* TMP748[2];
static TNimNode* TMP752[2];
static TNimNode* TMP753[3];
static TNimNode* TMP757[2];
static TNimNode* TMP758[264];
NI TMP760;
static char* NIM_CONST TMP759[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* TMP761[32];
NI TMP763;
static char* NIM_CONST TMP762[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* TMP767[6];
static TNimNode* TMP768[12];
NI TMP770;
static char* NIM_CONST TMP769[12] = {
"locNone", 
"locTemp", 
"locLocalVar", 
"locGlobalVar", 
"locParam", 
"locField", 
"locArrayElem", 
"locExpr", 
"locProc", 
"locData", 
"locCall", 
"locOther"};
static TNimNode* TMP771[3];
NI TMP773;
static char* NIM_CONST TMP772[3] = {
"OnUnknown", 
"OnStack", 
"OnHeap"};
static TNimNode* TMP774[8];
NI TMP776;
static char* NIM_CONST TMP775[8] = {
"lfIndirect", 
"lfParamCopy", 
"lfNoDeepCopy", 
"lfNoDecl", 
"lfDynamicLib", 
"lfExportLib", 
"lfHeader", 
"lfImportCompilerProc"};
static TNimNode* TMP779[5];
static TNimNode* TMP780[2];
NI TMP782;
static char* NIM_CONST TMP781[2] = {
"libHeader", 
"libDynamic"};
static TNimNode* TMP786[13];
NI TMP788;
static char* NIM_CONST TMP787[13] = {
"nfNone", 
"nfBase2", 
"nfBase8", 
"nfBase16", 
"nfAllConst", 
"nfTransf", 
"nfSem", 
"nfLL", 
"nfDotField", 
"nfDotSetter", 
"nfExplicitCall", 
"nfExprCall", 
"nfIsRef"};
static TNimNode* TMP789[158];
NI TMP791;
static char* NIM_CONST TMP790[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* TMP826[2];
static TNimNode* TMP827[2];
static TNimNode* TMP975[2];
static TNimNode* TMP976[3];
static TNimNode* TMP3130[2];
static TNimNode* TMP3131[2];
static TNimNode TMP723[730];
NTI226816.size = sizeof(tnode226816);
NTI226816.kind = 18;
NTI226816.base = 0;
NTI226816.flags = 2;
TMP730[0] = &TMP723[1];
NTI226852.size = sizeof(ttype226852);
NTI226852.kind = 17;
NTI226852.base = (&NTI201015);
NTI226852.flags = 2;
TMP731[0] = &TMP723[3];
NTI226258.size = sizeof(NU8);
NTI226258.kind = 14;
NTI226258.base = 0;
NTI226258.flags = 3;
for (TMP734 = 0; TMP734 < 62; TMP734++) {
TMP723[TMP734+4].kind = 1;
TMP723[TMP734+4].offset = TMP734;
TMP723[TMP734+4].name = TMP733[TMP734];
TMP732[TMP734] = &TMP723[TMP734+4];
}
TMP723[66].len = 62; TMP723[66].kind = 2; TMP723[66].sons = &TMP732[0];
NTI226258.node = &TMP723[66];
TMP723[3].kind = 1;
TMP723[3].offset = offsetof(ttype226852, Kind);
TMP723[3].typ = (&NTI226258);
TMP723[3].name = "kind";
TMP731[1] = &TMP723[67];
NTI226005.size = sizeof(NU8);
NTI226005.kind = 14;
NTI226005.base = 0;
NTI226005.flags = 3;
for (TMP737 = 0; TMP737 < 10; TMP737++) {
TMP723[TMP737+68].kind = 1;
TMP723[TMP737+68].offset = TMP737;
TMP723[TMP737+68].name = TMP736[TMP737];
TMP735[TMP737] = &TMP723[TMP737+68];
}
TMP723[78].len = 10; TMP723[78].kind = 2; TMP723[78].sons = &TMP735[0];
NTI226005.node = &TMP723[78];
TMP723[67].kind = 1;
TMP723[67].offset = offsetof(ttype226852, Callconv);
TMP723[67].typ = (&NTI226005);
TMP723[67].name = "callConv";
TMP731[2] = &TMP723[79];
NTI226441.size = sizeof(NU8);
NTI226441.kind = 14;
NTI226441.base = 0;
NTI226441.flags = 3;
for (TMP740 = 0; TMP740 < 28; TMP740++) {
TMP723[TMP740+80].kind = 1;
TMP723[TMP740+80].offset = TMP740;
TMP723[TMP740+80].name = TMP739[TMP740];
TMP738[TMP740] = &TMP723[TMP740+80];
}
TMP723[108].len = 28; TMP723[108].kind = 2; TMP723[108].sons = &TMP738[0];
NTI226441.node = &TMP723[108];
NTI226443.size = sizeof(NU32);
NTI226443.kind = 19;
NTI226443.base = (&NTI226441);
NTI226443.flags = 3;
TMP723[109].len = 0; TMP723[109].kind = 0;
NTI226443.node = &TMP723[109];
TMP723[79].kind = 1;
TMP723[79].offset = offsetof(ttype226852, Flags);
TMP723[79].typ = (&NTI226443);
TMP723[79].name = "flags";
TMP731[3] = &TMP723[110];
NTI226848.size = sizeof(ttypeseq226848*);
NTI226848.kind = 24;
NTI226848.base = (&NTI226812);
NTI226848.flags = 2;
NTI226848.marker = TMP741;
TMP723[110].kind = 1;
TMP723[110].offset = offsetof(ttype226852, Sons);
TMP723[110].typ = (&NTI226848);
TMP723[110].name = "sons";
TMP731[4] = &TMP723[111];
TMP723[111].kind = 1;
TMP723[111].offset = offsetof(ttype226852, N);
TMP723[111].typ = (&NTI226808);
TMP723[111].name = "n";
TMP731[5] = &TMP723[112];
NTI226846.size = sizeof(tsym226846);
NTI226846.kind = 17;
NTI226846.base = (&NTI201015);
NTI226846.flags = 2;
TMP742[0] = &TMP723[114];
NTI226445.size = sizeof(NU8);
NTI226445.kind = 14;
NTI226445.base = 0;
NTI226445.flags = 3;
for (TMP745 = 0; TMP745 < 26; TMP745++) {
TMP723[TMP745+115].kind = 1;
TMP723[TMP745+115].offset = TMP745;
TMP723[TMP745+115].name = TMP744[TMP745];
TMP743[TMP745] = &TMP723[TMP745+115];
}
TMP723[141].len = 26; TMP723[141].kind = 2; TMP723[141].sons = &TMP743[0];
NTI226445.node = &TMP723[141];
TMP723[114].kind = 3;
TMP723[114].offset = offsetof(tsym226846, Kind);
TMP723[114].typ = (&NTI226445);
TMP723[114].name = "kind";
TMP723[114].sons = &NimDT_226846_kind[0];
TMP723[114].len = 26;
TMP746[0] = &TMP723[143];
TMP723[143].kind = 1;
TMP723[143].offset = offsetof(tsym226846, kindU.S1.Typeinstcache);
TMP723[143].typ = (&NTI226848);
TMP723[143].name = "typeInstCache";
TMP746[1] = &TMP723[144];
NTI226840.size = sizeof(tscope226840);
NTI226840.kind = 18;
NTI226840.base = 0;
TMP747[0] = &TMP723[146];
TMP723[146].kind = 1;
TMP723[146].offset = offsetof(tscope226840, Depthlevel);
TMP723[146].typ = (&NTI108);
TMP723[146].name = "depthLevel";
TMP747[1] = &TMP723[147];
NTI226820.size = sizeof(tstrtable226820);
NTI226820.kind = 18;
NTI226820.base = 0;
NTI226820.flags = 2;
TMP748[0] = &TMP723[149];
TMP723[149].kind = 1;
TMP723[149].offset = offsetof(tstrtable226820, Counter);
TMP723[149].typ = (&NTI108);
TMP723[149].name = "counter";
TMP748[1] = &TMP723[150];
NTI226818.size = sizeof(tsymseq226818*);
NTI226818.kind = 24;
NTI226818.base = (&NTI226814);
NTI226818.flags = 2;
NTI226818.marker = TMP749;
TMP723[150].kind = 1;
TMP723[150].offset = offsetof(tstrtable226820, Data);
TMP723[150].typ = (&NTI226818);
TMP723[150].name = "data";
TMP723[148].len = 2; TMP723[148].kind = 2; TMP723[148].sons = &TMP748[0];
NTI226820.node = &TMP723[148];
TMP723[147].kind = 1;
TMP723[147].offset = offsetof(tscope226840, Symbols);
TMP723[147].typ = (&NTI226820);
TMP723[147].name = "symbols";
TMP747[2] = &TMP723[151];
NTI226810.size = sizeof(tnodeseq226810*);
NTI226810.kind = 24;
NTI226810.base = (&NTI226808);
NTI226810.flags = 2;
NTI226810.marker = TMP750;
TMP723[151].kind = 1;
TMP723[151].offset = offsetof(tscope226840, Usingsyms);
TMP723[151].typ = (&NTI226810);
TMP723[151].name = "usingSyms";
TMP747[3] = &TMP723[152];
TMP723[152].kind = 1;
TMP723[152].offset = offsetof(tscope226840, Parent);
TMP723[152].typ = (&NTI226842);
TMP723[152].name = "parent";
TMP723[145].len = 4; TMP723[145].kind = 2; TMP723[145].sons = &TMP747[0];
NTI226840.node = &TMP723[145];
NTI226842.size = sizeof(tscope226840*);
NTI226842.kind = 22;
NTI226842.base = (&NTI226840);
NTI226842.marker = TMP751;
TMP723[144].kind = 1;
TMP723[144].offset = offsetof(tsym226846, kindU.S1.Typscope);
TMP723[144].typ = (&NTI226842);
TMP723[144].name = "typScope";
TMP723[142].len = 2; TMP723[142].kind = 2; TMP723[142].sons = &TMP746[0];
NimDT_226846_kind[7] = &TMP723[142];
NimDT_226846_kind[4] = &TMP723[142];
TMP752[0] = &TMP723[154];
NTI226836.size = sizeof(tinstantiation226836);
NTI226836.kind = 18;
NTI226836.base = 0;
NTI226836.flags = 2;
TMP753[0] = &TMP723[156];
TMP723[156].kind = 1;
TMP723[156].offset = offsetof(tinstantiation226836, Sym);
TMP723[156].typ = (&NTI226814);
TMP723[156].name = "sym";
TMP753[1] = &TMP723[157];
TMP723[157].kind = 1;
TMP723[157].offset = offsetof(tinstantiation226836, Concretetypes);
TMP723[157].typ = (&NTI226848);
TMP723[157].name = "concreteTypes";
TMP753[2] = &TMP723[158];
NTI226936.size = sizeof(TY226936*);
NTI226936.kind = 24;
NTI226936.base = (&NTI114);
NTI226936.flags = 2;
NTI226936.marker = TMP754;
TMP723[158].kind = 1;
TMP723[158].offset = offsetof(tinstantiation226836, Usedby);
TMP723[158].typ = (&NTI226936);
TMP723[158].name = "usedBy";
TMP723[155].len = 3; TMP723[155].kind = 2; TMP723[155].sons = &TMP753[0];
NTI226836.node = &TMP723[155];
NTI226838.size = sizeof(tinstantiation226836*);
NTI226838.kind = 22;
NTI226838.base = (&NTI226836);
NTI226838.flags = 2;
NTI226838.marker = TMP755;
NTI226947.size = sizeof(TY226947*);
NTI226947.kind = 24;
NTI226947.base = (&NTI226838);
NTI226947.flags = 2;
NTI226947.marker = TMP756;
TMP723[154].kind = 1;
TMP723[154].offset = offsetof(tsym226846, kindU.S2.Procinstcache);
TMP723[154].typ = (&NTI226947);
TMP723[154].name = "procInstCache";
TMP752[1] = &TMP723[159];
TMP723[159].kind = 1;
TMP723[159].offset = offsetof(tsym226846, kindU.S2.Scope);
TMP723[159].typ = (&NTI226842);
TMP723[159].name = "scope";
TMP723[153].len = 2; TMP723[153].kind = 2; TMP723[153].sons = &TMP752[0];
NimDT_226846_kind[12] = &TMP723[153];
NimDT_226846_kind[13] = &TMP723[153];
NimDT_226846_kind[14] = &TMP723[153];
NimDT_226846_kind[15] = &TMP723[153];
NimDT_226846_kind[16] = &TMP723[153];
NimDT_226846_kind[17] = &TMP723[153];
NimDT_226846_kind[18] = &TMP723[153];
TMP757[0] = &TMP723[161];
TMP723[161].kind = 1;
TMP723[161].offset = offsetof(tsym226846, kindU.S3.Usedgenerics);
TMP723[161].typ = (&NTI226947);
TMP723[161].name = "usedGenerics";
TMP757[1] = &TMP723[162];
TMP723[162].kind = 1;
TMP723[162].offset = offsetof(tsym226846, kindU.S3.Tab);
TMP723[162].typ = (&NTI226820);
TMP723[162].name = "tab";
TMP723[160].len = 2; TMP723[160].kind = 2; TMP723[160].sons = &TMP757[0];
NimDT_226846_kind[6] = &TMP723[160];
TMP723[163].kind = 1;
TMP723[163].offset = offsetof(tsym226846, kindU.S4.Guard);
TMP723[163].typ = (&NTI226814);
TMP723[163].name = "guard";
NimDT_226846_kind[9] = &TMP723[163];
NimDT_226846_kind[8] = &TMP723[163];
NimDT_226846_kind[19] = &TMP723[163];
NimDT_226846_kind[21] = &TMP723[163];
TMP723[164].len = 0; TMP723[164].kind = 2;
NimDT_226846_kind[26] = &TMP723[164];
TMP742[1] = &TMP723[165];
NTI226532.size = sizeof(NU16);
NTI226532.kind = 14;
NTI226532.base = 0;
NTI226532.flags = 3;
for (TMP760 = 0; TMP760 < 264; TMP760++) {
TMP723[TMP760+166].kind = 1;
TMP723[TMP760+166].offset = TMP760;
TMP723[TMP760+166].name = TMP759[TMP760];
TMP758[TMP760] = &TMP723[TMP760+166];
}
TMP723[430].len = 264; TMP723[430].kind = 2; TMP723[430].sons = &TMP758[0];
NTI226532.node = &TMP723[430];
TMP723[165].kind = 1;
TMP723[165].offset = offsetof(tsym226846, Magic);
TMP723[165].typ = (&NTI226532);
TMP723[165].name = "magic";
TMP742[2] = &TMP723[431];
TMP723[431].kind = 1;
TMP723[431].offset = offsetof(tsym226846, Typ);
TMP723[431].typ = (&NTI226812);
TMP723[431].name = "typ";
TMP742[3] = &TMP723[432];
TMP723[432].kind = 1;
TMP723[432].offset = offsetof(tsym226846, Name);
TMP723[432].typ = (&NTI201019);
TMP723[432].name = "name";
TMP742[4] = &TMP723[433];
TMP723[433].kind = 1;
TMP723[433].offset = offsetof(tsym226846, Info);
TMP723[433].typ = (&NTI196539);
TMP723[433].name = "info";
TMP742[5] = &TMP723[434];
TMP723[434].kind = 1;
TMP723[434].offset = offsetof(tsym226846, Owner);
TMP723[434].typ = (&NTI226814);
TMP723[434].name = "owner";
TMP742[6] = &TMP723[435];
NTI226194.size = sizeof(NU8);
NTI226194.kind = 14;
NTI226194.base = 0;
NTI226194.flags = 3;
for (TMP763 = 0; TMP763 < 32; TMP763++) {
TMP723[TMP763+436].kind = 1;
TMP723[TMP763+436].offset = TMP763;
TMP723[TMP763+436].name = TMP762[TMP763];
TMP761[TMP763] = &TMP723[TMP763+436];
}
TMP723[468].len = 32; TMP723[468].kind = 2; TMP723[468].sons = &TMP761[0];
NTI226194.node = &TMP723[468];
NTI226196.size = sizeof(NU32);
NTI226196.kind = 19;
NTI226196.base = (&NTI226194);
NTI226196.flags = 3;
TMP723[469].len = 0; TMP723[469].kind = 0;
NTI226196.node = &TMP723[469];
TMP723[435].kind = 1;
TMP723[435].offset = offsetof(tsym226846, Flags);
TMP723[435].typ = (&NTI226196);
TMP723[435].name = "flags";
TMP742[7] = &TMP723[470];
TMP723[470].kind = 1;
TMP723[470].offset = offsetof(tsym226846, Ast);
TMP723[470].typ = (&NTI226808);
TMP723[470].name = "ast";
TMP742[8] = &TMP723[471];
TMP723[471].kind = 1;
TMP723[471].offset = offsetof(tsym226846, Options);
TMP723[471].typ = (&NTI170016);
TMP723[471].name = "options";
TMP742[9] = &TMP723[472];
TMP723[472].kind = 1;
TMP723[472].offset = offsetof(tsym226846, Position);
TMP723[472].typ = (&NTI108);
TMP723[472].name = "position";
TMP742[10] = &TMP723[473];
TMP723[473].kind = 1;
TMP723[473].offset = offsetof(tsym226846, Offset);
TMP723[473].typ = (&NTI108);
TMP723[473].name = "offset";
TMP742[11] = &TMP723[474];
NTI226830.size = sizeof(tloc226830);
NTI226830.kind = 18;
NTI226830.base = 0;
NTI226830.flags = 2;
TMP767[0] = &TMP723[476];
NTI226822.size = sizeof(NU8);
NTI226822.kind = 14;
NTI226822.base = 0;
NTI226822.flags = 3;
for (TMP770 = 0; TMP770 < 12; TMP770++) {
TMP723[TMP770+477].kind = 1;
TMP723[TMP770+477].offset = TMP770;
TMP723[TMP770+477].name = TMP769[TMP770];
TMP768[TMP770] = &TMP723[TMP770+477];
}
TMP723[489].len = 12; TMP723[489].kind = 2; TMP723[489].sons = &TMP768[0];
NTI226822.node = &TMP723[489];
TMP723[476].kind = 1;
TMP723[476].offset = offsetof(tloc226830, K);
TMP723[476].typ = (&NTI226822);
TMP723[476].name = "k";
TMP767[1] = &TMP723[490];
NTI226826.size = sizeof(NU8);
NTI226826.kind = 14;
NTI226826.base = 0;
NTI226826.flags = 3;
for (TMP773 = 0; TMP773 < 3; TMP773++) {
TMP723[TMP773+491].kind = 1;
TMP723[TMP773+491].offset = TMP773;
TMP723[TMP773+491].name = TMP772[TMP773];
TMP771[TMP773] = &TMP723[TMP773+491];
}
TMP723[494].len = 3; TMP723[494].kind = 2; TMP723[494].sons = &TMP771[0];
NTI226826.node = &TMP723[494];
TMP723[490].kind = 1;
TMP723[490].offset = offsetof(tloc226830, S);
TMP723[490].typ = (&NTI226826);
TMP723[490].name = "s";
TMP767[2] = &TMP723[495];
NTI226824.size = sizeof(NU8);
NTI226824.kind = 14;
NTI226824.base = 0;
NTI226824.flags = 3;
for (TMP776 = 0; TMP776 < 8; TMP776++) {
TMP723[TMP776+496].kind = 1;
TMP723[TMP776+496].offset = TMP776;
TMP723[TMP776+496].name = TMP775[TMP776];
TMP774[TMP776] = &TMP723[TMP776+496];
}
TMP723[504].len = 8; TMP723[504].kind = 2; TMP723[504].sons = &TMP774[0];
NTI226824.node = &TMP723[504];
NTI226828.size = sizeof(NU8);
NTI226828.kind = 19;
NTI226828.base = (&NTI226824);
NTI226828.flags = 3;
TMP723[505].len = 0; TMP723[505].kind = 0;
NTI226828.node = &TMP723[505];
TMP723[495].kind = 1;
TMP723[495].offset = offsetof(tloc226830, Flags);
TMP723[495].typ = (&NTI226828);
TMP723[495].name = "flags";
TMP767[3] = &TMP723[506];
TMP723[506].kind = 1;
TMP723[506].offset = offsetof(tloc226830, T);
TMP723[506].typ = (&NTI226812);
TMP723[506].name = "t";
TMP767[4] = &TMP723[507];
TMP723[507].kind = 1;
TMP723[507].offset = offsetof(tloc226830, R);
TMP723[507].typ = (&NTI178007);
TMP723[507].name = "r";
TMP767[5] = &TMP723[508];
TMP723[508].kind = 1;
TMP723[508].offset = offsetof(tloc226830, Heaproot);
TMP723[508].typ = (&NTI178007);
TMP723[508].name = "heapRoot";
TMP723[475].len = 6; TMP723[475].kind = 2; TMP723[475].sons = &TMP767[0];
NTI226830.node = &TMP723[475];
TMP723[474].kind = 1;
TMP723[474].offset = offsetof(tsym226846, Loc);
TMP723[474].typ = (&NTI226830);
TMP723[474].name = "loc";
TMP742[12] = &TMP723[509];
NTI226834.size = sizeof(tlib226834);
NTI226834.kind = 17;
NTI226834.base = (&NTI127022);
TMP779[0] = &TMP723[511];
NTI226832.size = sizeof(NU8);
NTI226832.kind = 14;
NTI226832.base = 0;
NTI226832.flags = 3;
for (TMP782 = 0; TMP782 < 2; TMP782++) {
TMP723[TMP782+512].kind = 1;
TMP723[TMP782+512].offset = TMP782;
TMP723[TMP782+512].name = TMP781[TMP782];
TMP780[TMP782] = &TMP723[TMP782+512];
}
TMP723[514].len = 2; TMP723[514].kind = 2; TMP723[514].sons = &TMP780[0];
NTI226832.node = &TMP723[514];
TMP723[511].kind = 1;
TMP723[511].offset = offsetof(tlib226834, Kind);
TMP723[511].typ = (&NTI226832);
TMP723[511].name = "kind";
TMP779[1] = &TMP723[515];
TMP723[515].kind = 1;
TMP723[515].offset = offsetof(tlib226834, Generated);
TMP723[515].typ = (&NTI138);
TMP723[515].name = "generated";
TMP779[2] = &TMP723[516];
TMP723[516].kind = 1;
TMP723[516].offset = offsetof(tlib226834, Isoverriden);
TMP723[516].typ = (&NTI138);
TMP723[516].name = "isOverriden";
TMP779[3] = &TMP723[517];
TMP723[517].kind = 1;
TMP723[517].offset = offsetof(tlib226834, Name);
TMP723[517].typ = (&NTI178007);
TMP723[517].name = "name";
TMP779[4] = &TMP723[518];
TMP723[518].kind = 1;
TMP723[518].offset = offsetof(tlib226834, Path);
TMP723[518].typ = (&NTI226808);
TMP723[518].name = "path";
TMP723[510].len = 5; TMP723[510].kind = 2; TMP723[510].sons = &TMP779[0];
NTI226834.node = &TMP723[510];
NTI226844.size = sizeof(tlib226834*);
NTI226844.kind = 22;
NTI226844.base = (&NTI226834);
NTI226844.marker = TMP783;
TMP723[509].kind = 1;
TMP723[509].offset = offsetof(tsym226846, Annex);
TMP723[509].typ = (&NTI226844);
TMP723[509].name = "annex";
TMP742[13] = &TMP723[519];
TMP723[519].kind = 1;
TMP723[519].offset = offsetof(tsym226846, Constraint);
TMP723[519].typ = (&NTI226808);
TMP723[519].name = "constraint";
TMP723[113].len = 14; TMP723[113].kind = 2; TMP723[113].sons = &TMP742[0];
NTI226846.node = &TMP723[113];
NTI226814.size = sizeof(tsym226846*);
NTI226814.kind = 22;
NTI226814.base = (&NTI226846);
NTI226814.flags = 2;
NTI226814.marker = TMP784;
TMP723[112].kind = 1;
TMP723[112].offset = offsetof(ttype226852, Owner);
TMP723[112].typ = (&NTI226814);
TMP723[112].name = "owner";
TMP731[6] = &TMP723[520];
TMP723[520].kind = 1;
TMP723[520].offset = offsetof(ttype226852, Sym);
TMP723[520].typ = (&NTI226814);
TMP723[520].name = "sym";
TMP731[7] = &TMP723[521];
TMP723[521].kind = 1;
TMP723[521].offset = offsetof(ttype226852, Destructor);
TMP723[521].typ = (&NTI226814);
TMP723[521].name = "destructor";
TMP731[8] = &TMP723[522];
TMP723[522].kind = 1;
TMP723[522].offset = offsetof(ttype226852, Deepcopy);
TMP723[522].typ = (&NTI226814);
TMP723[522].name = "deepCopy";
TMP731[9] = &TMP723[523];
TMP723[523].kind = 1;
TMP723[523].offset = offsetof(ttype226852, Size);
TMP723[523].typ = (&NTI5510);
TMP723[523].name = "size";
TMP731[10] = &TMP723[524];
TMP723[524].kind = 1;
TMP723[524].offset = offsetof(ttype226852, Align);
TMP723[524].typ = (&NTI112);
TMP723[524].name = "align";
TMP731[11] = &TMP723[525];
TMP723[525].kind = 1;
TMP723[525].offset = offsetof(ttype226852, Locklevel);
TMP723[525].typ = (&NTI112);
TMP723[525].name = "lockLevel";
TMP731[12] = &TMP723[526];
TMP723[526].kind = 1;
TMP723[526].offset = offsetof(ttype226852, Loc);
TMP723[526].typ = (&NTI226830);
TMP723[526].name = "loc";
TMP723[2].len = 13; TMP723[2].kind = 2; TMP723[2].sons = &TMP731[0];
NTI226852.node = &TMP723[2];
NTI226812.size = sizeof(ttype226852*);
NTI226812.kind = 22;
NTI226812.base = (&NTI226852);
NTI226812.flags = 2;
NTI226812.marker = TMP785;
TMP723[1].kind = 1;
TMP723[1].offset = offsetof(tnode226816, Typ);
TMP723[1].typ = (&NTI226812);
TMP723[1].name = "typ";
TMP730[1] = &TMP723[527];
TMP723[527].kind = 1;
TMP723[527].offset = offsetof(tnode226816, Info);
TMP723[527].typ = (&NTI196539);
TMP723[527].name = "info";
TMP730[2] = &TMP723[528];
NTI226437.size = sizeof(NU8);
NTI226437.kind = 14;
NTI226437.base = 0;
NTI226437.flags = 3;
for (TMP788 = 0; TMP788 < 13; TMP788++) {
TMP723[TMP788+529].kind = 1;
TMP723[TMP788+529].offset = TMP788;
TMP723[TMP788+529].name = TMP787[TMP788];
TMP786[TMP788] = &TMP723[TMP788+529];
}
TMP723[542].len = 13; TMP723[542].kind = 2; TMP723[542].sons = &TMP786[0];
NTI226437.node = &TMP723[542];
NTI226439.size = sizeof(NU16);
NTI226439.kind = 19;
NTI226439.base = (&NTI226437);
NTI226439.flags = 3;
TMP723[543].len = 0; TMP723[543].kind = 0;
NTI226439.node = &TMP723[543];
TMP723[528].kind = 1;
TMP723[528].offset = offsetof(tnode226816, Flags);
TMP723[528].typ = (&NTI226439);
TMP723[528].name = "flags";
TMP730[3] = &TMP723[544];
NTI226029.size = sizeof(NU8);
NTI226029.kind = 14;
NTI226029.base = 0;
NTI226029.flags = 3;
for (TMP791 = 0; TMP791 < 158; TMP791++) {
TMP723[TMP791+545].kind = 1;
TMP723[TMP791+545].offset = TMP791;
TMP723[TMP791+545].name = TMP790[TMP791];
TMP789[TMP791] = &TMP723[TMP791+545];
}
TMP723[703].len = 158; TMP723[703].kind = 2; TMP723[703].sons = &TMP789[0];
NTI226029.node = &TMP723[703];
TMP723[544].kind = 3;
TMP723[544].offset = offsetof(tnode226816, Kind);
TMP723[544].typ = (&NTI226029);
TMP723[544].name = "kind";
TMP723[544].sons = &NimDT_226816_kind[0];
TMP723[544].len = 158;
TMP723[704].kind = 1;
TMP723[704].offset = offsetof(tnode226816, kindU.S1.Intval);
TMP723[704].typ = (&NTI5510);
TMP723[704].name = "intVal";
NimDT_226816_kind[5] = &TMP723[704];
NimDT_226816_kind[6] = &TMP723[704];
NimDT_226816_kind[7] = &TMP723[704];
NimDT_226816_kind[8] = &TMP723[704];
NimDT_226816_kind[9] = &TMP723[704];
NimDT_226816_kind[10] = &TMP723[704];
NimDT_226816_kind[11] = &TMP723[704];
NimDT_226816_kind[12] = &TMP723[704];
NimDT_226816_kind[13] = &TMP723[704];
NimDT_226816_kind[14] = &TMP723[704];
NimDT_226816_kind[15] = &TMP723[704];
TMP723[705].kind = 1;
TMP723[705].offset = offsetof(tnode226816, kindU.S2.Floatval);
TMP723[705].typ = (&NTI5512);
TMP723[705].name = "floatVal";
NimDT_226816_kind[16] = &TMP723[705];
NimDT_226816_kind[17] = &TMP723[705];
NimDT_226816_kind[18] = &TMP723[705];
NimDT_226816_kind[19] = &TMP723[705];
TMP723[706].kind = 1;
TMP723[706].offset = offsetof(tnode226816, kindU.S3.Strval);
TMP723[706].typ = (&NTI149);
TMP723[706].name = "strVal";
NimDT_226816_kind[20] = &TMP723[706];
NimDT_226816_kind[21] = &TMP723[706];
NimDT_226816_kind[22] = &TMP723[706];
TMP723[707].kind = 1;
TMP723[707].offset = offsetof(tnode226816, kindU.S4.Sym);
TMP723[707].typ = (&NTI226814);
TMP723[707].name = "sym";
NimDT_226816_kind[3] = &TMP723[707];
TMP723[708].kind = 1;
TMP723[708].offset = offsetof(tnode226816, kindU.S5.Ident);
TMP723[708].typ = (&NTI201019);
TMP723[708].name = "ident";
NimDT_226816_kind[2] = &TMP723[708];
TMP723[709].kind = 1;
TMP723[709].offset = offsetof(tnode226816, kindU.S6.Sons);
TMP723[709].typ = (&NTI226810);
TMP723[709].name = "sons";
NimDT_226816_kind[158] = &TMP723[709];
TMP730[4] = &TMP723[710];
TMP723[710].kind = 1;
TMP723[710].offset = offsetof(tnode226816, Comment);
TMP723[710].typ = (&NTI149);
TMP723[710].name = "comment";
TMP723[0].len = 5; TMP723[0].kind = 2; TMP723[0].sons = &TMP730[0];
NTI226816.node = &TMP723[0];
NTI226808.size = sizeof(tnode226816*);
NTI226808.kind = 22;
NTI226808.base = (&NTI226816);
NTI226808.flags = 2;
NTI226808.marker = TMP792;
NTI226864.size = sizeof(tidtable226864);
NTI226864.kind = 18;
NTI226864.base = 0;
TMP826[0] = &TMP723[712];
TMP723[712].kind = 1;
TMP723[712].offset = offsetof(tidtable226864, Counter);
TMP723[712].typ = (&NTI108);
TMP723[712].name = "counter";
TMP826[1] = &TMP723[713];
NTI226860.size = sizeof(tidpair226860);
NTI226860.kind = 18;
NTI226860.base = 0;
TMP827[0] = &TMP723[715];
TMP723[715].kind = 1;
TMP723[715].offset = offsetof(tidpair226860, Key);
TMP723[715].typ = (&NTI201017);
TMP723[715].name = "key";
TMP827[1] = &TMP723[716];
TMP723[716].kind = 1;
TMP723[716].offset = offsetof(tidpair226860, Val);
TMP723[716].typ = (&NTI3213);
TMP723[716].name = "val";
TMP723[714].len = 2; TMP723[714].kind = 2; TMP723[714].sons = &TMP827[0];
NTI226860.node = &TMP723[714];
NTI226862.size = sizeof(tidpairseq226862*);
NTI226862.kind = 24;
NTI226862.base = (&NTI226860);
NTI226862.marker = TMP830;
TMP723[713].kind = 1;
TMP723[713].offset = offsetof(tidtable226864, Data);
TMP723[713].typ = (&NTI226862);
TMP723[713].name = "data";
TMP723[711].len = 2; TMP723[711].kind = 2; TMP723[711].sons = &TMP826[0];
NTI226864.node = &TMP723[711];
NTI226876.size = sizeof(tnodetable226876);
NTI226876.kind = 18;
NTI226876.base = 0;
NTI226876.flags = 2;
TMP975[0] = &TMP723[718];
TMP723[718].kind = 1;
TMP723[718].offset = offsetof(tnodetable226876, Counter);
TMP723[718].typ = (&NTI108);
TMP723[718].name = "counter";
TMP975[1] = &TMP723[719];
NTI226872.size = sizeof(tnodepair226872);
NTI226872.kind = 18;
NTI226872.base = 0;
NTI226872.flags = 2;
TMP976[0] = &TMP723[721];
TMP723[721].kind = 1;
TMP723[721].offset = offsetof(tnodepair226872, H);
TMP723[721].typ = (&NTI128021);
TMP723[721].name = "h";
TMP976[1] = &TMP723[722];
TMP723[722].kind = 1;
TMP723[722].offset = offsetof(tnodepair226872, Key);
TMP723[722].typ = (&NTI226808);
TMP723[722].name = "key";
TMP976[2] = &TMP723[723];
TMP723[723].kind = 1;
TMP723[723].offset = offsetof(tnodepair226872, Val);
TMP723[723].typ = (&NTI108);
TMP723[723].name = "val";
TMP723[720].len = 3; TMP723[720].kind = 2; TMP723[720].sons = &TMP976[0];
NTI226872.node = &TMP723[720];
NTI226874.size = sizeof(tnodepairseq226874*);
NTI226874.kind = 24;
NTI226874.base = (&NTI226872);
NTI226874.flags = 2;
NTI226874.marker = TMP977;
TMP723[719].kind = 1;
TMP723[719].offset = offsetof(tnodetable226876, Data);
TMP723[719].typ = (&NTI226874);
TMP723[719].name = "data";
TMP723[717].len = 2; TMP723[717].kind = 2; TMP723[717].sons = &TMP975[0];
NTI226876.node = &TMP723[717];
NTI457221.size = sizeof(tnode226816**);
NTI457221.kind = 21;
NTI457221.base = (&NTI226808);
NTI457221.flags = 3;
NTI226870.size = sizeof(tidnodetable226870);
NTI226870.kind = 18;
NTI226870.base = 0;
TMP3130[0] = &TMP723[725];
TMP723[725].kind = 1;
TMP723[725].offset = offsetof(tidnodetable226870, Counter);
TMP723[725].typ = (&NTI108);
TMP723[725].name = "counter";
TMP3130[1] = &TMP723[726];
NTI226866.size = sizeof(tidnodepair226866);
NTI226866.kind = 18;
NTI226866.base = 0;
TMP3131[0] = &TMP723[728];
TMP723[728].kind = 1;
TMP723[728].offset = offsetof(tidnodepair226866, Key);
TMP723[728].typ = (&NTI201017);
TMP723[728].name = "key";
TMP3131[1] = &TMP723[729];
TMP723[729].kind = 1;
TMP723[729].offset = offsetof(tidnodepair226866, Val);
TMP723[729].typ = (&NTI226808);
TMP723[729].name = "val";
TMP723[727].len = 2; TMP723[727].kind = 2; TMP723[727].sons = &TMP3131[0];
NTI226866.node = &TMP723[727];
NTI226868.size = sizeof(tidnodepairseq226868*);
NTI226868.kind = 24;
NTI226868.base = (&NTI226866);
NTI226868.marker = TMP3132;
TMP723[726].kind = 1;
TMP723[726].offset = offsetof(tidnodetable226870, Data);
TMP723[726].typ = (&NTI226868);
TMP723[726].name = "data";
TMP723[724].len = 2; TMP723[724].kind = 2; TMP723[724].sons = &TMP3130[0];
NTI226870.node = &TMP723[724];
}

