/* Generated by Nimrod Compiler v0.9.5 */
/*   (c) 2014 Andreas Rumpf */
/* The generated code is subject to the original license. */
/* Compiled for: Linux, i386, gcc */
/* Command for C compiler:
   gcc -c  -w -O3 -fno-strict-aliasing  -I/build/nimrod/src/nimrod/lib -o compiler/nimcache/ast.o compiler/nimcache/ast.c */
#define NIM_INTBITS 32
#include "nimbase.h"

#include <string.h>
typedef struct tnode188803 tnode188803;
typedef struct tcell41090 tcell41090;
typedef struct TNimType TNimType;
typedef struct tcellseq41106 tcellseq41106;
typedef struct tgcheap43016 tgcheap43016;
typedef struct tcellset41102 tcellset41102;
typedef struct tpagedesc41098 tpagedesc41098;
typedef struct tmemregion23410 tmemregion23410;
typedef struct tsmallchunk22638 tsmallchunk22638;
typedef struct tllchunk23404 tllchunk23404;
typedef struct tbigchunk22640 tbigchunk22640;
typedef struct tintset22615 tintset22615;
typedef struct ttrunk22611 ttrunk22611;
typedef struct tavlnode23408 tavlnode23408;
typedef struct tgcstat43014 tgcstat43014;
typedef struct tsym188833 tsym188833;
typedef struct tident167019 tident167019;
typedef struct NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
typedef struct tlineinfo163527 tlineinfo163527;
typedef struct ttype188837 ttype188837;
typedef struct tnodeseq188797 tnodeseq188797;
typedef struct TNimNode TNimNode;
typedef struct tidobj167013 tidobj167013;
typedef struct TNimObject TNimObject;
typedef struct ttypeseq188835 ttypeseq188835;
typedef struct tloc188817 tloc188817;
typedef struct trope145007 trope145007;
typedef struct tscope188827 tscope188827;
typedef struct TY188933 TY188933;
typedef struct tinstantiation188823 tinstantiation188823;
typedef struct tstrtable188807 tstrtable188807;
typedef struct tsymseq188805 tsymseq188805;
typedef struct tlib188821 tlib188821;
typedef struct TY188922 TY188922;
typedef struct tlistentry118017 tlistentry118017;
typedef struct tidtable188849 tidtable188849;
typedef struct tidpairseq188847 tidpairseq188847;
typedef struct tidpair188845 tidpair188845;
typedef struct tnodetable188861 tnodetable188861;
typedef struct tnodepairseq188859 tnodepairseq188859;
typedef struct tnodepair188857 tnodepair188857;
typedef struct tidnodetable188855 tidnodetable188855;
typedef struct tidnodepairseq188853 tidnodepairseq188853;
typedef struct tidnodepair188851 tidnodepair188851;
typedef struct TY79484 TY79484;
typedef struct tbasechunk22636 tbasechunk22636;
typedef struct tfreecell22628 tfreecell22628;
struct  tcell41090  {
NI Refcount;
TNimType* Typ;
};
struct  tcellseq41106  {
NI Len;
NI Cap;
tcell41090** D;
};
struct  tcellset41102  {
NI Counter;
NI Max;
tpagedesc41098* Head;
tpagedesc41098** Data;
};
typedef tsmallchunk22638* TY23422[512];
typedef ttrunk22611* ttrunkbuckets22613[256];
struct  tintset22615  {
ttrunkbuckets22613 Data;
};
struct  tmemregion23410  {
NI Minlargeobj;
NI Maxlargeobj;
TY23422 Freesmallchunks;
tllchunk23404* Llmem;
NI Currmem;
NI Maxmem;
NI Freemem;
NI Lastsize;
tbigchunk22640* Freechunkslist;
tintset22615 Chunkstarts;
tavlnode23408* Root;
tavlnode23408* Deleted;
tavlnode23408* Last;
tavlnode23408* Freeavlnodes;
};
struct  tgcstat43014  {
NI Stackscans;
NI Cyclecollections;
NI Maxthreshold;
NI Maxstacksize;
NI Maxstackcells;
NI Cycletablesize;
NI64 Maxpause;
};
struct  tgcheap43016  {
void* Stackbottom;
NI Cyclethreshold;
tcellseq41106 Zct;
tcellseq41106 Decstack;
tcellset41102 Cycleroots;
tcellseq41106 Tempstack;
NI Recgclock;
tmemregion23410 Region;
tgcstat43014 Stat;
};
struct  TGenericSeq  {
NI len;
NI reserved;
};
struct  NimStringDesc  {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
struct  tlineinfo163527  {
NI16 Line;
NI16 Col;
NI32 Fileindex;
};
struct  tnode188803  {
ttype188837* Typ;
tlineinfo163527 Info;
NU16 Flags;
NU8 Kind;
union {
struct {NI64 Intval;
} S1;
struct {NF Floatval;
} S2;
struct {NimStringDesc* Strval;
} S3;
struct {tsym188833* Sym;
} S4;
struct {tident167019* Ident;
} S5;
struct {tnodeseq188797* Sons;
} S6;
} kindU;
NimStringDesc* Comment;
};
typedef N_NIMCALL_PTR(void, TY2289) (void* p, NI op);
struct  TNimType  {
NI size;
NU8 kind;
NU8 flags;
TNimType* base;
TNimNode* node;
void* finalizer;
TY2289 marker;
};
struct  TNimNode  {
NU8 kind;
NI offset;
TNimType* typ;
NCSTRING name;
NI len;
TNimNode** sons;
};
struct  TNimObject  {
TNimType* m_type;
};
struct  tidobj167013  {
  TNimObject Sup;
NI Id;
};
struct  tloc188817  {
NU8 K;
NU8 S;
NU8 Flags;
ttype188837* T;
trope145007* R;
trope145007* Heaproot;
NI A;
};
struct  ttype188837  {
  tidobj167013 Sup;
NU8 Kind;
NU8 Callconv;
NU32 Flags;
ttypeseq188835* Sons;
tnode188803* N;
tsym188833* Destructor;
tsym188833* Owner;
tsym188833* Sym;
NI64 Size;
NI Align;
tloc188817 Loc;
};
struct  tstrtable188807  {
NI Counter;
tsymseq188805* Data;
};
struct  tsym188833  {
  tidobj167013 Sup;
NU8 Kind;
union {
struct {ttypeseq188835* Typeinstcache;
tscope188827* Typscope;
} S1;
struct {TY188933* Procinstcache;
tscope188827* Scope;
} S2;
struct {TY188933* Usedgenerics;
tstrtable188807 Tab;
} S3;
} kindU;
NU16 Magic;
ttype188837* Typ;
tident167019* Name;
tlineinfo163527 Info;
tsym188833* Owner;
NU32 Flags;
tnode188803* Ast;
NU32 Options;
NI Position;
NI Offset;
tloc188817 Loc;
tlib188821* Annex;
tnode188803* Constraint;
};
struct  tscope188827  {
NI Depthlevel;
tstrtable188807 Symbols;
tnodeseq188797* Usingsyms;
tscope188827* Parent;
};
struct  tinstantiation188823  {
tsym188833* Sym;
ttypeseq188835* Concretetypes;
TY188922* Usedby;
};
struct  tlistentry118017  {
  TNimObject Sup;
tlistentry118017* Prev;
tlistentry118017* Next;
};
struct  tlib188821  {
  tlistentry118017 Sup;
NU8 Kind;
NIM_BOOL Generated;
NIM_BOOL Isoverriden;
trope145007* Name;
tnode188803* Path;
};
struct  tidpair188845  {
tidobj167013* Key;
TNimObject* Val;
};
struct  tidtable188849  {
NI Counter;
tidpairseq188847* Data;
};
struct  tnodepair188857  {
NI H;
tnode188803* Key;
NI Val;
};
struct  tnodetable188861  {
NI Counter;
tnodepairseq188859* Data;
};
typedef tnode188803* TY191256[7];
typedef NimStringDesc* TY188016[10];
typedef tnode188803* TY207692[1];
struct  tidnodepair188851  {
tidobj167013* Key;
tnode188803* Val;
};
struct  tidnodetable188855  {
NI Counter;
tidnodepairseq188853* Data;
};
struct TY79484 {
NimStringDesc* Field0;
NI Field1;
};
typedef NU8 TY439854[20];
typedef NI TY22618[16];
struct  tpagedesc41098  {
tpagedesc41098* Next;
NI Key;
TY22618 Bits;
};
struct  tbasechunk22636  {
NI Prevsize;
NI Size;
NIM_BOOL Used;
};
struct  tsmallchunk22638  {
  tbasechunk22636 Sup;
tsmallchunk22638* Next;
tsmallchunk22638* Prev;
tfreecell22628* Freelist;
NI Free;
NI Acc;
NF Data;
};
struct  tllchunk23404  {
NI Size;
NI Acc;
tllchunk23404* Next;
};
struct  tbigchunk22640  {
  tbasechunk22636 Sup;
tbigchunk22640* Next;
tbigchunk22640* Prev;
NI Align;
NF Data;
};
struct  ttrunk22611  {
ttrunk22611* Next;
NI Key;
TY22618 Bits;
};
typedef tavlnode23408* TY23414[2];
struct  tavlnode23408  {
TY23414 Link;
NI Key;
NI Upperbound;
NI Level;
};
struct  tident167019  {
  tidobj167013 Sup;
NimStringDesc* S;
tident167019* Next;
NI H;
};
struct  trope145007  {
  TNimObject Sup;
trope145007* Left;
trope145007* Right;
NI Length;
NimStringDesc* Data;
};
struct  tfreecell22628  {
tfreecell22628* Next;
NI Zerofield;
};
struct tnodeseq188797 {
  TGenericSeq Sup;
  tnode188803* data[SEQ_DECL_SIZE];
};
struct ttypeseq188835 {
  TGenericSeq Sup;
  ttype188837* data[SEQ_DECL_SIZE];
};
struct TY188933 {
  TGenericSeq Sup;
  tinstantiation188823* data[SEQ_DECL_SIZE];
};
struct tsymseq188805 {
  TGenericSeq Sup;
  tsym188833* data[SEQ_DECL_SIZE];
};
struct TY188922 {
  TGenericSeq Sup;
  NI32 data[SEQ_DECL_SIZE];
};
struct tidpairseq188847 {
  TGenericSeq Sup;
  tidpair188845 data[SEQ_DECL_SIZE];
};
struct tnodepairseq188859 {
  TGenericSeq Sup;
  tnodepair188857 data[SEQ_DECL_SIZE];
};
struct tidnodepairseq188853 {
  TGenericSeq Sup;
  tidnodepair188851 data[SEQ_DECL_SIZE];
};
static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src);
static N_INLINE(tcell41090*, usrtocell_44443)(void* usr);
static N_INLINE(void, rtladdzct_46002)(tcell41090* c);
N_NOINLINE(void, addzct_44418)(tcellseq41106* s, tcell41090* c);
N_NIMCALL(tident167019*, getident_167456)(NimStringDesc* identifier);
N_NIMCALL(tlineinfo163527, unknownlineinfo_164203)(void);
N_NIMCALL(tnode188803*, newnode_189065)(NU8 kind);
N_NIMCALL(void, nimGCvisit)(void* d, NI op);
N_NIMCALL(void, TMP731)(void* p, NI op);
N_NIMCALL(void, TMP739)(void* p, NI op);
N_NIMCALL(void, TMP740)(void* p, NI op);
N_NIMCALL(void, TMP741)(void* p, NI op);
N_NIMCALL(void, TMP744)(void* p, NI op);
N_NIMCALL(void, TMP745)(void* p, NI op);
N_NIMCALL(void, TMP746)(void* p, NI op);
N_NIMCALL(void, TMP773)(void* p, NI op);
N_NIMCALL(void, TMP774)(void* p, NI op);
N_NIMCALL(void, TMP775)(void* p, NI op);
N_NIMCALL(void, TMP782)(void* p, NI op);
N_NIMCALL(void*, newObj)(TNimType* typ, NI size);
N_NIMCALL(void, TMP820)(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_187402)(void);
N_NIMCALL(void, TMP956)(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(tnode188803*, newnodei_189099)(NU8 kind, tlineinfo163527 info);
N_NIMCALL(void, genericSeqAssign)(void* dest, void* src_74604, TNimType* mt);
N_NIMCALL(void, propagatetoowner_192852)(ttype188837* owner, ttype188837* elem);
N_NIMCALL(NIM_BOOL, ismetatype_189732)(ttype188837* t);
static N_INLINE(NIM_BOOL, isgcedmem_192814)(ttype188837* t);
N_NIMCALL(NimStringDesc*, copyStringRC1)(NimStringDesc* src);
static N_INLINE(ttype188837*, lastson_189193)(ttype188837* n);
static N_INLINE(NI, sonslen_189185)(ttype188837* n);
static N_INLINE(void, asgnRef)(void** dest, void* src);
static N_INLINE(void, incref_46827)(tcell41090* c);
static N_INLINE(NIM_BOOL, canbecycleroot_44462)(tcell41090* c);
static N_INLINE(void, rtladdcycleroot_45235)(tcell41090* c);
N_NOINLINE(void, incl_41855)(tcellset41102* s, tcell41090* cell);
static N_INLINE(void, decref_46402)(tcell41090* c);
N_NIMCALL(void, mergeloc_191403)(tloc188817* a, tloc188817* b);
N_NIMCALL(void, newsons_189202)(ttype188837* father, NI length);
N_NIMCALL(TGenericSeq*, setLengthSeq)(TGenericSeq* seq, NI elemsize, NI newlen);
N_NIMCALL(ttype188837*, newtype_189060)(NU8 kind, tsym188833* owner);
N_NIMCALL(void, assigntype_189152)(ttype188837* dest, ttype188837* src);
N_NIMCALL(tsym188833*, newsym_189053)(NU8 symkind, tident167019* name, tsym188833* owner, tlineinfo163527 info);
N_NIMCALL(void, copystrtable_189157)(tstrtable188807* dest, tstrtable188807 src);
N_NIMCALL(void, genericAssign)(void* dest, void* src, TNimType* mt);
N_NIMCALL(void, initstrtable_189110)(tstrtable188807* x);
static N_INLINE(NI, sonslen_189181)(tnode188803* n);
N_NIMCALL(tnode188803*, copytree_189237)(tnode188803* src);
N_NIMCALL(tnode188803*, newintnode_189069)(NU8 kind, NI64 intval);
static N_INLINE(tnode188803*, HEX5BHEX5D_189694)(tnode188803* n, NI i);
N_NIMCALL(void, internalerror_165591)(tlineinfo163527 info, NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, copyString)(NimStringDesc* src);
N_NIMCALL(NimStringDesc*, nimCharToStr)(NIM_CHAR x);
N_NIMCALL(void, TMP2937)(void* p, NI op);
N_NIMCALL(void, internalerror_165606)(NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, HEX24_165714)(TY79484 x_165718);
N_NIMCALL(NIM_BOOL, containsnode_194562)(tnode188803* n, TY439854 kinds);
N_NIMCALL(NIM_BOOL, hassubnodewith_189222)(tnode188803* n, NU8 kind);
N_NIMCALL(void, addson_189207)(tnode188803* father, tnode188803* son);
STRING_LITERAL(TMP719, "*", 1);
TNimNode* NimDT_tsym_kind[26];
TNimNode* NimDT_tnode_kind[158];
STRING_LITERAL(TMP1966, "", 0);
STRING_LITERAL(TMP1967, "stdcall", 7);
STRING_LITERAL(TMP1968, "cdecl", 5);
STRING_LITERAL(TMP1969, "safecall", 8);
STRING_LITERAL(TMP1970, "syscall", 7);
STRING_LITERAL(TMP1971, "inline", 6);
STRING_LITERAL(TMP1972, "noinline", 8);
STRING_LITERAL(TMP1973, "fastcall", 8);
STRING_LITERAL(TMP1974, "closure", 7);
STRING_LITERAL(TMP1975, "noconv", 6);
NIM_CONST TY188016 callingconvtostr_188015 = {((NimStringDesc*) &TMP1966),
((NimStringDesc*) &TMP1967),
((NimStringDesc*) &TMP1968),
((NimStringDesc*) &TMP1969),
((NimStringDesc*) &TMP1970),
((NimStringDesc*) &TMP1971),
((NimStringDesc*) &TMP1972),
((NimStringDesc*) &TMP1973),
((NimStringDesc*) &TMP1974),
((NimStringDesc*) &TMP1975)}
;
STRING_LITERAL(TMP2912, "getInt", 6);
STRING_LITERAL(TMP2913, "getFloat", 8);
STRING_LITERAL(TMP2914, "getStr", 6);
STRING_LITERAL(TMP2917, "getStrOrChar", 12);
STRING_LITERAL(TMP2981, "compiler/ast.nim", 16);
NIM_CONST TY79484 TMP2980 = {((NimStringDesc*) &TMP2981),
1504}
;
tnode188803* emptynode_189727;
extern tgcheap43016 gch_43044;
tsym188833* anyglobal_189730;
tnode188803* emptyparams_191211;
TNimType NTI188803; /* TNode */
extern TNimType NTI167013; /* TIdObj */
TNimType NTI188837; /* TType */
TNimType NTI188240; /* TTypeKind */
TNimType NTI188003; /* TCallingConvention */
TNimType NTI188437; /* TTypeFlag */
TNimType NTI188439; /* TTypeFlags */
TNimType NTI188835; /* TTypeSeq */
TNimType NTI188833; /* TSym */
TNimType NTI188441; /* TSymKind */
TNimType NTI188827; /* TScope */
extern TNimType NTI106; /* int */
TNimType NTI188807; /* TStrTable */
TNimType NTI188805; /* TSymSeq */
TNimType NTI188797; /* TNodeSeq */
TNimType NTI188829; /* PScope */
TNimType NTI188823; /* TInstantiation */
extern TNimType NTI112; /* int32 */
TNimType NTI188922; /* seq[int32] */
TNimType NTI188825; /* PInstantiation */
TNimType NTI188933; /* seq[PInstantiation] */
TNimType NTI188521; /* TMagic */
extern TNimType NTI167017; /* PIdent */
extern TNimType NTI163527; /* TLineInfo */
TNimType NTI188185; /* TSymFlag */
TNimType NTI188187; /* TSymFlags */
extern TNimType NTI137012; /* TOptions */
TNimType NTI188817; /* TLoc */
TNimType NTI188809; /* TLocKind */
TNimType NTI188813; /* TStorageLoc */
TNimType NTI188811; /* TLocFlag */
TNimType NTI188815; /* TLocFlags */
extern TNimType NTI145005; /* PRope */
extern TNimType NTI118017; /* TListEntry */
TNimType NTI188821; /* TLib */
TNimType NTI188819; /* TLibKind */
extern TNimType NTI134; /* bool */
TNimType NTI188831; /* PLib */
TNimType NTI188801; /* PSym */
extern TNimType NTI4289; /* BiggestInt */
TNimType NTI188799; /* PType */
TNimType NTI188433; /* TNodeFlag */
TNimType NTI188435; /* TNodeFlags */
TNimType NTI188023; /* TNodeKind */
extern TNimType NTI4291; /* BiggestFloat */
extern TNimType NTI143; /* string */
TNimType NTI188795; /* PNode */
TNimType NTI188849; /* TIdTable */
TNimType NTI188845; /* TIdPair */
extern TNimType NTI167015; /* PIdObj */
extern TNimType NTI2411; /* PObject */
TNimType NTI188847; /* TIdPairSeq */
extern NU32 goptions_137108;
extern NI gfrontendid_187007;
TNimType NTI188861; /* TNodeTable */
TNimType NTI188857; /* TNodePair */
extern TNimType NTI119013; /* THash */
TNimType NTI188859; /* TNodePairSeq */
TNimType NTI391221; /* ptr PNode */
TNimType NTI188855; /* TIdNodeTable */
TNimType NTI188851; /* TIdNodePair */
TNimType NTI188853; /* TIdNodePairSeq */

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

static N_INLINE(void, rtladdzct_46002)(tcell41090* c) {
	addzct_44418(&gch_43044.Zct, c);
}

static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src) {
	{
		tcell41090* c;
		if (!!((src == NIM_NIL))) goto LA3;
		c = usrtocell_44443(src);
		(*c).Refcount += 8;
	}
	LA3: ;
	{
		tcell41090* c;
		if (!!(((*dest) == NIM_NIL))) goto LA7;
		c = usrtocell_44443((*dest));
		{
			(*c).Refcount -= 8;
			if (!((NU32)((*c).Refcount) < (NU32)(8))) goto LA11;
			rtladdzct_46002(c);
		}
		LA11: ;
	}
	LA7: ;
	(*dest) = src;
}
N_NIMCALL(void, TMP731)(void* p, NI op) {
	ttypeseq188835* a;
	NI LOC1;
	a = (ttypeseq188835*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP739)(void* p, NI op) {
	tsymseq188805* a;
	NI LOC1;
	a = (tsymseq188805*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP740)(void* p, NI op) {
	tnodeseq188797* a;
	NI LOC1;
	a = (tnodeseq188797*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP741)(void* p, NI op) {
	tscope188827* a;
	a = (tscope188827*)p;
	nimGCvisit((void*)(*a).Symbols.Data, op);
	nimGCvisit((void*)(*a).Usingsyms, op);
	nimGCvisit((void*)(*a).Parent, op);
}
N_NIMCALL(void, TMP744)(void* p, NI op) {
	TY188922* a;
	NI LOC1;
	a = (TY188922*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	}
}
N_NIMCALL(void, TMP745)(void* p, NI op) {
	tinstantiation188823* a;
	a = (tinstantiation188823*)p;
	nimGCvisit((void*)(*a).Sym, op);
	nimGCvisit((void*)(*a).Concretetypes, op);
	nimGCvisit((void*)(*a).Usedby, op);
}
N_NIMCALL(void, TMP746)(void* p, NI op) {
	TY188933* a;
	NI LOC1;
	a = (TY188933*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1], op);
	}
}
N_NIMCALL(void, TMP773)(void* p, NI op) {
	tlib188821* a;
	a = (tlib188821*)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, TMP774)(void* p, NI op) {
	tsym188833* a;
	a = (tsym188833*)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;
	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, TMP775)(void* p, NI op) {
	ttype188837* a;
	a = (ttype188837*)p;
	nimGCvisit((void*)(*a).Sons, op);
	nimGCvisit((void*)(*a).N, op);
	nimGCvisit((void*)(*a).Destructor, op);
	nimGCvisit((void*)(*a).Owner, op);
	nimGCvisit((void*)(*a).Sym, op);
	nimGCvisit((void*)(*a).Loc.T, op);
	nimGCvisit((void*)(*a).Loc.R, op);
	nimGCvisit((void*)(*a).Loc.Heaproot, op);
}
N_NIMCALL(void, TMP782)(void* p, NI op) {
	tnode188803* a;
	a = (tnode188803*)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(tnode188803*, newnode_189065)(NU8 kind) {
	tnode188803* result;
	result = 0;
	result = (tnode188803*) newObj((&NTI188795), sizeof(tnode188803));
	(*result).Kind = kind;
	(*result).Info.Fileindex = ((NI32) -1);
	(*result).Info.Col = ((NI16) -1);
	(*result).Info.Line = ((NI16) -1);
	return result;
}
N_NIMCALL(void, TMP820)(void* p, NI op) {
	tidpairseq188847* a;
	NI LOC1;
	a = (tidpairseq188847*)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_189120)(tidtable188849* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) &(*x).Data, (tidpairseq188847*) newSeq((&NTI188847), 8));
}

N_NIMCALL(void, initstrtable_189110)(tstrtable188807* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) &(*x).Data, (tsymseq188805*) newSeq((&NTI188805), 8));
}

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

N_NIMCALL(tsym188833*, newsym_189053)(NU8 symkind, tident167019* name, tsym188833* owner, tlineinfo163527 info) {
	tsym188833* result;
	result = 0;
	result = (tsym188833*) newObj((&NTI188801), sizeof(tsym188833));
	(*result).Sup.Sup.m_type = (&NTI188833);
	asgnRefNoCycle((void**) &(*result).Name, name);
	(*result).Kind = symkind;
	(*result).Flags = 0;
	(*result).Info = info;
	(*result).Options = goptions_137108;
	asgnRefNoCycle((void**) &(*result).Owner, owner);
	(*result).Offset = -1;
	(*result).Sup.Id = getid_187402();
	return result;
}

N_NIMCALL(tnode188803*, newidentnode_189090)(tident167019* ident, tlineinfo163527 info) {
	tnode188803* result;
	result = 0;
	result = newnode_189065(((NU8) 2));
	asgnRefNoCycle((void**) &(*result).kindU.S5.Ident, ident);
	(*result).Info = info;
	return result;
}
N_NIMCALL(void, TMP956)(void* p, NI op) {
	tnodepairseq188859* a;
	NI LOC1;
	a = (tnodepairseq188859*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1].Key, op);
	}
}

N_NIMCALL(tnode188803*, newnodei_189099)(NU8 kind, tlineinfo163527 info) {
	tnode188803* result;
	result = 0;
	result = (tnode188803*) newObj((&NTI188795), sizeof(tnode188803));
	(*result).Kind = kind;
	(*result).Info = info;
	return result;
}

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

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

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

N_NIMCALL(tnode188803*, newprocnode_191214)(NU8 kind, tlineinfo163527 info, tnode188803* body, tnode188803* params, tnode188803* name, tnode188803* pattern, tnode188803* genericparams, tnode188803* pragmas, tnode188803* exceptions) {
	tnode188803* result;
	TY191256 LOC1;
	result = 0;
	result = newnodei_189099(kind, info);
	if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
	(*result).kindU.S6.Sons = (tnodeseq188797*) newSeqRC1((&NTI188797), 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(tnode188803*, newnode_191003)(NU8 kind, tlineinfo163527 info, tnodeseq188797* sons, ttype188837* typ) {
	tnode188803* result;
	result = 0;
	result = (tnode188803*) newObj((&NTI188795), sizeof(tnode188803));
	(*result).Kind = kind;
	(*result).Info = info;
	asgnRefNoCycle((void**) &(*result).Typ, typ);
	genericSeqAssign(&(*result).kindU.S6.Sons, sons, (&NTI188797));
	return result;
}

N_NIMCALL(tnode188803*, newnodei_190803)(NU8 kind, tlineinfo163527 info, NI children) {
	tnode188803* result;
	result = 0;
	result = (tnode188803*) newObj((&NTI188795), sizeof(tnode188803));
	(*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 = (tnodeseq188797*) newSeqRC1((&NTI188797), children);
	}
	LA3: ;
	return result;
}

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

N_NIMCALL(NIM_BOOL, ismetatype_189732)(ttype188837* 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_192814)(ttype188837* 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_192852)(ttype188837* owner, ttype188837* 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_189732(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_192814(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_193092)(ttype188837* father, ttype188837* son) {
	{
		if (!(*father).Sons == 0) goto LA3;
		if ((*father).Sons) nimGCunrefNoCycle((*father).Sons);
		(*father).Sons = (ttypeseq188835*) newSeqRC1((&NTI188835), 0);
	}
	LA3: ;
	(*father).Sons = (ttypeseq188835*) incrSeq(&((*father).Sons)->Sup, sizeof(ttype188837*));
	asgnRefNoCycle((void**) &(*father).Sons->data[(*father).Sons->Sup.len-1], son);
	{
		if (!!(son == 0)) goto LA7;
		propagatetoowner_192852(father, son);
	}
	LA7: ;
}

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

N_NIMCALL(NI, len_192569)(ttype188837* 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(NI, sonslen_189185)(ttype188837* 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(ttype188837*, lastson_189193)(ttype188837* n) {
	ttype188837* result;
	NI LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = sonslen_189185(n);
	result = (*n).Sons->data[(NI32)(LOC1 - 1)];
	return result;
}

N_NIMCALL(ttype188837*, skiptypes_192793)(ttype188837* t, NU64 kinds) {
	ttype188837* result;
	result = 0;
	result = t;
	while (1) {
		if (!((kinds &(IL64(1)<<(((*result).Kind)&IL64(63))))!=0)) goto LA1;
		result = lastson_189193(result);
	} LA1: ;
	return result;
}

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

static N_INLINE(void, rtladdcycleroot_45235)(tcell41090* c) {
	{
		if (!!((((NI) ((NI)((*c).Refcount & 3))) == 3))) goto LA3;
		(*c).Refcount = (NI)((NI)((*c).Refcount & -4) | 3);
		incl_41855(&gch_43044.Cycleroots, c);
	}
	LA3: ;
}

static N_INLINE(void, incref_46827)(tcell41090* c) {
	(*c).Refcount = (NI)((NU32)((*c).Refcount) + (NU32)(8));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = canbecycleroot_44462(c);
		if (!LOC3) goto LA4;
		rtladdcycleroot_45235(c);
	}
	LA4: ;
}

static N_INLINE(void, decref_46402)(tcell41090* c) {
	{
		(*c).Refcount -= 8;
		if (!((NU32)((*c).Refcount) < (NU32)(8))) goto LA3;
		rtladdzct_46002(c);
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC6;
		LOC6 = 0;
		LOC6 = canbecycleroot_44462(c);
		if (!LOC6) goto LA7;
		rtladdcycleroot_45235(c);
	}
	goto LA1;
	LA7: ;
	LA1: ;
}

static N_INLINE(void, asgnRef)(void** dest, void* src) {
	{
		tcell41090* LOC5;
		if (!!((src == NIM_NIL))) goto LA3;
		LOC5 = 0;
		LOC5 = usrtocell_44443(src);
		incref_46827(LOC5);
	}
	LA3: ;
	{
		tcell41090* LOC10;
		if (!!(((*dest) == NIM_NIL))) goto LA8;
		LOC10 = 0;
		LOC10 = usrtocell_44443((*dest));
		decref_46402(LOC10);
	}
	LA8: ;
	(*dest) = src;
}

N_NIMCALL(void, mergeloc_191403)(tloc188817* a, tloc188817* 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: ;
	{
		if (!((*a).A == 0)) goto LA19;
		(*a).A = (*b).A;
	}
	LA19: ;
}

N_NIMCALL(void, newsons_189202)(ttype188837* father, NI length) {
	{
		if (!(*father).Sons == 0) goto LA3;
		if ((*father).Sons) nimGCunrefNoCycle((*father).Sons);
		(*father).Sons = (ttypeseq188835*) newSeqRC1((&NTI188835), length);
	}
	goto LA1;
	LA3: ;
	{
		(*father).Sons = (ttypeseq188835*) setLengthSeq(&((*father).Sons)->Sup, sizeof(ttype188837*), length);
	}
	LA1: ;
}

N_NIMCALL(void, assigntype_189152)(ttype188837* dest, ttype188837* src) {
	NI LOC14;
	NI i_191564;
	NI HEX3Atmp_191565;
	NI LOC15;
	NI res_191567;
	(*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);
	{
		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_191403(&(*(*dest).Sym).Loc, &(*(*src).Sym).Loc);
		}
		goto LA5;
		LA7: ;
		{
			asgnRefNoCycle((void**) &(*dest).Sym, (*src).Sym);
		}
		LA5: ;
	}
	LA3: ;
	LOC14 = 0;
	LOC14 = sonslen_189185(src);
	newsons_189202(dest, LOC14);
	i_191564 = 0;
	HEX3Atmp_191565 = 0;
	LOC15 = 0;
	LOC15 = sonslen_189185(src);
	HEX3Atmp_191565 = (NI32)(LOC15 - 1);
	res_191567 = 0;
	while (1) {
		if (!(res_191567 <= HEX3Atmp_191565)) goto LA16;
		i_191564 = res_191567;
		asgnRefNoCycle((void**) &(*dest).Sons->data[i_191564], (*src).Sons->data[i_191564]);
		res_191567 += 1;
	} LA16: ;
}

N_NIMCALL(ttype188837*, newtype_189060)(NU8 kind, tsym188833* owner) {
	ttype188837* result;
	result = 0;
	result = (ttype188837*) newObj((&NTI188799), sizeof(ttype188837));
	(*result).Sup.Sup.m_type = (&NTI188837);
	(*result).Kind = kind;
	asgnRefNoCycle((void**) &(*result).Owner, owner);
	(*result).Size = -1;
	(*result).Align = 2;
	(*result).Sup.Id = getid_187402();
	return result;
}

N_NIMCALL(tnode188803*, newintnode_189069)(NU8 kind, NI64 intval) {
	tnode188803* result;
	result = 0;
	result = newnode_189065(kind);
	(*result).kindU.S1.Intval = intval;
	return result;
}

N_NIMCALL(void, copyidtable_189175)(tidtable188849* dest, tidtable188849 src) {
	NI i_190156;
	NI HEX3Atmp_190157;
	NI res_190159;
	(*dest).Counter = src.Counter;
	{
		if (!src.Data == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	unsureAsgnRef((void**) &(*dest).Data, (tidpairseq188847*) newSeq((&NTI188847), src.Data->Sup.len));
	i_190156 = 0;
	HEX3Atmp_190157 = 0;
	HEX3Atmp_190157 = (src.Data->Sup.len-1);
	res_190159 = 0;
	while (1) {
		if (!(res_190159 <= HEX3Atmp_190157)) goto LA5;
		i_190156 = res_190159;
		asgnRef((void**) &(*dest).Data->data[i_190156].Key, src.Data->data[i_190156].Key);
		asgnRef((void**) &(*dest).Data->data[i_190156].Val, src.Data->data[i_190156].Val);
		res_190159 += 1;
	} LA5: ;
	BeforeRet: ;
}

N_NIMCALL(ttype188837*, copytype_189141)(ttype188837* t, tsym188833* owner, NIM_BOOL keepid) {
	ttype188837* result;
	result = 0;
	result = newtype_189060((*t).Kind, owner);
	assigntype_189152(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(tnode188803*, copynode_189233)(tnode188803* src) {
	tnode188803* result;
	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_189065((*src).Kind);
	(*result).Info = (*src).Info;
	asgnRefNoCycle((void**) &(*result).Typ, (*src).Typ);
	(*result).Flags = ((*src).Flags & 2462);
	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_189157)(tstrtable188807* dest, tstrtable188807 src) {
	NI i_190093;
	NI HEX3Atmp_190094;
	NI res_190096;
	(*dest).Counter = src.Counter;
	{
		if (!src.Data == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	(*dest).Data = (tsymseq188805*) setLengthSeq(&((*dest).Data)->Sup, sizeof(tsym188833*), src.Data->Sup.len);
	i_190093 = 0;
	HEX3Atmp_190094 = 0;
	HEX3Atmp_190094 = (src.Data->Sup.len-1);
	res_190096 = 0;
	while (1) {
		if (!(res_190096 <= HEX3Atmp_190094)) goto LA5;
		i_190093 = res_190096;
		asgnRefNoCycle((void**) &(*dest).Data->data[i_190093], src.Data->data[i_190093]);
		res_190096 += 1;
	} LA5: ;
	BeforeRet: ;
}

N_NIMCALL(tsym188833*, copysym_189147)(tsym188833* s, NIM_BOOL keepid) {
	tsym188833* result;
	result = 0;
	result = newsym_189053((*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_187402();
	}
	LA1: ;
	(*result).Flags = (*s).Flags;
	(*result).Magic = (*s).Magic;
	{
		if (!((*s).Kind == ((NU8) 6))) goto LA8;
		copystrtable_189157(&(*result).kindU.S3.Tab, (*s).kindU.S3.Tab);
	}
	LA8: ;
	(*result).Options = (*s).Options;
	(*result).Position = (*s).Position;
	genericAssign((void*)&(*result).Loc, (void*)&(*s).Loc, (&NTI188817));
	asgnRef((void**) &(*result).Annex, (*s).Annex);
	return result;
}

N_NIMCALL(tnode188803*, newsymnode_189095)(tsym188833* sym) {
	tnode188803* result;
	result = 0;
	result = newnode_189065(((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_189197)(tnode188803* 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 = (tnodeseq188797*) newSeqRC1((&NTI188797), length);
	}
	goto LA1;
	LA3: ;
	{
		(*father).kindU.S6.Sons = (tnodeseq188797*) setLengthSeq(&((*father).kindU.S6.Sons)->Sup, sizeof(tnode188803*), length);
	}
	LA1: ;
}

N_NIMCALL(void, newstrtable_192425)(tstrtable188807* Result) {
	initstrtable_189110(Result);
}

static N_INLINE(NI, sonslen_189181)(tnode188803* 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(tnode188803*, copytree_189237)(tnode188803* src) {
	tnode188803* result;
	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_189065((*src).Kind);
	(*result).Info = (*src).Info;
	asgnRefNoCycle((void**) &(*result).Typ, (*src).Typ);
	(*result).Flags = ((*src).Flags & 2462);
	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;
		NI i_194383;
		NI HEX3Atmp_194412;
		NI LOC13;
		NI res_194414;
		LOC12 = 0;
		LOC12 = sonslen_189181(src);
		if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
		(*result).kindU.S6.Sons = (tnodeseq188797*) newSeqRC1((&NTI188797), LOC12);
		i_194383 = 0;
		HEX3Atmp_194412 = 0;
		LOC13 = 0;
		LOC13 = sonslen_189181(src);
		HEX3Atmp_194412 = (NI32)(LOC13 - 1);
		res_194414 = 0;
		while (1) {
			if (!(res_194414 <= HEX3Atmp_194412)) goto LA14;
			i_194383 = res_194414;
			asgnRefNoCycle((void**) &(*result).kindU.S6.Sons->data[i_194383], copytree_189237((*src).kindU.S6.Sons->data[i_194383]));
			res_194414 += 1;
		} LA14: ;
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tnode188803*, newsymnode_190723)(tsym188833* sym, tlineinfo163527 info) {
	tnode188803* result;
	result = 0;
	result = newnode_189065(((NU8) 3));
	asgnRefNoCycle((void**) &(*result).kindU.S4.Sym, sym);
	asgnRefNoCycle((void**) &(*result).Typ, (*sym).Typ);
	(*result).Info = info;
	return result;
}

N_NIMCALL(tnode188803*, newnodeit_189104)(NU8 kind, tlineinfo163527 info, ttype188837* typ) {
	tnode188803* result;
	result = 0;
	result = newnode_189065(kind);
	(*result).Info = info;
	asgnRefNoCycle((void**) &(*result).Typ, typ);
	return result;
}

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

N_NIMCALL(tnode188803*, newinttypenode_189074)(NU8 kind, NI64 intval, ttype188837* typ) {
	tnode188803* result;
	result = 0;
	result = newintnode_189069(kind, intval);
	asgnRefNoCycle((void**) &(*result).Typ, typ);
	return result;
}

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

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

N_NIMCALL(void, discardsons_189260)(tnode188803* father) {
	genericSeqAssign(&(*father).kindU.S6.Sons, NIM_NIL, (&NTI188797));
}

N_NIMCALL(void, appendtomodule_189815)(tsym188833* m, tnode188803* n) {
	{
		TY207692 LOC5;
		if (!((*m).Ast == NIM_NIL)) goto LA3;
		asgnRefNoCycle((void**) &(*m).Ast, newnode_189065(((NU8) 114)));
		if ((*(*m).Ast).kindU.S6.Sons) nimGCunrefNoCycle((*(*m).Ast).kindU.S6.Sons);
		(*(*m).Ast).kindU.S6.Sons = (tnodeseq188797*) newSeqRC1((&NTI188797), 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 = (tnodeseq188797*) incrSeq(&((*(*m).Ast).kindU.S6.Sons)->Sup, sizeof(tnode188803*));
		asgnRefNoCycle((void**) &(*(*m).Ast).kindU.S6.Sons->data[(*(*m).Ast).kindU.S6.Sons->Sup.len-1], n);
	}
	LA1: ;
}

N_NIMCALL(void, delson_189212)(tnode188803* father, NI idx) {
	NI length;
	NI i_193433;
	NI HEX3Atmp_193492;
	NI res_193494;
	{
		if (!(*father).kindU.S6.Sons == 0) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	length = sonslen_189181(father);
	i_193433 = 0;
	HEX3Atmp_193492 = 0;
	HEX3Atmp_193492 = (NI32)(length - 2);
	res_193494 = idx;
	while (1) {
		if (!(res_193494 <= HEX3Atmp_193492)) goto LA5;
		i_193433 = res_193494;
		asgnRefNoCycle((void**) &(*father).kindU.S6.Sons->data[i_193433], (*father).kindU.S6.Sons->data[(NI32)(i_193433 + 1)]);
		res_193494 += 1;
	} LA5: ;
	(*father).kindU.S6.Sons = (tnodeseq188797*) setLengthSeq(&((*father).kindU.S6.Sons)->Sup, sizeof(tnode188803*), (NI32)(length - 1));
	BeforeRet: ;
}

N_NIMCALL(NIM_BOOL, iscallexpr_189241)(tnode188803* 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(tnode188803*, shallowcopy_193743)(tnode188803* src) {
	tnode188803* result;
	result = 0;
	{
		if (!(src == NIM_NIL)) goto LA3;
		result = NIM_NIL;
		goto BeforeRet;
	}
	LA3: ;
	result = newnode_189065((*src).Kind);
	(*result).Info = (*src).Info;
	asgnRefNoCycle((void**) &(*result).Typ, (*src).Typ);
	(*result).Flags = ((*src).Flags & 2462);
	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_189181(src);
		if ((*result).kindU.S6.Sons) nimGCunrefNoCycle((*result).kindU.S6.Sons);
		(*result).kindU.S6.Sons = (tnodeseq188797*) newSeqRC1((&NTI188797), LOC12);
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tsym188833*, linkto_189797)(tsym188833* s, ttype188837* t) {
	tsym188833* result;
	result = 0;
	asgnRefNoCycle((void**) &(*t).Sym, s);
	asgnRefNoCycle((void**) &(*s).Typ, t);
	result = s;
	return result;
}

N_NIMCALL(tnode188803*, newfloatnode_189080)(NU8 kind, NF floatval) {
	tnode188803* result;
	result = 0;
	result = newnode_189065(kind);
	(*result).kindU.S2.Floatval = floatval;
	return result;
}

N_NIMCALL(NI64, getint_194832)(tnode188803* a) {
	NI64 result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 6) ... ((NU8) 15):
	{
		result = (*a).kindU.S1.Intval;
	}
	break;
	default:
	{
		internalerror_165591((*a).Info, ((NimStringDesc*) &TMP2912));
		result = 0;
	}
	break;
	}
	return result;
}

N_NIMCALL(NF, getfloat_194852)(tnode188803* a) {
	NF result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 16) ... ((NU8) 19):
	{
		result = (*a).kindU.S2.Floatval;
	}
	break;
	default:
	{
		internalerror_165591((*a).Info, ((NimStringDesc*) &TMP2913));
		result = 0.0;
	}
	break;
	}
	return result;
}

N_NIMCALL(NimStringDesc*, getstr_194873)(tnode188803* a) {
	NimStringDesc* result;
	result = 0;
	switch ((*a).Kind) {
	case ((NU8) 20) ... ((NU8) 22):
	{
		result = copyString((*a).kindU.S3.Strval);
	}
	break;
	default:
	{
		internalerror_165591((*a).Info, ((NimStringDesc*) &TMP2914));
		result = copyString(((NimStringDesc*) &TMP1966));
	}
	break;
	}
	return result;
}

N_NIMCALL(NimStringDesc*, getstrorchar_194893)(tnode188803* 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_165591((*a).Info, ((NimStringDesc*) &TMP2917));
		result = copyString(((NimStringDesc*) &TMP1966));
	}
	break;
	}
	return result;
}
N_NIMCALL(void, TMP2937)(void* p, NI op) {
	tidnodepairseq188853* a;
	NI LOC1;
	a = (tidnodepairseq188853*)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_189130)(tidnodetable188855* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) &(*x).Data, (tidnodepairseq188853*) newSeq((&NTI188853), 8));
}

N_NIMCALL(tsym188833*, skipgenericowner_194972)(tsym188833* s) {
	tsym188833* result;
	result = 0;
	{
		NimStringDesc* LOC5;
		if (!!(((520192 &(1<<(((*s).Kind)&31)))!=0))) goto LA3;
		LOC5 = 0;
		LOC5 = HEX24_165714(TMP2980);
		internalerror_165606(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_194562)(tnode188803* n, TY439854 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_194609;
		NI HEX3Atmp_194637;
		NI LOC7;
		NI res_194639;
		i_194609 = 0;
		HEX3Atmp_194637 = 0;
		LOC7 = 0;
		LOC7 = sonslen_189181(n);
		HEX3Atmp_194637 = (NI32)(LOC7 - 1);
		res_194639 = 0;
		while (1) {
			if (!(res_194639 <= HEX3Atmp_194637)) goto LA8;
			i_194609 = res_194639;
			{
				NIM_BOOL LOC11;
				LOC11 = 0;
				LOC11 = ((kinds[(*n).Kind/8] &(1<<((*n).Kind%8)))!=0);
				if (LOC11) goto LA12;
				LOC11 = containsnode_194562((*n).kindU.S6.Sons->data[i_194609], kinds);
				LA12: ;
				if (!LOC11) goto LA13;
				result = NIM_TRUE;
				goto BeforeRet;
			}
			LA13: ;
			res_194639 += 1;
		} LA8: ;
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, hassubnodewith_189222)(tnode188803* n, NU8 kind) {
	NIM_BOOL result;
	result = 0;
	switch ((*n).Kind) {
	case ((NU8) 1) ... ((NU8) 23):
	{
		result = ((*n).Kind == kind);
	}
	break;
	default:
	{
		NI i_194670;
		NI HEX3Atmp_194708;
		NI LOC3;
		NI res_194710;
		i_194670 = 0;
		HEX3Atmp_194708 = 0;
		LOC3 = 0;
		LOC3 = sonslen_189181(n);
		HEX3Atmp_194708 = (NI32)(LOC3 - 1);
		res_194710 = 0;
		while (1) {
			if (!(res_194710 <= HEX3Atmp_194708)) goto LA4;
			i_194670 = res_194710;
			{
				NIM_BOOL LOC7;
				LOC7 = 0;
				LOC7 = ((*(*n).kindU.S6.Sons->data[i_194670]).Kind == kind);
				if (LOC7) goto LA8;
				LOC7 = hassubnodewith_189222((*n).kindU.S6.Sons->data[i_194670], kind);
				LA8: ;
				if (!LOC7) goto LA9;
				result = NIM_TRUE;
				goto BeforeRet;
			}
			LA9: ;
			res_194710 += 1;
		} LA4: ;
		result = NIM_FALSE;
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tnode188803*, withinfo_190675)(tnode188803* n, tlineinfo163527 info) {
	tnode188803* result;
	result = 0;
	(*n).Info = info;
	result = n;
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, hassonwith_189217)(tnode188803* n, NU8 kind) {
	NIM_BOOL result;
	NI i_194462;
	NI HEX3Atmp_194486;
	NI LOC1;
	NI res_194488;
	result = 0;
	i_194462 = 0;
	HEX3Atmp_194486 = 0;
	LOC1 = 0;
	LOC1 = sonslen_189181(n);
	HEX3Atmp_194486 = (NI32)(LOC1 - 1);
	res_194488 = 0;
	while (1) {
		if (!(res_194488 <= HEX3Atmp_194486)) goto LA2;
		i_194462 = res_194488;
		{
			if (!((*(*n).kindU.S6.Sons->data[i_194462]).Kind == kind)) goto LA5;
			result = NIM_TRUE;
			goto BeforeRet;
		}
		LA5: ;
		res_194488 += 1;
	} LA2: ;
	result = NIM_FALSE;
	BeforeRet: ;
	return result;
}

N_NIMCALL(tsym188833*, createmodulealias_191841)(tsym188833* s, tident167019* newident, tlineinfo163527 info) {
	tsym188833* result;
	result = 0;
	result = newsym_189053((*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, (&NTI188817));
	asgnRef((void**) &(*result).Annex, (*s).Annex);
	return result;
}

N_NIMCALL(void, initnodetable_189135)(tnodetable188861* x) {
	(*x).Counter = 0;
	unsureAsgnRef((void**) &(*x).Data, (tnodepairseq188859*) newSeq((&NTI188859), 8));
}
N_NOINLINE(void, astInit)(void) {
	tident167019* LOC1;
	tlineinfo163527 LOC2;
	asgnRefNoCycle((void**) &emptynode_189727, newnode_189065(((NU8) 1)));
	LOC1 = 0;
	LOC1 = getident_167456(((NimStringDesc*) &TMP719));
	LOC2 = unknownlineinfo_164203();
	asgnRefNoCycle((void**) &anyglobal_189730, newsym_189053(((NU8) 8), LOC1, NIM_NIL, LOC2));
	asgnRefNoCycle((void**) &emptyparams_191211, newnode_189065(((NU8) 76)));
	addson_189207(emptyparams_191211, emptynode_189727);
}

N_NOINLINE(void, astDatInit)(void) {
static TNimNode* TMP720[5];
static TNimNode* TMP721[11];
static TNimNode* TMP722[62];
NI TMP724;
static char* NIM_CONST TMP723[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* TMP725[10];
NI TMP727;
static char* NIM_CONST TMP726[10] = {
"ccDefault", 
"ccStdCall", 
"ccCDecl", 
"ccSafeCall", 
"ccSysCall", 
"ccInline", 
"ccNoInline", 
"ccFastCall", 
"ccClosure", 
"ccNoConvention"};
static TNimNode* TMP728[28];
NI TMP730;
static char* NIM_CONST TMP729[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* TMP732[14];
static TNimNode* TMP733[25];
NI TMP735;
static char* NIM_CONST TMP734[25] = {
"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"};
static TNimNode* TMP736[2];
static TNimNode* TMP737[4];
static TNimNode* TMP738[2];
static TNimNode* TMP742[2];
static TNimNode* TMP743[3];
static TNimNode* TMP747[2];
static TNimNode* TMP748[265];
NI TMP750;
static char* NIM_CONST TMP749[265] = {
"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", 
"mRand", 
"mSwap", 
"mIsNil", 
"mArrToSeq", 
"mCopyStr", 
"mCopyStrLast", 
"mNewString", 
"mNewStringOfCap", 
"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", 
"mIsMainModule", 
"mCompileDate", 
"mCompileTime", 
"mNimrodVersion", 
"mNimrodMajor", 
"mNimrodMinor", 
"mNimrodPatch", 
"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* TMP751[32];
NI TMP753;
static char* NIM_CONST TMP752[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", 
"sfDestructor", 
"sfGenSym"};
static TNimNode* TMP757[7];
static TNimNode* TMP758[12];
NI TMP760;
static char* NIM_CONST TMP759[12] = {
"locNone", 
"locTemp", 
"locLocalVar", 
"locGlobalVar", 
"locParam", 
"locField", 
"locArrayElem", 
"locExpr", 
"locProc", 
"locData", 
"locCall", 
"locOther"};
static TNimNode* TMP761[3];
NI TMP763;
static char* NIM_CONST TMP762[3] = {
"OnUnknown", 
"OnStack", 
"OnHeap"};
static TNimNode* TMP764[8];
NI TMP766;
static char* NIM_CONST TMP765[8] = {
"lfIndirect", 
"lfParamCopy", 
"lfNoDeepCopy", 
"lfNoDecl", 
"lfDynamicLib", 
"lfExportLib", 
"lfHeader", 
"lfImportCompilerProc"};
static TNimNode* TMP769[5];
static TNimNode* TMP770[2];
NI TMP772;
static char* NIM_CONST TMP771[2] = {
"libHeader", 
"libDynamic"};
static TNimNode* TMP776[12];
NI TMP778;
static char* NIM_CONST TMP777[12] = {
"nfNone", 
"nfBase2", 
"nfBase8", 
"nfBase16", 
"nfAllConst", 
"nfTransf", 
"nfSem", 
"nfDotField", 
"nfDotSetter", 
"nfExplicitCall", 
"nfExprCall", 
"nfIsRef"};
static TNimNode* TMP779[157];
NI TMP781;
static char* NIM_CONST TMP780[157] = {
"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", 
"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* TMP816[2];
static TNimNode* TMP817[2];
static TNimNode* TMP954[2];
static TNimNode* TMP955[3];
static TNimNode* TMP2935[2];
static TNimNode* TMP2936[2];
static TNimNode TMP713[726];
NTI188803.size = sizeof(tnode188803);
NTI188803.kind = 18;
NTI188803.base = 0;
NTI188803.flags = 2;
TMP720[0] = &TMP713[1];
NTI188837.size = sizeof(ttype188837);
NTI188837.kind = 17;
NTI188837.base = (&NTI167013);
NTI188837.flags = 2;
TMP721[0] = &TMP713[3];
NTI188240.size = sizeof(NU8);
NTI188240.kind = 14;
NTI188240.base = 0;
NTI188240.flags = 3;
for (TMP724 = 0; TMP724 < 62; TMP724++) {
TMP713[TMP724+4].kind = 1;
TMP713[TMP724+4].offset = TMP724;
TMP713[TMP724+4].name = TMP723[TMP724];
TMP722[TMP724] = &TMP713[TMP724+4];
}
TMP713[66].len = 62; TMP713[66].kind = 2; TMP713[66].sons = &TMP722[0];
NTI188240.node = &TMP713[66];
TMP713[3].kind = 1;
TMP713[3].offset = offsetof(ttype188837, Kind);
TMP713[3].typ = (&NTI188240);
TMP713[3].name = "kind";
TMP721[1] = &TMP713[67];
NTI188003.size = sizeof(NU8);
NTI188003.kind = 14;
NTI188003.base = 0;
NTI188003.flags = 3;
for (TMP727 = 0; TMP727 < 10; TMP727++) {
TMP713[TMP727+68].kind = 1;
TMP713[TMP727+68].offset = TMP727;
TMP713[TMP727+68].name = TMP726[TMP727];
TMP725[TMP727] = &TMP713[TMP727+68];
}
TMP713[78].len = 10; TMP713[78].kind = 2; TMP713[78].sons = &TMP725[0];
NTI188003.node = &TMP713[78];
TMP713[67].kind = 1;
TMP713[67].offset = offsetof(ttype188837, Callconv);
TMP713[67].typ = (&NTI188003);
TMP713[67].name = "callConv";
TMP721[2] = &TMP713[79];
NTI188437.size = sizeof(NU8);
NTI188437.kind = 14;
NTI188437.base = 0;
NTI188437.flags = 3;
for (TMP730 = 0; TMP730 < 28; TMP730++) {
TMP713[TMP730+80].kind = 1;
TMP713[TMP730+80].offset = TMP730;
TMP713[TMP730+80].name = TMP729[TMP730];
TMP728[TMP730] = &TMP713[TMP730+80];
}
TMP713[108].len = 28; TMP713[108].kind = 2; TMP713[108].sons = &TMP728[0];
NTI188437.node = &TMP713[108];
NTI188439.size = sizeof(NU32);
NTI188439.kind = 19;
NTI188439.base = (&NTI188437);
NTI188439.flags = 3;
TMP713[109].len = 0; TMP713[109].kind = 0;
NTI188439.node = &TMP713[109];
TMP713[79].kind = 1;
TMP713[79].offset = offsetof(ttype188837, Flags);
TMP713[79].typ = (&NTI188439);
TMP713[79].name = "flags";
TMP721[3] = &TMP713[110];
NTI188835.size = sizeof(ttypeseq188835*);
NTI188835.kind = 24;
NTI188835.base = (&NTI188799);
NTI188835.flags = 2;
NTI188835.marker = TMP731;
TMP713[110].kind = 1;
TMP713[110].offset = offsetof(ttype188837, Sons);
TMP713[110].typ = (&NTI188835);
TMP713[110].name = "sons";
TMP721[4] = &TMP713[111];
TMP713[111].kind = 1;
TMP713[111].offset = offsetof(ttype188837, N);
TMP713[111].typ = (&NTI188795);
TMP713[111].name = "n";
TMP721[5] = &TMP713[112];
NTI188833.size = sizeof(tsym188833);
NTI188833.kind = 17;
NTI188833.base = (&NTI167013);
NTI188833.flags = 2;
TMP732[0] = &TMP713[114];
NTI188441.size = sizeof(NU8);
NTI188441.kind = 14;
NTI188441.base = 0;
NTI188441.flags = 3;
for (TMP735 = 0; TMP735 < 25; TMP735++) {
TMP713[TMP735+115].kind = 1;
TMP713[TMP735+115].offset = TMP735;
TMP713[TMP735+115].name = TMP734[TMP735];
TMP733[TMP735] = &TMP713[TMP735+115];
}
TMP713[140].len = 25; TMP713[140].kind = 2; TMP713[140].sons = &TMP733[0];
NTI188441.node = &TMP713[140];
TMP713[114].kind = 3;
TMP713[114].offset = offsetof(tsym188833, Kind);
TMP713[114].typ = (&NTI188441);
TMP713[114].name = "kind";
TMP713[114].sons = &NimDT_tsym_kind[0];
TMP713[114].len = 25;
TMP736[0] = &TMP713[142];
TMP713[142].kind = 1;
TMP713[142].offset = offsetof(tsym188833, kindU.S1.Typeinstcache);
TMP713[142].typ = (&NTI188835);
TMP713[142].name = "typeInstCache";
TMP736[1] = &TMP713[143];
NTI188827.size = sizeof(tscope188827);
NTI188827.kind = 18;
NTI188827.base = 0;
TMP737[0] = &TMP713[145];
TMP713[145].kind = 1;
TMP713[145].offset = offsetof(tscope188827, Depthlevel);
TMP713[145].typ = (&NTI106);
TMP713[145].name = "depthLevel";
TMP737[1] = &TMP713[146];
NTI188807.size = sizeof(tstrtable188807);
NTI188807.kind = 18;
NTI188807.base = 0;
NTI188807.flags = 2;
TMP738[0] = &TMP713[148];
TMP713[148].kind = 1;
TMP713[148].offset = offsetof(tstrtable188807, Counter);
TMP713[148].typ = (&NTI106);
TMP713[148].name = "counter";
TMP738[1] = &TMP713[149];
NTI188805.size = sizeof(tsymseq188805*);
NTI188805.kind = 24;
NTI188805.base = (&NTI188801);
NTI188805.flags = 2;
NTI188805.marker = TMP739;
TMP713[149].kind = 1;
TMP713[149].offset = offsetof(tstrtable188807, Data);
TMP713[149].typ = (&NTI188805);
TMP713[149].name = "data";
TMP713[147].len = 2; TMP713[147].kind = 2; TMP713[147].sons = &TMP738[0];
NTI188807.node = &TMP713[147];
TMP713[146].kind = 1;
TMP713[146].offset = offsetof(tscope188827, Symbols);
TMP713[146].typ = (&NTI188807);
TMP713[146].name = "symbols";
TMP737[2] = &TMP713[150];
NTI188797.size = sizeof(tnodeseq188797*);
NTI188797.kind = 24;
NTI188797.base = (&NTI188795);
NTI188797.flags = 2;
NTI188797.marker = TMP740;
TMP713[150].kind = 1;
TMP713[150].offset = offsetof(tscope188827, Usingsyms);
TMP713[150].typ = (&NTI188797);
TMP713[150].name = "usingSyms";
TMP737[3] = &TMP713[151];
TMP713[151].kind = 1;
TMP713[151].offset = offsetof(tscope188827, Parent);
TMP713[151].typ = (&NTI188829);
TMP713[151].name = "parent";
TMP713[144].len = 4; TMP713[144].kind = 2; TMP713[144].sons = &TMP737[0];
NTI188827.node = &TMP713[144];
NTI188829.size = sizeof(tscope188827*);
NTI188829.kind = 22;
NTI188829.base = (&NTI188827);
NTI188829.marker = TMP741;
TMP713[143].kind = 1;
TMP713[143].offset = offsetof(tsym188833, kindU.S1.Typscope);
TMP713[143].typ = (&NTI188829);
TMP713[143].name = "typScope";
TMP713[141].len = 2; TMP713[141].kind = 2; TMP713[141].sons = &TMP736[0];
NimDT_tsym_kind[7] = &TMP713[141];
NimDT_tsym_kind[4] = &TMP713[141];
TMP742[0] = &TMP713[153];
NTI188823.size = sizeof(tinstantiation188823);
NTI188823.kind = 18;
NTI188823.base = 0;
NTI188823.flags = 2;
TMP743[0] = &TMP713[155];
TMP713[155].kind = 1;
TMP713[155].offset = offsetof(tinstantiation188823, Sym);
TMP713[155].typ = (&NTI188801);
TMP713[155].name = "sym";
TMP743[1] = &TMP713[156];
TMP713[156].kind = 1;
TMP713[156].offset = offsetof(tinstantiation188823, Concretetypes);
TMP713[156].typ = (&NTI188835);
TMP713[156].name = "concreteTypes";
TMP743[2] = &TMP713[157];
NTI188922.size = sizeof(TY188922*);
NTI188922.kind = 24;
NTI188922.base = (&NTI112);
NTI188922.flags = 2;
NTI188922.marker = TMP744;
TMP713[157].kind = 1;
TMP713[157].offset = offsetof(tinstantiation188823, Usedby);
TMP713[157].typ = (&NTI188922);
TMP713[157].name = "usedBy";
TMP713[154].len = 3; TMP713[154].kind = 2; TMP713[154].sons = &TMP743[0];
NTI188823.node = &TMP713[154];
NTI188825.size = sizeof(tinstantiation188823*);
NTI188825.kind = 22;
NTI188825.base = (&NTI188823);
NTI188825.flags = 2;
NTI188825.marker = TMP745;
NTI188933.size = sizeof(TY188933*);
NTI188933.kind = 24;
NTI188933.base = (&NTI188825);
NTI188933.flags = 2;
NTI188933.marker = TMP746;
TMP713[153].kind = 1;
TMP713[153].offset = offsetof(tsym188833, kindU.S2.Procinstcache);
TMP713[153].typ = (&NTI188933);
TMP713[153].name = "procInstCache";
TMP742[1] = &TMP713[158];
TMP713[158].kind = 1;
TMP713[158].offset = offsetof(tsym188833, kindU.S2.Scope);
TMP713[158].typ = (&NTI188829);
TMP713[158].name = "scope";
TMP713[152].len = 2; TMP713[152].kind = 2; TMP713[152].sons = &TMP742[0];
NimDT_tsym_kind[12] = &TMP713[152];
NimDT_tsym_kind[13] = &TMP713[152];
NimDT_tsym_kind[14] = &TMP713[152];
NimDT_tsym_kind[15] = &TMP713[152];
NimDT_tsym_kind[16] = &TMP713[152];
NimDT_tsym_kind[17] = &TMP713[152];
NimDT_tsym_kind[18] = &TMP713[152];
TMP747[0] = &TMP713[160];
TMP713[160].kind = 1;
TMP713[160].offset = offsetof(tsym188833, kindU.S3.Usedgenerics);
TMP713[160].typ = (&NTI188933);
TMP713[160].name = "usedGenerics";
TMP747[1] = &TMP713[161];
TMP713[161].kind = 1;
TMP713[161].offset = offsetof(tsym188833, kindU.S3.Tab);
TMP713[161].typ = (&NTI188807);
TMP713[161].name = "tab";
TMP713[159].len = 2; TMP713[159].kind = 2; TMP713[159].sons = &TMP747[0];
NimDT_tsym_kind[6] = &TMP713[159];
TMP713[162].len = 0; TMP713[162].kind = 2;
NimDT_tsym_kind[25] = &TMP713[162];
TMP732[1] = &TMP713[163];
NTI188521.size = sizeof(NU16);
NTI188521.kind = 14;
NTI188521.base = 0;
NTI188521.flags = 3;
for (TMP750 = 0; TMP750 < 265; TMP750++) {
TMP713[TMP750+164].kind = 1;
TMP713[TMP750+164].offset = TMP750;
TMP713[TMP750+164].name = TMP749[TMP750];
TMP748[TMP750] = &TMP713[TMP750+164];
}
TMP713[429].len = 265; TMP713[429].kind = 2; TMP713[429].sons = &TMP748[0];
NTI188521.node = &TMP713[429];
TMP713[163].kind = 1;
TMP713[163].offset = offsetof(tsym188833, Magic);
TMP713[163].typ = (&NTI188521);
TMP713[163].name = "magic";
TMP732[2] = &TMP713[430];
TMP713[430].kind = 1;
TMP713[430].offset = offsetof(tsym188833, Typ);
TMP713[430].typ = (&NTI188799);
TMP713[430].name = "typ";
TMP732[3] = &TMP713[431];
TMP713[431].kind = 1;
TMP713[431].offset = offsetof(tsym188833, Name);
TMP713[431].typ = (&NTI167017);
TMP713[431].name = "name";
TMP732[4] = &TMP713[432];
TMP713[432].kind = 1;
TMP713[432].offset = offsetof(tsym188833, Info);
TMP713[432].typ = (&NTI163527);
TMP713[432].name = "info";
TMP732[5] = &TMP713[433];
TMP713[433].kind = 1;
TMP713[433].offset = offsetof(tsym188833, Owner);
TMP713[433].typ = (&NTI188801);
TMP713[433].name = "owner";
TMP732[6] = &TMP713[434];
NTI188185.size = sizeof(NU8);
NTI188185.kind = 14;
NTI188185.base = 0;
NTI188185.flags = 3;
for (TMP753 = 0; TMP753 < 32; TMP753++) {
TMP713[TMP753+435].kind = 1;
TMP713[TMP753+435].offset = TMP753;
TMP713[TMP753+435].name = TMP752[TMP753];
TMP751[TMP753] = &TMP713[TMP753+435];
}
TMP713[467].len = 32; TMP713[467].kind = 2; TMP713[467].sons = &TMP751[0];
NTI188185.node = &TMP713[467];
NTI188187.size = sizeof(NU32);
NTI188187.kind = 19;
NTI188187.base = (&NTI188185);
NTI188187.flags = 3;
TMP713[468].len = 0; TMP713[468].kind = 0;
NTI188187.node = &TMP713[468];
TMP713[434].kind = 1;
TMP713[434].offset = offsetof(tsym188833, Flags);
TMP713[434].typ = (&NTI188187);
TMP713[434].name = "flags";
TMP732[7] = &TMP713[469];
TMP713[469].kind = 1;
TMP713[469].offset = offsetof(tsym188833, Ast);
TMP713[469].typ = (&NTI188795);
TMP713[469].name = "ast";
TMP732[8] = &TMP713[470];
TMP713[470].kind = 1;
TMP713[470].offset = offsetof(tsym188833, Options);
TMP713[470].typ = (&NTI137012);
TMP713[470].name = "options";
TMP732[9] = &TMP713[471];
TMP713[471].kind = 1;
TMP713[471].offset = offsetof(tsym188833, Position);
TMP713[471].typ = (&NTI106);
TMP713[471].name = "position";
TMP732[10] = &TMP713[472];
TMP713[472].kind = 1;
TMP713[472].offset = offsetof(tsym188833, Offset);
TMP713[472].typ = (&NTI106);
TMP713[472].name = "offset";
TMP732[11] = &TMP713[473];
NTI188817.size = sizeof(tloc188817);
NTI188817.kind = 18;
NTI188817.base = 0;
NTI188817.flags = 2;
TMP757[0] = &TMP713[475];
NTI188809.size = sizeof(NU8);
NTI188809.kind = 14;
NTI188809.base = 0;
NTI188809.flags = 3;
for (TMP760 = 0; TMP760 < 12; TMP760++) {
TMP713[TMP760+476].kind = 1;
TMP713[TMP760+476].offset = TMP760;
TMP713[TMP760+476].name = TMP759[TMP760];
TMP758[TMP760] = &TMP713[TMP760+476];
}
TMP713[488].len = 12; TMP713[488].kind = 2; TMP713[488].sons = &TMP758[0];
NTI188809.node = &TMP713[488];
TMP713[475].kind = 1;
TMP713[475].offset = offsetof(tloc188817, K);
TMP713[475].typ = (&NTI188809);
TMP713[475].name = "k";
TMP757[1] = &TMP713[489];
NTI188813.size = sizeof(NU8);
NTI188813.kind = 14;
NTI188813.base = 0;
NTI188813.flags = 3;
for (TMP763 = 0; TMP763 < 3; TMP763++) {
TMP713[TMP763+490].kind = 1;
TMP713[TMP763+490].offset = TMP763;
TMP713[TMP763+490].name = TMP762[TMP763];
TMP761[TMP763] = &TMP713[TMP763+490];
}
TMP713[493].len = 3; TMP713[493].kind = 2; TMP713[493].sons = &TMP761[0];
NTI188813.node = &TMP713[493];
TMP713[489].kind = 1;
TMP713[489].offset = offsetof(tloc188817, S);
TMP713[489].typ = (&NTI188813);
TMP713[489].name = "s";
TMP757[2] = &TMP713[494];
NTI188811.size = sizeof(NU8);
NTI188811.kind = 14;
NTI188811.base = 0;
NTI188811.flags = 3;
for (TMP766 = 0; TMP766 < 8; TMP766++) {
TMP713[TMP766+495].kind = 1;
TMP713[TMP766+495].offset = TMP766;
TMP713[TMP766+495].name = TMP765[TMP766];
TMP764[TMP766] = &TMP713[TMP766+495];
}
TMP713[503].len = 8; TMP713[503].kind = 2; TMP713[503].sons = &TMP764[0];
NTI188811.node = &TMP713[503];
NTI188815.size = sizeof(NU8);
NTI188815.kind = 19;
NTI188815.base = (&NTI188811);
NTI188815.flags = 3;
TMP713[504].len = 0; TMP713[504].kind = 0;
NTI188815.node = &TMP713[504];
TMP713[494].kind = 1;
TMP713[494].offset = offsetof(tloc188817, Flags);
TMP713[494].typ = (&NTI188815);
TMP713[494].name = "flags";
TMP757[3] = &TMP713[505];
TMP713[505].kind = 1;
TMP713[505].offset = offsetof(tloc188817, T);
TMP713[505].typ = (&NTI188799);
TMP713[505].name = "t";
TMP757[4] = &TMP713[506];
TMP713[506].kind = 1;
TMP713[506].offset = offsetof(tloc188817, R);
TMP713[506].typ = (&NTI145005);
TMP713[506].name = "r";
TMP757[5] = &TMP713[507];
TMP713[507].kind = 1;
TMP713[507].offset = offsetof(tloc188817, Heaproot);
TMP713[507].typ = (&NTI145005);
TMP713[507].name = "heapRoot";
TMP757[6] = &TMP713[508];
TMP713[508].kind = 1;
TMP713[508].offset = offsetof(tloc188817, A);
TMP713[508].typ = (&NTI106);
TMP713[508].name = "a";
TMP713[474].len = 7; TMP713[474].kind = 2; TMP713[474].sons = &TMP757[0];
NTI188817.node = &TMP713[474];
TMP713[473].kind = 1;
TMP713[473].offset = offsetof(tsym188833, Loc);
TMP713[473].typ = (&NTI188817);
TMP713[473].name = "loc";
TMP732[12] = &TMP713[509];
NTI188821.size = sizeof(tlib188821);
NTI188821.kind = 17;
NTI188821.base = (&NTI118017);
TMP769[0] = &TMP713[511];
NTI188819.size = sizeof(NU8);
NTI188819.kind = 14;
NTI188819.base = 0;
NTI188819.flags = 3;
for (TMP772 = 0; TMP772 < 2; TMP772++) {
TMP713[TMP772+512].kind = 1;
TMP713[TMP772+512].offset = TMP772;
TMP713[TMP772+512].name = TMP771[TMP772];
TMP770[TMP772] = &TMP713[TMP772+512];
}
TMP713[514].len = 2; TMP713[514].kind = 2; TMP713[514].sons = &TMP770[0];
NTI188819.node = &TMP713[514];
TMP713[511].kind = 1;
TMP713[511].offset = offsetof(tlib188821, Kind);
TMP713[511].typ = (&NTI188819);
TMP713[511].name = "kind";
TMP769[1] = &TMP713[515];
TMP713[515].kind = 1;
TMP713[515].offset = offsetof(tlib188821, Generated);
TMP713[515].typ = (&NTI134);
TMP713[515].name = "generated";
TMP769[2] = &TMP713[516];
TMP713[516].kind = 1;
TMP713[516].offset = offsetof(tlib188821, Isoverriden);
TMP713[516].typ = (&NTI134);
TMP713[516].name = "isOverriden";
TMP769[3] = &TMP713[517];
TMP713[517].kind = 1;
TMP713[517].offset = offsetof(tlib188821, Name);
TMP713[517].typ = (&NTI145005);
TMP713[517].name = "name";
TMP769[4] = &TMP713[518];
TMP713[518].kind = 1;
TMP713[518].offset = offsetof(tlib188821, Path);
TMP713[518].typ = (&NTI188795);
TMP713[518].name = "path";
TMP713[510].len = 5; TMP713[510].kind = 2; TMP713[510].sons = &TMP769[0];
NTI188821.node = &TMP713[510];
NTI188831.size = sizeof(tlib188821*);
NTI188831.kind = 22;
NTI188831.base = (&NTI188821);
NTI188831.marker = TMP773;
TMP713[509].kind = 1;
TMP713[509].offset = offsetof(tsym188833, Annex);
TMP713[509].typ = (&NTI188831);
TMP713[509].name = "annex";
TMP732[13] = &TMP713[519];
TMP713[519].kind = 1;
TMP713[519].offset = offsetof(tsym188833, Constraint);
TMP713[519].typ = (&NTI188795);
TMP713[519].name = "constraint";
TMP713[113].len = 14; TMP713[113].kind = 2; TMP713[113].sons = &TMP732[0];
NTI188833.node = &TMP713[113];
NTI188801.size = sizeof(tsym188833*);
NTI188801.kind = 22;
NTI188801.base = (&NTI188833);
NTI188801.flags = 2;
NTI188801.marker = TMP774;
TMP713[112].kind = 1;
TMP713[112].offset = offsetof(ttype188837, Destructor);
TMP713[112].typ = (&NTI188801);
TMP713[112].name = "destructor";
TMP721[6] = &TMP713[520];
TMP713[520].kind = 1;
TMP713[520].offset = offsetof(ttype188837, Owner);
TMP713[520].typ = (&NTI188801);
TMP713[520].name = "owner";
TMP721[7] = &TMP713[521];
TMP713[521].kind = 1;
TMP713[521].offset = offsetof(ttype188837, Sym);
TMP713[521].typ = (&NTI188801);
TMP713[521].name = "sym";
TMP721[8] = &TMP713[522];
TMP713[522].kind = 1;
TMP713[522].offset = offsetof(ttype188837, Size);
TMP713[522].typ = (&NTI4289);
TMP713[522].name = "size";
TMP721[9] = &TMP713[523];
TMP713[523].kind = 1;
TMP713[523].offset = offsetof(ttype188837, Align);
TMP713[523].typ = (&NTI106);
TMP713[523].name = "align";
TMP721[10] = &TMP713[524];
TMP713[524].kind = 1;
TMP713[524].offset = offsetof(ttype188837, Loc);
TMP713[524].typ = (&NTI188817);
TMP713[524].name = "loc";
TMP713[2].len = 11; TMP713[2].kind = 2; TMP713[2].sons = &TMP721[0];
NTI188837.node = &TMP713[2];
NTI188799.size = sizeof(ttype188837*);
NTI188799.kind = 22;
NTI188799.base = (&NTI188837);
NTI188799.flags = 2;
NTI188799.marker = TMP775;
TMP713[1].kind = 1;
TMP713[1].offset = offsetof(tnode188803, Typ);
TMP713[1].typ = (&NTI188799);
TMP713[1].name = "typ";
TMP720[1] = &TMP713[525];
TMP713[525].kind = 1;
TMP713[525].offset = offsetof(tnode188803, Info);
TMP713[525].typ = (&NTI163527);
TMP713[525].name = "info";
TMP720[2] = &TMP713[526];
NTI188433.size = sizeof(NU8);
NTI188433.kind = 14;
NTI188433.base = 0;
NTI188433.flags = 3;
for (TMP778 = 0; TMP778 < 12; TMP778++) {
TMP713[TMP778+527].kind = 1;
TMP713[TMP778+527].offset = TMP778;
TMP713[TMP778+527].name = TMP777[TMP778];
TMP776[TMP778] = &TMP713[TMP778+527];
}
TMP713[539].len = 12; TMP713[539].kind = 2; TMP713[539].sons = &TMP776[0];
NTI188433.node = &TMP713[539];
NTI188435.size = sizeof(NU16);
NTI188435.kind = 19;
NTI188435.base = (&NTI188433);
NTI188435.flags = 3;
TMP713[540].len = 0; TMP713[540].kind = 0;
NTI188435.node = &TMP713[540];
TMP713[526].kind = 1;
TMP713[526].offset = offsetof(tnode188803, Flags);
TMP713[526].typ = (&NTI188435);
TMP713[526].name = "flags";
TMP720[3] = &TMP713[541];
NTI188023.size = sizeof(NU8);
NTI188023.kind = 14;
NTI188023.base = 0;
NTI188023.flags = 3;
for (TMP781 = 0; TMP781 < 157; TMP781++) {
TMP713[TMP781+542].kind = 1;
TMP713[TMP781+542].offset = TMP781;
TMP713[TMP781+542].name = TMP780[TMP781];
TMP779[TMP781] = &TMP713[TMP781+542];
}
TMP713[699].len = 157; TMP713[699].kind = 2; TMP713[699].sons = &TMP779[0];
NTI188023.node = &TMP713[699];
TMP713[541].kind = 3;
TMP713[541].offset = offsetof(tnode188803, Kind);
TMP713[541].typ = (&NTI188023);
TMP713[541].name = "kind";
TMP713[541].sons = &NimDT_tnode_kind[0];
TMP713[541].len = 157;
TMP713[700].kind = 1;
TMP713[700].offset = offsetof(tnode188803, kindU.S1.Intval);
TMP713[700].typ = (&NTI4289);
TMP713[700].name = "intVal";
NimDT_tnode_kind[5] = &TMP713[700];
NimDT_tnode_kind[6] = &TMP713[700];
NimDT_tnode_kind[7] = &TMP713[700];
NimDT_tnode_kind[8] = &TMP713[700];
NimDT_tnode_kind[9] = &TMP713[700];
NimDT_tnode_kind[10] = &TMP713[700];
NimDT_tnode_kind[11] = &TMP713[700];
NimDT_tnode_kind[12] = &TMP713[700];
NimDT_tnode_kind[13] = &TMP713[700];
NimDT_tnode_kind[14] = &TMP713[700];
NimDT_tnode_kind[15] = &TMP713[700];
TMP713[701].kind = 1;
TMP713[701].offset = offsetof(tnode188803, kindU.S2.Floatval);
TMP713[701].typ = (&NTI4291);
TMP713[701].name = "floatVal";
NimDT_tnode_kind[16] = &TMP713[701];
NimDT_tnode_kind[17] = &TMP713[701];
NimDT_tnode_kind[18] = &TMP713[701];
NimDT_tnode_kind[19] = &TMP713[701];
TMP713[702].kind = 1;
TMP713[702].offset = offsetof(tnode188803, kindU.S3.Strval);
TMP713[702].typ = (&NTI143);
TMP713[702].name = "strVal";
NimDT_tnode_kind[20] = &TMP713[702];
NimDT_tnode_kind[21] = &TMP713[702];
NimDT_tnode_kind[22] = &TMP713[702];
TMP713[703].kind = 1;
TMP713[703].offset = offsetof(tnode188803, kindU.S4.Sym);
TMP713[703].typ = (&NTI188801);
TMP713[703].name = "sym";
NimDT_tnode_kind[3] = &TMP713[703];
TMP713[704].kind = 1;
TMP713[704].offset = offsetof(tnode188803, kindU.S5.Ident);
TMP713[704].typ = (&NTI167017);
TMP713[704].name = "ident";
NimDT_tnode_kind[2] = &TMP713[704];
TMP713[705].kind = 1;
TMP713[705].offset = offsetof(tnode188803, kindU.S6.Sons);
TMP713[705].typ = (&NTI188797);
TMP713[705].name = "sons";
NimDT_tnode_kind[157] = &TMP713[705];
TMP720[4] = &TMP713[706];
TMP713[706].kind = 1;
TMP713[706].offset = offsetof(tnode188803, Comment);
TMP713[706].typ = (&NTI143);
TMP713[706].name = "comment";
TMP713[0].len = 5; TMP713[0].kind = 2; TMP713[0].sons = &TMP720[0];
NTI188803.node = &TMP713[0];
NTI188795.size = sizeof(tnode188803*);
NTI188795.kind = 22;
NTI188795.base = (&NTI188803);
NTI188795.flags = 2;
NTI188795.marker = TMP782;
NTI188849.size = sizeof(tidtable188849);
NTI188849.kind = 18;
NTI188849.base = 0;
TMP816[0] = &TMP713[708];
TMP713[708].kind = 1;
TMP713[708].offset = offsetof(tidtable188849, Counter);
TMP713[708].typ = (&NTI106);
TMP713[708].name = "counter";
TMP816[1] = &TMP713[709];
NTI188845.size = sizeof(tidpair188845);
NTI188845.kind = 18;
NTI188845.base = 0;
TMP817[0] = &TMP713[711];
TMP713[711].kind = 1;
TMP713[711].offset = offsetof(tidpair188845, Key);
TMP713[711].typ = (&NTI167015);
TMP713[711].name = "key";
TMP817[1] = &TMP713[712];
TMP713[712].kind = 1;
TMP713[712].offset = offsetof(tidpair188845, Val);
TMP713[712].typ = (&NTI2411);
TMP713[712].name = "val";
TMP713[710].len = 2; TMP713[710].kind = 2; TMP713[710].sons = &TMP817[0];
NTI188845.node = &TMP713[710];
NTI188847.size = sizeof(tidpairseq188847*);
NTI188847.kind = 24;
NTI188847.base = (&NTI188845);
NTI188847.marker = TMP820;
TMP713[709].kind = 1;
TMP713[709].offset = offsetof(tidtable188849, Data);
TMP713[709].typ = (&NTI188847);
TMP713[709].name = "data";
TMP713[707].len = 2; TMP713[707].kind = 2; TMP713[707].sons = &TMP816[0];
NTI188849.node = &TMP713[707];
NTI188861.size = sizeof(tnodetable188861);
NTI188861.kind = 18;
NTI188861.base = 0;
NTI188861.flags = 2;
TMP954[0] = &TMP713[714];
TMP713[714].kind = 1;
TMP713[714].offset = offsetof(tnodetable188861, Counter);
TMP713[714].typ = (&NTI106);
TMP713[714].name = "counter";
TMP954[1] = &TMP713[715];
NTI188857.size = sizeof(tnodepair188857);
NTI188857.kind = 18;
NTI188857.base = 0;
NTI188857.flags = 2;
TMP955[0] = &TMP713[717];
TMP713[717].kind = 1;
TMP713[717].offset = offsetof(tnodepair188857, H);
TMP713[717].typ = (&NTI119013);
TMP713[717].name = "h";
TMP955[1] = &TMP713[718];
TMP713[718].kind = 1;
TMP713[718].offset = offsetof(tnodepair188857, Key);
TMP713[718].typ = (&NTI188795);
TMP713[718].name = "key";
TMP955[2] = &TMP713[719];
TMP713[719].kind = 1;
TMP713[719].offset = offsetof(tnodepair188857, Val);
TMP713[719].typ = (&NTI106);
TMP713[719].name = "val";
TMP713[716].len = 3; TMP713[716].kind = 2; TMP713[716].sons = &TMP955[0];
NTI188857.node = &TMP713[716];
NTI188859.size = sizeof(tnodepairseq188859*);
NTI188859.kind = 24;
NTI188859.base = (&NTI188857);
NTI188859.flags = 2;
NTI188859.marker = TMP956;
TMP713[715].kind = 1;
TMP713[715].offset = offsetof(tnodetable188861, Data);
TMP713[715].typ = (&NTI188859);
TMP713[715].name = "data";
TMP713[713].len = 2; TMP713[713].kind = 2; TMP713[713].sons = &TMP954[0];
NTI188861.node = &TMP713[713];
NTI391221.size = sizeof(tnode188803**);
NTI391221.kind = 21;
NTI391221.base = (&NTI188795);
NTI391221.flags = 3;
NTI188855.size = sizeof(tidnodetable188855);
NTI188855.kind = 18;
NTI188855.base = 0;
TMP2935[0] = &TMP713[721];
TMP713[721].kind = 1;
TMP713[721].offset = offsetof(tidnodetable188855, Counter);
TMP713[721].typ = (&NTI106);
TMP713[721].name = "counter";
TMP2935[1] = &TMP713[722];
NTI188851.size = sizeof(tidnodepair188851);
NTI188851.kind = 18;
NTI188851.base = 0;
TMP2936[0] = &TMP713[724];
TMP713[724].kind = 1;
TMP713[724].offset = offsetof(tidnodepair188851, Key);
TMP713[724].typ = (&NTI167015);
TMP713[724].name = "key";
TMP2936[1] = &TMP713[725];
TMP713[725].kind = 1;
TMP713[725].offset = offsetof(tidnodepair188851, Val);
TMP713[725].typ = (&NTI188795);
TMP713[725].name = "val";
TMP713[723].len = 2; TMP713[723].kind = 2; TMP713[723].sons = &TMP2936[0];
NTI188851.node = &TMP713[723];
NTI188853.size = sizeof(tidnodepairseq188853*);
NTI188853.kind = 24;
NTI188853.base = (&NTI188851);
NTI188853.marker = TMP2937;
TMP713[722].kind = 1;
TMP713[722].offset = offsetof(tidnodetable188855, Data);
TMP713[722].typ = (&NTI188853);
TMP713[722].name = "data";
TMP713[720].len = 2; TMP713[720].kind = 2; TMP713[720].sons = &TMP2935[0];
NTI188855.node = &TMP713[720];
}

