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

#include <string.h>
typedef struct NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
typedef struct Ttype191849 Ttype191849;
typedef struct Tidobj168015 Tidobj168015;
typedef struct TNimObject TNimObject;
typedef struct TNimType TNimType;
typedef struct TNimNode TNimNode;
typedef struct Ttypeseq191845 Ttypeseq191845;
typedef struct Tnode191813 Tnode191813;
typedef struct Tsym191843 Tsym191843;
typedef struct Tloc191827 Tloc191827;
typedef struct Ropeobj162009 Ropeobj162009;
typedef struct Tscope191837 Tscope191837;
typedef struct TY191944 TY191944;
typedef struct Tstrtable191817 Tstrtable191817;
typedef struct Tsymseq191815 Tsymseq191815;
typedef struct Tident168021 Tident168021;
typedef struct Tlineinfo164338 Tlineinfo164338;
typedef struct Tlib191831 Tlib191831;
typedef struct Tnodeseq191807 Tnodeseq191807;
typedef struct TY88145 TY88145;
typedef struct Tsametypeclosure225841 Tsametypeclosure225841;
typedef struct TY225854 TY225854;
typedef struct TY225855 TY225855;
typedef struct Intset188056 Intset188056;
typedef struct Ttrunk188052 Ttrunk188052;
typedef struct Ttrunkseq188054 Ttrunkseq188054;
typedef struct Tcell46346 Tcell46346;
typedef struct Tcellseq46362 Tcellseq46362;
typedef struct Tgcheap48216 Tgcheap48216;
typedef struct Tcellset46358 Tcellset46358;
typedef struct Tpagedesc46354 Tpagedesc46354;
typedef struct Tmemregion28210 Tmemregion28210;
typedef struct Tsmallchunk27440 Tsmallchunk27440;
typedef struct Tllchunk28204 Tllchunk28204;
typedef struct Tbigchunk27442 Tbigchunk27442;
typedef struct Tintset27417 Tintset27417;
typedef struct Ttrunk27413 Ttrunk27413;
typedef struct Tavlnode28208 Tavlnode28208;
typedef struct Tgcstat48214 Tgcstat48214;
typedef struct Tinstantiation191833 Tinstantiation191833;
typedef struct Tlistentry132022 Tlistentry132022;
typedef struct Tbasechunk27438 Tbasechunk27438;
typedef struct Tfreecell27430 Tfreecell27430;
typedef struct TY191933 TY191933;
struct  TGenericSeq  {
NI len;
NI reserved;
};
struct  NimStringDesc  {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
typedef N_NIMCALL_PTR(void, TY3289) (void* p, NI op);
typedef N_NIMCALL_PTR(void*, TY3294) (void* p);
struct  TNimType  {
NI size;
NU8 kind;
NU8 flags;
TNimType* base;
TNimNode* node;
void* finalizer;
TY3289 marker;
TY3294 deepcopy;
};
struct  TNimObject  {
TNimType* m_type;
};
struct  Tidobj168015  {
  TNimObject Sup;
NI id;
};
struct  Tloc191827  {
NU8 k;
NU8 s;
NU16 flags;
Ttype191849* t;
Ropeobj162009* r;
Ropeobj162009* heaproot;
};
struct  Ttype191849  {
  Tidobj168015 Sup;
NU8 kind;
NU8 callconv;
NU32 flags;
Ttypeseq191845* sons;
Tnode191813* n;
Tsym191843* owner;
Tsym191843* sym;
Tsym191843* destructor;
Tsym191843* deepcopy;
Tsym191843* assignment;
NI64 size;
NI16 align;
NI16 locklevel;
Tloc191827 loc;
};
struct  Tstrtable191817  {
NI counter;
Tsymseq191815* data;
};
struct  Tlineinfo164338  {
NI16 line;
NI16 col;
NI32 fileindex;
};
struct  Tsym191843  {
  Tidobj168015 Sup;
NU8 kind;
union{
struct {Ttypeseq191845* typeinstcache;
Tscope191837* typscope;
} S1;
struct {TY191944* procinstcache;
Tsym191843* gcunsafetyreason;
} S2;
struct {TY191944* usedgenerics;
Tstrtable191817 tab;
} S3;
struct {Tsym191843* guard;
} S4;
} kindU;
NU16 magic;
Ttype191849* typ;
Tident168021* name;
Tlineinfo164338 info;
Tsym191843* owner;
NU32 flags;
Tnode191813* ast;
NU32 options;
NI position;
NI offset;
Tloc191827 loc;
Tlib191831* annex;
Tnode191813* constraint;
};
struct  Tnode191813  {
Ttype191849* typ;
Tlineinfo164338 info;
NU16 flags;
NU8 kind;
union{
struct {NI64 intval;
} S1;
struct {NF floatval;
} S2;
struct {NimStringDesc* strval;
} S3;
struct {Tsym191843* sym;
} S4;
struct {Tident168021* ident;
} S5;
struct {Tnodeseq191807* sons;
} S6;
} kindU;
NimStringDesc* comment;
};
struct  Tident168021  {
  Tidobj168015 Sup;
NimStringDesc* s;
Tident168021* next;
NI h;
};
typedef NimStringDesc* TY223610[62];
struct TY88145 {
NimStringDesc* Field0;
NI Field1;
};
typedef NimStringDesc* TY191020[10];
struct  Tsametypeclosure225841  {
NU8 cmp;
NI reccheck;
NU8 flags;
TY225854* s;
};
struct TY225855 {
NI Field0;
NI Field1;
};
struct  TNimNode  {
NU8 kind;
NI offset;
TNimType* typ;
NCSTRING name;
NI len;
TNimNode** sons;
};
typedef N_NIMCALL_PTR(NIM_BOOL, Ttypeiter221046) (Ttype191849* t, TNimObject* closure);
struct  Intset188056  {
NI counter;
NI max;
Ttrunk188052* head;
Ttrunkseq188054* data;
};
struct  Tcell46346  {
NI refcount;
TNimType* typ;
};
struct  Tcellseq46362  {
NI len;
NI cap;
Tcell46346** d;
};
struct  Tcellset46358  {
NI counter;
NI max;
Tpagedesc46354* head;
Tpagedesc46354** data;
};
typedef Tsmallchunk27440* TY28222[512];
typedef Ttrunk27413* Ttrunkbuckets27415[256];
struct  Tintset27417  {
Ttrunkbuckets27415 data;
};
struct  Tmemregion28210  {
NI minlargeobj;
NI maxlargeobj;
TY28222 freesmallchunks;
Tllchunk28204* llmem;
NI currmem;
NI maxmem;
NI freemem;
NI lastsize;
Tbigchunk27442* freechunkslist;
Tintset27417 chunkstarts;
Tavlnode28208* root;
Tavlnode28208* deleted;
Tavlnode28208* last;
Tavlnode28208* freeavlnodes;
};
struct  Tgcstat48214  {
NI stackscans;
NI cyclecollections;
NI maxthreshold;
NI maxstacksize;
NI maxstackcells;
NI cycletablesize;
NI64 maxpause;
};
struct  Tgcheap48216  {
void* stackbottom;
NI cyclethreshold;
Tcellseq46362 zct;
Tcellseq46362 decstack;
Tcellset46358 cycleroots;
Tcellseq46362 tempstack;
NI recgclock;
Tmemregion28210 region;
Tgcstat48214 stat;
};
typedef N_NIMCALL_PTR(NIM_BOOL, Ttypepredicate221050) (Ttype191849* t);
struct  Ropeobj162009  {
  TNimObject Sup;
Ropeobj162009* left;
Ropeobj162009* right;
NI length;
NimStringDesc* data;
};
struct  Tscope191837  {
NI depthlevel;
Tstrtable191817 symbols;
Tnodeseq191807* usingsyms;
Tscope191837* parent;
};
struct  Tlistentry132022  {
  TNimObject Sup;
Tlistentry132022* prev;
Tlistentry132022* next;
};
struct  Tlib191831  {
  Tlistentry132022 Sup;
NU8 kind;
NIM_BOOL generated;
NIM_BOOL isoverriden;
Ropeobj162009* name;
Tnode191813* path;
};
typedef NI TY27420[8];
struct  Ttrunk188052  {
Ttrunk188052* next;
NI key;
TY27420 bits;
};
struct  Tpagedesc46354  {
Tpagedesc46354* next;
NI key;
TY27420 bits;
};
struct  Tbasechunk27438  {
NI prevsize;
NI size;
NIM_BOOL used;
};
struct  Tsmallchunk27440  {
  Tbasechunk27438 Sup;
Tsmallchunk27440* next;
Tsmallchunk27440* prev;
Tfreecell27430* freelist;
NI free;
NI acc;
NF data;
};
struct  Tllchunk28204  {
NI size;
NI acc;
Tllchunk28204* next;
};
struct  Tbigchunk27442  {
  Tbasechunk27438 Sup;
Tbigchunk27442* next;
Tbigchunk27442* prev;
NI align;
NF data;
};
struct  Ttrunk27413  {
Ttrunk27413* next;
NI key;
TY27420 bits;
};
typedef Tavlnode28208* TY28214[2];
struct  Tavlnode28208  {
TY28214 link;
NI key;
NI upperbound;
NI level;
};
struct  Tinstantiation191833  {
Tsym191843* sym;
Ttypeseq191845* concretetypes;
TY191933* usedby;
};
struct  Tfreecell27430  {
Tfreecell27430* next;
NI zerofield;
};
struct TY225854 {
  TGenericSeq Sup;
  TY225855 data[SEQ_DECL_SIZE];
};
struct Ttypeseq191845 {
  TGenericSeq Sup;
  Ttype191849* data[SEQ_DECL_SIZE];
};
struct TY191944 {
  TGenericSeq Sup;
  Tinstantiation191833* data[SEQ_DECL_SIZE];
};
struct Tsymseq191815 {
  TGenericSeq Sup;
  Tsym191843* data[SEQ_DECL_SIZE];
};
struct Tnodeseq191807 {
  TGenericSeq Sup;
  Tnode191813* data[SEQ_DECL_SIZE];
};
struct Ttrunkseq188054 {
  TGenericSeq Sup;
  Ttrunk188052* data[SEQ_DECL_SIZE];
};
struct TY191933 {
  TGenericSeq Sup;
  NI32 data[SEQ_DECL_SIZE];
};
N_NIMCALL(NimStringDesc*, copyString)(NimStringDesc* src);
static N_INLINE(NIM_BOOL, isintlit_221327)(Ttype191849* t);
static N_INLINE(void, appendString)(NimStringDesc* dest, NimStringDesc* src);
N_NIMCALL(NimStringDesc*, nimInt64ToStr)(NI64 x);
N_NIMCALL(NimStringDesc*, rawNewString)(NI space);
static N_INLINE(void, appendChar)(NimStringDesc* dest, NIM_CHAR c);
N_NIMCALL(NimStringDesc*, typetostring_221032)(Ttype191849* typ, NU8 prefer);
N_NIMCALL(NI, sonslen_194351)(Ttype191849* n);
N_NIMCALL(NimStringDesc*, resizeString)(NimStringDesc* dest, NI addlen);
N_NIMCALL(NimStringDesc*, addChar)(NimStringDesc* s, NIM_CHAR c);
N_NIMCALL(Ttype191849*, base_221039)(Ttype191849* t);
N_NIMCALL(NI, len_194377)(Ttype191849* n);
N_NIMCALL(void, internalerror_166218)(NimStringDesc* errmsg);
N_NIMCALL(NimStringDesc*, HEX24_166306)(TY88145 x);
N_NIMCALL(NimStringDesc*, rendertree_213058)(Tnode191813* n, NU8 renderflags);
N_NIMCALL(NimStringDesc*, rangetostr_223451)(Tnode191813* n);
N_NIMCALL(NimStringDesc*, valuetostring_223438)(Tnode191813* a);
N_NIMCALL(NimStringDesc*, nimFloatToStr)(NF f);
N_NIMCALL(NI, sonslen_194403)(Tnode191813* n);
N_NIMCALL(NimStringDesc*, setLengthStr)(NimStringDesc* s, NI newlen);
static N_INLINE(NI, len_192097)(Tnode191813* n);
static N_INLINE(Tnode191813*, HEX5BHEX5D_192244)(Tnode191813* n, NI i);
static N_INLINE(void, addsep_99447)(NimStringDesc** dest, NimStringDesc* sep, NI startlen);
N_NIMCALL(NimStringDesc*, HEX24_194096)(NI16 x);
N_NIMCALL(NimStringDesc*, nsuFormatSingleElem)(NimStringDesc* formatstr, NimStringDesc* a);
N_NIMCALL(Ttype191849*, elemtype_221522)(Ttype191849* t);
N_NIMCALL(Ttype191849*, lastson_194442)(Ttype191849* n);
N_NIMCALL(void, initsametypeclosure_225863)(Tsametypeclosure225841* Result);
N_NOINLINE(void, chckNil)(void* p);
N_NIMCALL(NIM_BOOL, sametypeaux_226035)(Ttype191849* x, Ttype191849* y, Tsametypeclosure225841* c);
N_NIMCALL(Ttype191849*, skiptypes_195167)(Ttype191849* t, NU64 kinds);
N_NIMCALL(Ttype191849*, skipgenericalias_227119)(Ttype191849* t);
N_NIMCALL(NIM_BOOL, isgenericalias_227091)(Ttype191849* t);
static N_INLINE(NIM_BOOL, sameflags_227141)(Ttype191849* a, Ttype191849* b);
N_NIMCALL(NIM_BOOL, exprstructuralequivalent_220149)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(NIM_BOOL, containsorincl_225872)(Tsametypeclosure225841* c, Ttype191849* a, Ttype191849* b);
static N_INLINE(NIM_BOOL, contains_225890)(TY225855* a, NI aLen0, TY225855 item);
static N_INLINE(NI, find_225900)(TY225855* a, NI aLen0, TY225855 item);
N_NIMCALL(NIM_BOOL, HEX3DHEX3D_225946)(TY225855 x, TY225855 y);
N_NIMCALL(void, TMP2632)(void* p, NI op);
N_NIMCALL(void*, newSeq)(TNimType* typ, NI len);
N_NIMCALL(void, unsureAsgnRef)(void** dest, void* src);
N_NIMCALL(TGenericSeq*, incrSeq)(TGenericSeq* seq, NI elemsize);
N_NIMCALL(NIM_BOOL, sameobjectstructures_227005)(Ttype191849* a, Ttype191849* b, Tsametypeclosure225841* c);
N_NIMCALL(NIM_BOOL, sametypeornilaux_226044)(Ttype191849* a, Ttype191849* b, Tsametypeclosure225841* c);
N_NIMCALL(NIM_BOOL, sameobjecttree_226866)(Tnode191813* a, Tnode191813* b, Tsametypeclosure225841* c);
static N_INLINE(NIM_BOOL, eqStrings)(NimStringDesc* a, NimStringDesc* b);
N_NIMCALL(NIM_BOOL, sametuple_226622)(Ttype191849* a, Ttype191849* b, Tsametypeclosure225841* c);
N_NIMCALL(void, internalerror_166199)(Tlineinfo164338 info, NimStringDesc* errmsg);
N_NIMCALL(NIM_BOOL, samechildrenaux_227048)(Ttype191849* a, Ttype191849* b, Tsametypeclosure225841* c);
N_NIMCALL(NIM_BOOL, sameconstraints_226240)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(NIM_BOOL, samevalue_199324)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(NIM_BOOL, iterovertype_221062)(Ttype191849* t, Ttypeiter221046 iter, TNimObject* closure);
N_NIMCALL(void, initintset_188927)(Intset188056* Result);
N_NIMCALL(NIM_BOOL, iterovertypeaux_222077)(Intset188056* marker, Ttype191849* t, Ttypeiter221046 iter, TNimObject* closure);
N_NIMCALL(NIM_BOOL, containsorincl_188898)(Intset188056* s, NI key);
N_NIMCALL(NIM_BOOL, iterovernode_222087)(Intset188056* marker, Tnode191813* n, Ttypeiter221046 iter, TNimObject* closure);
N_NIMCALL(NIM_BOOL, containsgenerictypeiter_230225)(Ttype191849* t, TNimObject* closure);
N_NIMCALL(NI64, firstord_221004)(Ttype191849* t);
N_NIMCALL(NI64, getordvalue_221178)(Tnode191813* n);
N_NIMCALL(void, localerror_166155)(Tlineinfo164338 info, NU16 msg, NimStringDesc* arg);
N_NIMCALL(NimStringDesc*, reprEnum)(NI e_84329, TNimType* typ);
N_NIMCALL(NI64, lastord_221010)(Ttype191849* t);
N_NIMCALL(NI64, lengthord_221016)(Ttype191849* t);
N_NIMCALL(NIM_BOOL, isordinaltype_221093)(Ttype191849* t);
N_NIMCALL(NIM_BOOL, compatibleeffectsaux_230417)(Tnode191813* se, Tnode191813* re);
N_NIMCALL(NI, safeinheritancediff_230388)(Ttype191849* a, Ttype191849* b);
N_NIMCALL(NI, inheritancediff_228064)(Ttype191849* a, Ttype191849* b);
N_NIMCALL(NIM_BOOL, sameobjecttypes_226785)(Ttype191849* a, Ttype191849* b);
N_NIMCALL(NIM_BOOL, isemptycontainer_230978)(Ttype191849* t);
N_NIMCALL(NU8, classify_230913)(Ttype191849* t);
N_NIMCALL(NI64, computesize_221184)(Ttype191849* typ);
N_NIMCALL(NI64, computesizeaux_229686)(Ttype191849* typ, NI64* a);
N_NIMCALL(NI64, align_229669)(NI64 address, NI64 alignment);
N_NIMCALL(NIM_BOOL, isobjectwithtypefieldpredicate_222556)(Ttype191849* t);
N_NIMCALL(NI64, computerecsizeaux_229694)(Tnode191813* n, NI64* a, NI64* curroffset);
N_NIMCALL(Tnode191813*, lastson_194431)(Tnode191813* n);
N_NIMCALL(NU8, equalparam_226157)(Tsym191843* a, Tsym191843* b);
N_NIMCALL(NIM_BOOL, sametypeornil_226108)(Ttype191849* a, Ttype191849* b, NU8 flags);
N_NIMCALL(NIM_BOOL, sametype_226092)(Ttype191849* a, Ttype191849* b, NU8 flags);
N_NIMCALL(Ttype191849*, typeallowedaux_228858)(Intset188056* marker, Ttype191849* typ, NU8 kind, NU8 flags_228866);
N_NIMCALL(Ttype191849*, typeallowednode_228870)(Intset188056* marker, Tnode191813* n, NU8 kind, NU8 flags);
N_NIMCALL(Ttype191849*, copytype_194549)(Ttype191849* t, Tsym191843* owner, NIM_BOOL keepid);
static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src);
static N_INLINE(Tcell46346*, usrtocell_49846)(void* usr);
static N_INLINE(void, rtladdzct_51404)(Tcell46346* c);
N_NOINLINE(void, addzct_49817)(Tcellseq46362* s, Tcell46346* c);
N_NIMCALL(Ttype191849*, taketype_231006)(Ttype191849* formal, Ttype191849* arg);
N_NIMCALL(Tnode191813*, copytree_196028)(Tnode191813* src);
N_NIMCALL(Tnode191813*, skipconv_230935)(Tnode191813* n);
N_NIMCALL(NIM_BOOL, searchtypefor_222514)(Ttype191849* t, Ttypepredicate221050 predicate);
N_NIMCALL(NIM_BOOL, searchtypeforaux_222226)(Ttype191849* t, Ttypepredicate221050 predicate, Intset188056* marker);
N_NIMCALL(NIM_BOOL, searchtypenodeforaux_222235)(Tnode191813* n, Ttypepredicate221050 p, Intset188056* marker);
N_NIMCALL(NIM_BOOL, isgcref_222783)(Ttype191849* t);
N_NIMCALL(void, incl_188856)(Intset188056* s, NI key);
N_NIMCALL(NIM_BOOL, contains_188829)(Intset188056* s, NI key);
N_NIMCALL(NIM_BOOL, canformacycleaux_222909)(Intset188056* marker, Ttype191849* typ, NI startid);
N_NIMCALL(NIM_BOOL, canformacyclenode_222918)(Intset188056* marker, Tnode191813* n, NI startid);
N_NIMCALL(NU8, analyseobjectwithtypefieldaux_222637)(Ttype191849* t, Intset188056* marker);
N_NIMCALL(NIM_BOOL, ishiddenpointer_222878)(Ttype191849* t);
static N_INLINE(NIM_BOOL, iscompiletimeonly_230712)(Ttype191849* t);
N_NIMCALL(NIM_BOOL, HEX3DHEX3D_230739)(Ttypeseq191845* x, Ttypeseq191845* y);
STRING_LITERAL(TMP1968, "", 0);
STRING_LITERAL(TMP1969, " literal(", 9);
STRING_LITERAL(TMP1970, ")", 1);
STRING_LITERAL(TMP1971, "None", 4);
STRING_LITERAL(TMP1972, "bool", 4);
STRING_LITERAL(TMP1973, "Char", 4);
STRING_LITERAL(TMP1974, "empty", 5);
STRING_LITERAL(TMP1975, "Array Constructor [$1]", 22);
STRING_LITERAL(TMP1976, "nil", 3);
STRING_LITERAL(TMP1977, "expr", 4);
STRING_LITERAL(TMP1978, "stmt", 4);
STRING_LITERAL(TMP1979, "typeDesc", 8);
STRING_LITERAL(TMP1980, "GenericInvocation", 17);
STRING_LITERAL(TMP1981, "GenericBody", 11);
STRING_LITERAL(TMP1982, "GenericInst", 11);
STRING_LITERAL(TMP1983, "GenericParam", 12);
STRING_LITERAL(TMP1984, "distinct $1", 11);
STRING_LITERAL(TMP1985, "enum", 4);
STRING_LITERAL(TMP1986, "ordinal[$1]", 11);
STRING_LITERAL(TMP1987, "array[$1, $2]", 13);
STRING_LITERAL(TMP1988, "object", 6);
STRING_LITERAL(TMP1989, "tuple", 5);
STRING_LITERAL(TMP1990, "set[$1]", 7);
STRING_LITERAL(TMP1991, "range[$1]", 9);
STRING_LITERAL(TMP1992, "ptr ", 4);
STRING_LITERAL(TMP1993, "ref ", 4);
STRING_LITERAL(TMP1994, "var ", 4);
STRING_LITERAL(TMP1995, "seq[$1]", 7);
STRING_LITERAL(TMP1996, "proc", 4);
STRING_LITERAL(TMP1997, "pointer", 7);
STRING_LITERAL(TMP1998, "OpenArray[$1]", 13);
STRING_LITERAL(TMP1999, "string", 6);
STRING_LITERAL(TMP2000, "CString", 7);
STRING_LITERAL(TMP2001, "Forward", 7);
STRING_LITERAL(TMP2002, "int", 3);
STRING_LITERAL(TMP2003, "int8", 4);
STRING_LITERAL(TMP2004, "int16", 5);
STRING_LITERAL(TMP2005, "int32", 5);
STRING_LITERAL(TMP2006, "int64", 5);
STRING_LITERAL(TMP2007, "float", 5);
STRING_LITERAL(TMP2008, "float32", 7);
STRING_LITERAL(TMP2009, "float64", 7);
STRING_LITERAL(TMP2010, "float128", 8);
STRING_LITERAL(TMP2011, "uint", 4);
STRING_LITERAL(TMP2012, "uint8", 5);
STRING_LITERAL(TMP2013, "uint16", 6);
STRING_LITERAL(TMP2014, "uint32", 6);
STRING_LITERAL(TMP2015, "uint64", 6);
STRING_LITERAL(TMP2016, "bignum", 6);
STRING_LITERAL(TMP2017, "const ", 6);
STRING_LITERAL(TMP2018, "!", 1);
STRING_LITERAL(TMP2019, "varargs[$1]", 11);
STRING_LITERAL(TMP2020, "iter[$1]", 8);
STRING_LITERAL(TMP2021, "Error Type", 10);
STRING_LITERAL(TMP2022, "BuiltInTypeClass", 16);
STRING_LITERAL(TMP2023, "UserTypeClass", 13);
STRING_LITERAL(TMP2024, "UserTypeClassInst", 17);
STRING_LITERAL(TMP2025, "CompositeTypeClass", 18);
STRING_LITERAL(TMP2026, "and", 3);
STRING_LITERAL(TMP2027, "or", 2);
STRING_LITERAL(TMP2028, "not", 3);
STRING_LITERAL(TMP2029, "any", 3);
STRING_LITERAL(TMP2030, "static", 6);
STRING_LITERAL(TMP2031, "TypeFromExpr", 12);
STRING_LITERAL(TMP2032, "FieldAccessor", 13);
NIM_CONST TY223610 typetostr_223609 = {((NimStringDesc*) &TMP1971),
((NimStringDesc*) &TMP1972),
((NimStringDesc*) &TMP1973),
((NimStringDesc*) &TMP1974),
((NimStringDesc*) &TMP1975),
((NimStringDesc*) &TMP1976),
((NimStringDesc*) &TMP1977),
((NimStringDesc*) &TMP1978),
((NimStringDesc*) &TMP1979),
((NimStringDesc*) &TMP1980),
((NimStringDesc*) &TMP1981),
((NimStringDesc*) &TMP1982),
((NimStringDesc*) &TMP1983),
((NimStringDesc*) &TMP1984),
((NimStringDesc*) &TMP1985),
((NimStringDesc*) &TMP1986),
((NimStringDesc*) &TMP1987),
((NimStringDesc*) &TMP1988),
((NimStringDesc*) &TMP1989),
((NimStringDesc*) &TMP1990),
((NimStringDesc*) &TMP1991),
((NimStringDesc*) &TMP1992),
((NimStringDesc*) &TMP1993),
((NimStringDesc*) &TMP1994),
((NimStringDesc*) &TMP1995),
((NimStringDesc*) &TMP1996),
((NimStringDesc*) &TMP1997),
((NimStringDesc*) &TMP1998),
((NimStringDesc*) &TMP1999),
((NimStringDesc*) &TMP2000),
((NimStringDesc*) &TMP2001),
((NimStringDesc*) &TMP2002),
((NimStringDesc*) &TMP2003),
((NimStringDesc*) &TMP2004),
((NimStringDesc*) &TMP2005),
((NimStringDesc*) &TMP2006),
((NimStringDesc*) &TMP2007),
((NimStringDesc*) &TMP2008),
((NimStringDesc*) &TMP2009),
((NimStringDesc*) &TMP2010),
((NimStringDesc*) &TMP2011),
((NimStringDesc*) &TMP2012),
((NimStringDesc*) &TMP2013),
((NimStringDesc*) &TMP2014),
((NimStringDesc*) &TMP2015),
((NimStringDesc*) &TMP2016),
((NimStringDesc*) &TMP2017),
((NimStringDesc*) &TMP2018),
((NimStringDesc*) &TMP2019),
((NimStringDesc*) &TMP2020),
((NimStringDesc*) &TMP2021),
((NimStringDesc*) &TMP2022),
((NimStringDesc*) &TMP2023),
((NimStringDesc*) &TMP2024),
((NimStringDesc*) &TMP2025),
((NimStringDesc*) &TMP2026),
((NimStringDesc*) &TMP2027),
((NimStringDesc*) &TMP2028),
((NimStringDesc*) &TMP2029),
((NimStringDesc*) &TMP2030),
((NimStringDesc*) &TMP2031),
((NimStringDesc*) &TMP2032)}
;
STRING_LITERAL(TMP2033, "int literal(", 12);
STRING_LITERAL(TMP2034, ", ", 2);
STRING_LITERAL(TMP2035, "typedesc", 8);
STRING_LITERAL(TMP2036, "typedesc[", 9);
STRING_LITERAL(TMP2037, "]", 1);
STRING_LITERAL(TMP2039, "types.nim", 9);
NIM_CONST TY88145 TMP2038 = {((NimStringDesc*) &TMP2039),
((NI) 445)}
;
STRING_LITERAL(TMP2040, "static[", 7);
STRING_LITERAL(TMP2041, "(", 1);
NIM_CONST TY88145 TMP2042 = {((NimStringDesc*) &TMP2039),
((NI) 452)}
;
STRING_LITERAL(TMP2043, "var", 3);
STRING_LITERAL(TMP2044, "ref", 3);
STRING_LITERAL(TMP2045, "ptr", 3);
STRING_LITERAL(TMP2046, "seq", 3);
STRING_LITERAL(TMP2047, "array", 5);
STRING_LITERAL(TMP2048, "set", 3);
STRING_LITERAL(TMP2049, "range", 5);
STRING_LITERAL(TMP2050, "distinct", 8);
STRING_LITERAL(TMP2051, "openarray", 9);
STRING_LITERAL(TMP2052, "[", 1);
STRING_LITERAL(TMP2053, " and ", 5);
STRING_LITERAL(TMP2054, " or ", 4);
STRING_LITERAL(TMP2055, "not ", 4);
NIM_CONST TY88145 TMP2056 = {((NimStringDesc*) &TMP2039),
((NI) 483)}
;
STRING_LITERAL(TMP2057, "array[", 6);
STRING_LITERAL(TMP2058, "<invalid value>", 15);
STRING_LITERAL(TMP2059, "..", 2);
STRING_LITERAL(TMP2060, "Array constructor[", 18);
STRING_LITERAL(TMP2061, "seq[", 4);
STRING_LITERAL(TMP2062, "ordinal[", 8);
STRING_LITERAL(TMP2063, "set[", 4);
STRING_LITERAL(TMP2064, "openarray[", 10);
STRING_LITERAL(TMP2065, "distinct ", 9);
STRING_LITERAL(TMP2066, "tuple[", 6);
STRING_LITERAL(TMP2067, ": ", 2);
STRING_LITERAL(TMP2068, "tuple[]", 7);
STRING_LITERAL(TMP2069, "range ", 6);
STRING_LITERAL(TMP2070, "iterator (", 10);
STRING_LITERAL(TMP2071, "proc (", 6);
extern NIM_CONST TY191020 Callingconvtostr_191019;
STRING_LITERAL(TMP2082, "noSideEffect", 12);
STRING_LITERAL(TMP2083, "gcsafe", 6);
STRING_LITERAL(TMP2084, "locks: ", 7);
STRING_LITERAL(TMP2087, "{.", 2);
STRING_LITERAL(TMP2088, ".}", 2);
STRING_LITERAL(TMP2089, "shared ", 7);
STRING_LITERAL(TMP2090, " not nil", 8);
STRING_LITERAL(TMP2633, "sameTuple", 9);
NIM_CONST TY88145 TMP2634 = {((NimStringDesc*) &TMP2039),
((NI) 726)}
;
STRING_LITERAL(TMP2644, "invalid kind for first(", 23);
STRING_LITERAL(TMP2645, "invalid kind for last(", 22);
NIM_CONST TY88145 TMP2648 = {((NimStringDesc*) &TMP2039),
((NI) 1374)}
;
NIM_CONST TY88145 TMP2649 = {((NimStringDesc*) &TMP2039),
((NI) 1375)}
;
STRING_LITERAL(TMP2656, "getProcHeader", 13);
STRING_LITERAL(TMP2813, "computeRecSizeAux(record case branch)", 37);
STRING_LITERAL(TMP2814, "getSize: ", 9);
NIM_CONST TY88145 TMP3346 = {((NimStringDesc*) &TMP2039),
((NI) 1351)}
;
STRING_LITERAL(TMP3409, "searchTypeNodeForAux(record case branch)", 40);
STRING_LITERAL(TMP3410, "searchTypeNodeForAux()", 22);
TNimType NTI225855; /* tuple[a: int, b: int] */
extern TNimType NTI108; /* int */
TNimType NTI225854; /* seq[tuple[a: int, b: int]] */
extern NI intsize_160623;
extern TNimType NTI191260; /* TTypeKind */
extern NI floatsize_160624;
extern NI ptrsize_160625;
extern Tgcheap48216 gch_48244;

static N_INLINE(NIM_BOOL, isintlit_221327)(Ttype191849* t) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	NIM_BOOL LOC2;
	result = 0;
	LOC1 = 0;
	LOC2 = 0;
	LOC2 = ((*t).kind == ((NU8) 31));
	if (!(LOC2)) goto LA3;
	LOC2 = !(((*t).n == NIM_NIL));
	LA3: ;
	LOC1 = LOC2;
	if (!(LOC1)) goto LA4;
	LOC1 = ((*(*t).n).kind == ((NU8) 6));
	LA4: ;
	result = LOC1;
	return result;
}

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

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

N_NIMCALL(Ttype191849*, base_221039)(Ttype191849* t) {
	Ttype191849* result;
	result = 0;
	result = (*t).sons->data[((NI) 0)];
	return result;
}

N_NIMCALL(NimStringDesc*, valuetostring_223438)(Tnode191813* a) {
	NimStringDesc* result;
	result = 0;
	switch ((*a).kind) {
	case ((NU8) 5) ... ((NU8) 15):
	{
		result = nimInt64ToStr((*a).kindU.S1.intval);
	}
	break;
	case ((NU8) 16) ... ((NU8) 19):
	{
		result = nimFloatToStr((*a).kindU.S2.floatval);
	}
	break;
	case ((NU8) 20) ... ((NU8) 22):
	{
		result = copyString((*a).kindU.S3.strval);
	}
	break;
	default:
	{
		result = copyString(((NimStringDesc*) &TMP2058));
	}
	break;
	}
	return result;
}

N_NIMCALL(NimStringDesc*, rangetostr_223451)(Tnode191813* n) {
	NimStringDesc* result;
	NimStringDesc* LOC1;
	NimStringDesc* LOC2;
	NimStringDesc* LOC3;
	result = 0;
	LOC1 = 0;
	LOC2 = 0;
	LOC2 = valuetostring_223438((*n).kindU.S6.sons->data[((NI) 0)]);
	LOC3 = 0;
	LOC3 = valuetostring_223438((*n).kindU.S6.sons->data[((NI) 1)]);
	LOC1 = rawNewString(LOC2->Sup.len + LOC3->Sup.len + 2);
appendString(LOC1, LOC2);
appendString(LOC1, ((NimStringDesc*) &TMP2059));
appendString(LOC1, LOC3);
	result = LOC1;
	return result;
}

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

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

static N_INLINE(void, addsep_99447)(NimStringDesc** dest, NimStringDesc* sep, NI startlen) {
	{
		if (!(((NI) (startlen)) < ((*dest) ? (*dest)->Sup.len : 0))) goto LA3;
		(*dest) = resizeString((*dest), sep->Sup.len + 0);
appendString((*dest), sep);
	}
	LA3: ;
}

N_NIMCALL(NimStringDesc*, typetostring_221032)(Ttype191849* typ, NU8 prefer) {
	NimStringDesc* result;
	Ttype191849* t;
{	result = 0;
	t = typ;
	result = copyString(((NimStringDesc*) &TMP1968));
	{
		if (!(t == NIM_NIL)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	{
		NIM_BOOL LOC7;
		NIM_BOOL LOC8;
		LOC7 = 0;
		LOC8 = 0;
		LOC8 = ((25 &(1<<((prefer)&7)))!=0);
		if (!(LOC8)) goto LA9;
		LOC8 = !(((*t).sym == NIM_NIL));
		LA9: ;
		LOC7 = LOC8;
		if (!(LOC7)) goto LA10;
		LOC7 = !((((*(*t).sym).flags &(1<<((((NU8) 29))&31)))!=0));
		LA10: ;
		if (!LOC7) goto LA11;
		{
			NIM_BOOL LOC15;
			NimStringDesc* LOC19;
			NimStringDesc* LOC20;
			LOC15 = 0;
			LOC15 = ((*t).kind == ((NU8) 31));
			if (!(LOC15)) goto LA16;
			LOC15 = isintlit_221327(t);
			LA16: ;
			if (!LOC15) goto LA17;
			LOC19 = 0;
			LOC20 = 0;
			LOC20 = nimInt64ToStr((*(*t).n).kindU.S1.intval);
			LOC19 = rawNewString((*(*(*t).sym).name).s->Sup.len + LOC20->Sup.len + 10);
appendString(LOC19, (*(*(*t).sym).name).s);
appendString(LOC19, ((NimStringDesc*) &TMP1969));
appendString(LOC19, LOC20);
appendString(LOC19, ((NimStringDesc*) &TMP1970));
			result = LOC19;
			goto BeforeRet;
		}
		LA17: ;
		{
			NIM_BOOL LOC23;
			LOC23 = 0;
			LOC23 = (prefer == ((NU8) 0));
			if (LOC23) goto LA24;
			LOC23 = (*(*t).sym).owner == 0;
			LA24: ;
			if (!LOC23) goto LA25;
			result = copyString((*(*(*t).sym).name).s);
			goto BeforeRet;
		}
		goto LA21;
		LA25: ;
		{
			NimStringDesc* LOC28;
			LOC28 = 0;
			LOC28 = rawNewString((*(*(*(*t).sym).owner).name).s->Sup.len + (*(*(*t).sym).name).s->Sup.len + 1);
appendString(LOC28, (*(*(*(*t).sym).owner).name).s);
appendChar(LOC28, 46);
appendString(LOC28, (*(*(*t).sym).name).s);
			result = LOC28;
			goto BeforeRet;
		}
		LA21: ;
	}
	LA11: ;
	switch ((*t).kind) {
	case ((NU8) 31):
	{
		{
			NIM_BOOL LOC32;
			NIM_BOOL LOC33;
			LOC32 = 0;
			LOC33 = 0;
			LOC33 = isintlit_221327(t);
			LOC32 = !(LOC33);
			if (LOC32) goto LA34;
			LOC32 = (prefer == ((NU8) 2));
			LA34: ;
			if (!LOC32) goto LA35;
			result = copyString(typetostr_223609[((*t).kind)- 0]);
		}
		goto LA30;
		LA35: ;
		{
			{
				if (!(prefer == ((NU8) 4))) goto LA40;
				result = nimInt64ToStr((*(*t).n).kindU.S1.intval);
			}
			goto LA38;
			LA40: ;
			{
				NimStringDesc* LOC43;
				NimStringDesc* LOC44;
				LOC43 = 0;
				LOC44 = 0;
				LOC44 = nimInt64ToStr((*(*t).n).kindU.S1.intval);
				LOC43 = rawNewString(LOC44->Sup.len + 13);
appendString(LOC43, ((NimStringDesc*) &TMP2033));
appendString(LOC43, LOC44);
appendString(LOC43, ((NimStringDesc*) &TMP1970));
				result = LOC43;
			}
			LA38: ;
		}
		LA30: ;
	}
	break;
	case ((NU8) 10):
	case ((NU8) 11):
	case ((NU8) 9):
	{
		NimStringDesc* LOC46;
		NimStringDesc* LOC47;
		LOC46 = 0;
		LOC47 = 0;
		LOC47 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
		LOC46 = rawNewString(LOC47->Sup.len + 1);
appendString(LOC46, LOC47);
appendChar(LOC46, 91);
		result = LOC46;
		{
			NI i_223757;
			NI HEX3Atmp_224368;
			NI LOC49;
			NI res_224371;
			i_223757 = 0;
			HEX3Atmp_224368 = 0;
			LOC49 = 0;
			LOC49 = sonslen_194351(t);
			HEX3Atmp_224368 = (NI)((NI)(LOC49 - ((NI) 1)) - ((NI) (!(((*t).kind == ((NU8) 9))))));
			res_224371 = ((NI) 1);
			{
				while (1) {
					NimStringDesc* LOC56;
					if (!(res_224371 <= HEX3Atmp_224368)) goto LA51;
					i_223757 = res_224371;
					{
						if (!(((NI) 1) < i_223757)) goto LA54;
						result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TMP2034));
					}
					LA54: ;
					LOC56 = 0;
					LOC56 = typetostring_221032((*t).sons->data[i_223757], ((NU8) 4));
					result = resizeString(result, LOC56->Sup.len + 0);
appendString(result, LOC56);
					res_224371 += ((NI) 1);
				} LA51: ;
			}
		}
		result = addChar(result, 93);
	}
	break;
	case ((NU8) 8):
	{
		{
			Ttype191849* LOC60;
			LOC60 = 0;
			LOC60 = base_221039(t);
			if (!((*LOC60).kind == ((NU8) 0))) goto LA61;
			result = copyString(((NimStringDesc*) &TMP2035));
		}
		goto LA58;
		LA61: ;
		{
			NimStringDesc* LOC64;
			Ttype191849* LOC65;
			NimStringDesc* LOC66;
			LOC64 = 0;
			LOC65 = 0;
			LOC65 = base_221039(t);
			LOC66 = 0;
			LOC66 = typetostring_221032(LOC65, ((NU8) 0));
			LOC64 = rawNewString(LOC66->Sup.len + 10);
appendString(LOC64, ((NimStringDesc*) &TMP2036));
appendString(LOC64, LOC66);
appendString(LOC64, ((NimStringDesc*) &TMP2037));
			result = LOC64;
		}
		LA58: ;
	}
	break;
	case ((NU8) 59):
	{
		{
			NI LOC70;
			NimStringDesc* LOC73;
			LOC70 = 0;
			LOC70 = len_194377(t);
			if (!!((((NI) 0) < LOC70))) goto LA71;
			LOC73 = 0;
			LOC73 = HEX24_166306(TMP2038);
			internalerror_166218(LOC73);
		}
		LA71: ;
		{
			NIM_BOOL LOC76;
			LOC76 = 0;
			LOC76 = (prefer == ((NU8) 4));
			if (!(LOC76)) goto LA77;
			LOC76 = !(((*t).n == NIM_NIL));
			LA77: ;
			if (!LOC76) goto LA78;
			result = rendertree_213058((*t).n, 0);
		}
		goto LA74;
		LA78: ;
		{
			NimStringDesc* LOC81;
			NimStringDesc* LOC82;
			LOC81 = 0;
			LOC82 = 0;
			LOC82 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
			LOC81 = rawNewString(LOC82->Sup.len + 8);
appendString(LOC81, ((NimStringDesc*) &TMP2040));
appendString(LOC81, LOC82);
appendString(LOC81, ((NimStringDesc*) &TMP2037));
			result = LOC81;
			{
				NimStringDesc* LOC87;
				NimStringDesc* LOC88;
				if (!!(((*t).n == NIM_NIL))) goto LA85;
				LOC87 = 0;
				LOC88 = 0;
				LOC88 = rendertree_213058((*t).n, 0);
				LOC87 = rawNewString(LOC88->Sup.len + 2);
appendString(LOC87, ((NimStringDesc*) &TMP2041));
appendString(LOC87, LOC88);
appendString(LOC87, ((NimStringDesc*) &TMP1970));
				result = resizeString(result, LOC87->Sup.len + 0);
appendString(result, LOC87);
			}
			LA85: ;
		}
		LA74: ;
	}
	break;
	case ((NU8) 52):
	{
		{
			NIM_BOOL LOC92;
			NimStringDesc* LOC96;
			LOC92 = 0;
			LOC92 = !(((*t).sym == NIM_NIL));
			if (!(LOC92)) goto LA93;
			LOC92 = !(((*(*t).sym).owner == NIM_NIL));
			LA93: ;
			if (!!(LOC92)) goto LA94;
			LOC96 = 0;
			LOC96 = HEX24_166306(TMP2042);
			internalerror_166218(LOC96);
		}
		LA94: ;
		result = copyString((*(*(*(*t).sym).owner).name).s);
		goto BeforeRet;
	}
	break;
	case ((NU8) 51):
	{
		Ttype191849* LOC98;
		LOC98 = 0;
		LOC98 = base_221039(t);
		switch ((*LOC98).kind) {
		case ((NU8) 23):
		{
			result = copyString(((NimStringDesc*) &TMP2043));
		}
		break;
		case ((NU8) 22):
		{
			result = copyString(((NimStringDesc*) &TMP2044));
		}
		break;
		case ((NU8) 21):
		{
			result = copyString(((NimStringDesc*) &TMP2045));
		}
		break;
		case ((NU8) 24):
		{
			result = copyString(((NimStringDesc*) &TMP2046));
		}
		break;
		case ((NU8) 16):
		{
			result = copyString(((NimStringDesc*) &TMP2047));
		}
		break;
		case ((NU8) 19):
		{
			result = copyString(((NimStringDesc*) &TMP2048));
		}
		break;
		case ((NU8) 20):
		{
			result = copyString(((NimStringDesc*) &TMP2049));
		}
		break;
		case ((NU8) 13):
		{
			result = copyString(((NimStringDesc*) &TMP2050));
		}
		break;
		case ((NU8) 25):
		{
			result = copyString(((NimStringDesc*) &TMP1996));
		}
		break;
		case ((NU8) 17):
		{
			result = copyString(((NimStringDesc*) &TMP1988));
		}
		break;
		case ((NU8) 18):
		{
			result = copyString(((NimStringDesc*) &TMP1989));
		}
		break;
		case ((NU8) 27):
		{
			result = copyString(((NimStringDesc*) &TMP2051));
		}
		break;
		default:
		{
			Ttype191849* LOC112;
			LOC112 = 0;
			LOC112 = base_221039(t);
			result = copyString(typetostr_223609[((*LOC112).kind)- 0]);
		}
		break;
		}
	}
	break;
	case ((NU8) 53):
	{
		Ttype191849* body;
		NimStringDesc* LOC114;
		body = base_221039(t);
		LOC114 = 0;
		LOC114 = rawNewString((*(*(*body).sym).name).s->Sup.len + 1);
appendString(LOC114, (*(*(*body).sym).name).s);
appendString(LOC114, ((NimStringDesc*) &TMP2052));
		result = LOC114;
		{
			NI i_223856;
			NI HEX3Atmp_224376;
			NI LOC116;
			NI res_224379;
			i_223856 = 0;
			HEX3Atmp_224376 = 0;
			LOC116 = 0;
			LOC116 = sonslen_194351(t);
			HEX3Atmp_224376 = (NI)(LOC116 - ((NI) 2));
			res_224379 = ((NI) 1);
			{
				while (1) {
					NimStringDesc* LOC123;
					if (!(res_224379 <= HEX3Atmp_224376)) goto LA118;
					i_223856 = res_224379;
					{
						if (!(((NI) 1) < i_223856)) goto LA121;
						result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TMP2034));
					}
					LA121: ;
					LOC123 = 0;
					LOC123 = typetostring_221032((*t).sons->data[i_223856], ((NU8) 0));
					result = resizeString(result, LOC123->Sup.len + 0);
appendString(result, LOC123);
					res_224379 += ((NI) 1);
				} LA118: ;
			}
		}
		result = resizeString(result, 1);
appendString(result, ((NimStringDesc*) &TMP2037));
	}
	break;
	case ((NU8) 55):
	{
		NimStringDesc* LOC125;
		NimStringDesc* LOC126;
		NimStringDesc* LOC127;
		LOC125 = 0;
		LOC126 = 0;
		LOC126 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
		LOC127 = 0;
		LOC127 = typetostring_221032((*t).sons->data[((NI) 1)], ((NU8) 0));
		LOC125 = rawNewString(LOC126->Sup.len + LOC127->Sup.len + 5);
appendString(LOC125, LOC126);
appendString(LOC125, ((NimStringDesc*) &TMP2053));
appendString(LOC125, LOC127);
		result = LOC125;
	}
	break;
	case ((NU8) 56):
	{
		NimStringDesc* LOC129;
		NimStringDesc* LOC130;
		NimStringDesc* LOC131;
		LOC129 = 0;
		LOC130 = 0;
		LOC130 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
		LOC131 = 0;
		LOC131 = typetostring_221032((*t).sons->data[((NI) 1)], ((NU8) 0));
		LOC129 = rawNewString(LOC130->Sup.len + LOC131->Sup.len + 4);
appendString(LOC129, LOC130);
appendString(LOC129, ((NimStringDesc*) &TMP2054));
appendString(LOC129, LOC131);
		result = LOC129;
	}
	break;
	case ((NU8) 57):
	{
		NimStringDesc* LOC133;
		NimStringDesc* LOC134;
		LOC133 = 0;
		LOC134 = 0;
		LOC134 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
		LOC133 = rawNewString(LOC134->Sup.len + 4);
appendString(LOC133, ((NimStringDesc*) &TMP2055));
appendString(LOC133, LOC134);
		result = LOC133;
	}
	break;
	case ((NU8) 6):
	{
		{
			NI LOC138;
			NimStringDesc* LOC141;
			LOC138 = 0;
			LOC138 = len_194377(t);
			if (!!((LOC138 == ((NI) 0)))) goto LA139;
			LOC141 = 0;
			LOC141 = HEX24_166306(TMP2056);
			internalerror_166218(LOC141);
		}
		LA139: ;
		result = copyString(((NimStringDesc*) &TMP1977));
	}
	break;
	case ((NU8) 60):
	case ((NU8) 61):
	{
		result = rendertree_213058((*t).n, 0);
	}
	break;
	case ((NU8) 16):
	{
		{
			NimStringDesc* LOC148;
			NimStringDesc* LOC149;
			NimStringDesc* LOC150;
			if (!((*(*t).sons->data[((NI) 0)]).kind == ((NU8) 20))) goto LA146;
			LOC148 = 0;
			LOC149 = 0;
			LOC149 = rangetostr_223451((*(*t).sons->data[((NI) 0)]).n);
			LOC150 = 0;
			LOC150 = typetostring_221032((*t).sons->data[((NI) 1)], ((NU8) 0));
			LOC148 = rawNewString(LOC149->Sup.len + LOC150->Sup.len + 9);
appendString(LOC148, ((NimStringDesc*) &TMP2057));
appendString(LOC148, LOC149);
appendString(LOC148, ((NimStringDesc*) &TMP2034));
appendString(LOC148, LOC150);
appendChar(LOC148, 93);
			result = LOC148;
		}
		goto LA144;
		LA146: ;
		{
			NimStringDesc* LOC152;
			NimStringDesc* LOC153;
			NimStringDesc* LOC154;
			LOC152 = 0;
			LOC153 = 0;
			LOC153 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
			LOC154 = 0;
			LOC154 = typetostring_221032((*t).sons->data[((NI) 1)], ((NU8) 0));
			LOC152 = rawNewString(LOC153->Sup.len + LOC154->Sup.len + 9);
appendString(LOC152, ((NimStringDesc*) &TMP2057));
appendString(LOC152, LOC153);
appendString(LOC152, ((NimStringDesc*) &TMP2034));
appendString(LOC152, LOC154);
appendChar(LOC152, 93);
			result = LOC152;
		}
		LA144: ;
	}
	break;
	case ((NU8) 4):
	{
		NimStringDesc* LOC156;
		NimStringDesc* LOC157;
		NimStringDesc* LOC158;
		LOC156 = 0;
		LOC157 = 0;
		LOC157 = rangetostr_223451((*(*t).sons->data[((NI) 0)]).n);
		LOC158 = 0;
		LOC158 = typetostring_221032((*t).sons->data[((NI) 1)], ((NU8) 0));
		LOC156 = rawNewString(LOC157->Sup.len + LOC158->Sup.len + 21);
appendString(LOC156, ((NimStringDesc*) &TMP2060));
appendString(LOC156, LOC157);
appendString(LOC156, ((NimStringDesc*) &TMP2034));
appendString(LOC156, LOC158);
appendChar(LOC156, 93);
		result = LOC156;
	}
	break;
	case ((NU8) 24):
	{
		NimStringDesc* LOC160;
		NimStringDesc* LOC161;
		LOC160 = 0;
		LOC161 = 0;
		LOC161 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
		LOC160 = rawNewString(LOC161->Sup.len + 5);
appendString(LOC160, ((NimStringDesc*) &TMP2061));
appendString(LOC160, LOC161);
appendChar(LOC160, 93);
		result = LOC160;
	}
	break;
	case ((NU8) 15):
	{
		NimStringDesc* LOC163;
		NimStringDesc* LOC164;
		LOC163 = 0;
		LOC164 = 0;
		LOC164 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
		LOC163 = rawNewString(LOC164->Sup.len + 9);
appendString(LOC163, ((NimStringDesc*) &TMP2062));
appendString(LOC163, LOC164);
appendChar(LOC163, 93);
		result = LOC163;
	}
	break;
	case ((NU8) 19):
	{
		NimStringDesc* LOC166;
		NimStringDesc* LOC167;
		LOC166 = 0;
		LOC167 = 0;
		LOC167 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
		LOC166 = rawNewString(LOC167->Sup.len + 5);
appendString(LOC166, ((NimStringDesc*) &TMP2063));
appendString(LOC166, LOC167);
appendChar(LOC166, 93);
		result = LOC166;
	}
	break;
	case ((NU8) 27):
	{
		NimStringDesc* LOC169;
		NimStringDesc* LOC170;
		LOC169 = 0;
		LOC170 = 0;
		LOC170 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
		LOC169 = rawNewString(LOC170->Sup.len + 11);
appendString(LOC169, ((NimStringDesc*) &TMP2064));
appendString(LOC169, LOC170);
appendChar(LOC169, 93);
		result = LOC169;
	}
	break;
	case ((NU8) 13):
	{
		NimStringDesc* LOC172;
		NU8 LOC173;
		NimStringDesc* LOC179;
		LOC172 = 0;
		LOC173 = 0;
		{
			if (!(prefer == ((NU8) 3))) goto LA176;
			LOC173 = ((NU8) 3);
		}
		goto LA174;
		LA176: ;
		{
			LOC173 = ((NU8) 0);
		}
		LA174: ;
		LOC179 = 0;
		LOC179 = typetostring_221032((*t).sons->data[((NI) 0)], LOC173);
		LOC172 = rawNewString(LOC179->Sup.len + 9);
appendString(LOC172, ((NimStringDesc*) &TMP2065));
appendString(LOC172, LOC179);
		result = LOC172;
	}
	break;
	case ((NU8) 18):
	{
		{
			if (!!(((*t).n == NIM_NIL))) goto LA183;
			result = copyString(((NimStringDesc*) &TMP2066));
			{
				NI i_224013;
				NI HEX3Atmp_224384;
				NI LOC186;
				NI res_224387;
				i_224013 = 0;
				HEX3Atmp_224384 = 0;
				LOC186 = 0;
				LOC186 = sonslen_194403((*t).n);
				HEX3Atmp_224384 = (NI)(LOC186 - ((NI) 1));
				res_224387 = ((NI) 0);
				{
					while (1) {
						NimStringDesc* LOC189;
						NimStringDesc* LOC190;
						if (!(res_224387 <= HEX3Atmp_224384)) goto LA188;
						i_224013 = res_224387;
						LOC189 = 0;
						LOC190 = 0;
						LOC190 = typetostring_221032((*t).sons->data[i_224013], ((NU8) 0));
						LOC189 = rawNewString((*(*(*(*(*t).n).kindU.S6.sons->data[i_224013]).kindU.S4.sym).name).s->Sup.len + LOC190->Sup.len + 2);
appendString(LOC189, (*(*(*(*(*t).n).kindU.S6.sons->data[i_224013]).kindU.S4.sym).name).s);
appendString(LOC189, ((NimStringDesc*) &TMP2067));
appendString(LOC189, LOC190);
						result = resizeString(result, LOC189->Sup.len + 0);
appendString(result, LOC189);
						{
							NI LOC193;
							LOC193 = 0;
							LOC193 = sonslen_194403((*t).n);
							if (!(i_224013 < (NI)(LOC193 - ((NI) 1)))) goto LA194;
							result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TMP2034));
						}
						LA194: ;
						res_224387 += ((NI) 1);
					} LA188: ;
				}
			}
			result = addChar(result, 93);
		}
		goto LA181;
		LA183: ;
		{
			NI LOC197;
			LOC197 = 0;
			LOC197 = sonslen_194351(t);
			if (!(LOC197 == ((NI) 0))) goto LA198;
			result = copyString(((NimStringDesc*) &TMP2068));
		}
		goto LA181;
		LA198: ;
		{
			result = copyString(((NimStringDesc*) &TMP2041));
			{
				NI i_224216;
				NI HEX3Atmp_224392;
				NI LOC202;
				NI res_224395;
				i_224216 = 0;
				HEX3Atmp_224392 = 0;
				LOC202 = 0;
				LOC202 = sonslen_194351(t);
				HEX3Atmp_224392 = (NI)(LOC202 - ((NI) 1));
				res_224395 = ((NI) 0);
				{
					while (1) {
						NimStringDesc* LOC205;
						if (!(res_224395 <= HEX3Atmp_224392)) goto LA204;
						i_224216 = res_224395;
						LOC205 = 0;
						LOC205 = typetostring_221032((*t).sons->data[i_224216], ((NU8) 0));
						result = resizeString(result, LOC205->Sup.len + 0);
appendString(result, LOC205);
						{
							NI LOC208;
							LOC208 = 0;
							LOC208 = sonslen_194351(t);
							if (!(i_224216 < (NI)(LOC208 - ((NI) 1)))) goto LA209;
							result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TMP2034));
						}
						LA209: ;
						res_224395 += ((NI) 1);
					} LA204: ;
				}
			}
			result = addChar(result, 41);
		}
		LA181: ;
	}
	break;
	case ((NU8) 21):
	case ((NU8) 22):
	case ((NU8) 23):
	case ((NU8) 47):
	case ((NU8) 46):
	{
		result = copyString(typetostr_223609[((*t).kind)- 0]);
		{
			NI LOC214;
			LOC214 = 0;
			LOC214 = len_194377(t);
			if (!(((NI) 2) <= LOC214)) goto LA215;
			result = setLengthStr(result, ((NI) ((NI)((result ? result->Sup.len : 0) - ((NI) 1)))));
			result = addChar(result, 91);
			{
				NI i_224229;
				NI HEX3Atmp_224400;
				NI LOC218;
				NI res_224403;
				i_224229 = 0;
				HEX3Atmp_224400 = 0;
				LOC218 = 0;
				LOC218 = sonslen_194351(t);
				HEX3Atmp_224400 = (NI)(LOC218 - ((NI) 1));
				res_224403 = ((NI) 0);
				{
					while (1) {
						NimStringDesc* LOC221;
						if (!(res_224403 <= HEX3Atmp_224400)) goto LA220;
						i_224229 = res_224403;
						LOC221 = 0;
						LOC221 = typetostring_221032((*t).sons->data[i_224229], ((NU8) 0));
						result = resizeString(result, LOC221->Sup.len + 0);
appendString(result, LOC221);
						{
							NI LOC224;
							LOC224 = 0;
							LOC224 = sonslen_194351(t);
							if (!(i_224229 < (NI)(LOC224 - ((NI) 1)))) goto LA225;
							result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TMP2034));
						}
						LA225: ;
						res_224403 += ((NI) 1);
					} LA220: ;
				}
			}
			result = addChar(result, 93);
		}
		goto LA212;
		LA215: ;
		{
			NimStringDesc* LOC228;
			LOC228 = 0;
			LOC228 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
			result = resizeString(result, LOC228->Sup.len + 0);
appendString(result, LOC228);
		}
		LA212: ;
	}
	break;
	case ((NU8) 20):
	{
		NimStringDesc* LOC230;
		NimStringDesc* LOC231;
		LOC230 = 0;
		LOC231 = 0;
		LOC231 = rangetostr_223451((*t).n);
		LOC230 = rawNewString(LOC231->Sup.len + 6);
appendString(LOC230, ((NimStringDesc*) &TMP2069));
appendString(LOC230, LOC231);
		result = LOC230;
		{
			NimStringDesc* LOC236;
			NimStringDesc* LOC237;
			if (!!((prefer == ((NU8) 2)))) goto LA234;
			LOC236 = 0;
			LOC237 = 0;
			LOC237 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
			LOC236 = rawNewString(LOC237->Sup.len + 2);
appendString(LOC236, ((NimStringDesc*) &TMP2041));
appendString(LOC236, LOC237);
appendString(LOC236, ((NimStringDesc*) &TMP1970));
			result = resizeString(result, LOC236->Sup.len + 0);
appendString(result, LOC236);
		}
		LA234: ;
	}
	break;
	case ((NU8) 25):
	{
		NimStringDesc* prag;
		{
			if (!(((*t).flags &(1<<((((NU8) 14))&31)))!=0)) goto LA241;
			result = copyString(((NimStringDesc*) &TMP2070));
		}
		goto LA239;
		LA241: ;
		{
			result = copyString(((NimStringDesc*) &TMP2071));
		}
		LA239: ;
		{
			NI i_224261;
			NI HEX3Atmp_224408;
			NI LOC245;
			NI res_224411;
			i_224261 = 0;
			HEX3Atmp_224408 = 0;
			LOC245 = 0;
			LOC245 = sonslen_194351(t);
			HEX3Atmp_224408 = (NI)(LOC245 - ((NI) 1));
			res_224411 = ((NI) 1);
			{
				while (1) {
					NimStringDesc* LOC259;
					if (!(res_224411 <= HEX3Atmp_224408)) goto LA247;
					i_224261 = res_224411;
					{
						NIM_BOOL LOC250;
						NIM_BOOL LOC251;
						NI LOC253;
						Tnode191813* LOC255;
						Tnode191813* LOC258;
						LOC250 = 0;
						LOC251 = 0;
						LOC251 = !(((*t).n == NIM_NIL));
						if (!(LOC251)) goto LA252;
						LOC253 = 0;
						LOC253 = len_192097((*t).n);
						LOC251 = (i_224261 < LOC253);
						LA252: ;
						LOC250 = LOC251;
						if (!(LOC250)) goto LA254;
						LOC255 = 0;
						LOC255 = HEX5BHEX5D_192244((*t).n, i_224261);
						LOC250 = ((*LOC255).kind == ((NU8) 3));
						LA254: ;
						if (!LOC250) goto LA256;
						LOC258 = 0;
						LOC258 = HEX5BHEX5D_192244((*t).n, i_224261);
						result = resizeString(result, (*(*(*LOC258).kindU.S4.sym).name).s->Sup.len + 0);
appendString(result, (*(*(*LOC258).kindU.S4.sym).name).s);
						result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TMP2067));
					}
					LA256: ;
					LOC259 = 0;
					LOC259 = typetostring_221032((*t).sons->data[i_224261], ((NU8) 0));
					result = resizeString(result, LOC259->Sup.len + 0);
appendString(result, LOC259);
					{
						NI LOC262;
						LOC262 = 0;
						LOC262 = sonslen_194351(t);
						if (!(i_224261 < (NI)(LOC262 - ((NI) 1)))) goto LA263;
						result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TMP2034));
					}
					LA263: ;
					res_224411 += ((NI) 1);
				} LA247: ;
			}
		}
		result = addChar(result, 41);
		{
			NimStringDesc* LOC269;
			NimStringDesc* LOC270;
			if (!!(((*t).sons->data[((NI) 0)] == NIM_NIL))) goto LA267;
			LOC269 = 0;
			LOC270 = 0;
			LOC270 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
			LOC269 = rawNewString(LOC270->Sup.len + 2);
appendString(LOC269, ((NimStringDesc*) &TMP2067));
appendString(LOC269, LOC270);
			result = resizeString(result, LOC269->Sup.len + 0);
appendString(result, LOC269);
		}
		LA267: ;
		{
			if (!((*t).callconv == ((NU8) 0))) goto LA273;
			prag = copyString(((NimStringDesc*) &TMP1968));
		}
		goto LA271;
		LA273: ;
		{
			prag = copyString(Callingconvtostr_191019[((*t).callconv)- 0]);
		}
		LA271: ;
		{
			if (!(((*t).flags &(1<<((((NU8) 1))&31)))!=0)) goto LA278;
			addsep_99447((&prag), ((NimStringDesc*) &TMP2034), ((NI) 0));
			prag = resizeString(prag, 12);
appendString(prag, ((NimStringDesc*) &TMP2082));
		}
		LA278: ;
		{
			if (!(((*t).flags &(1<<((((NU8) 7))&31)))!=0)) goto LA282;
			addsep_99447((&prag), ((NimStringDesc*) &TMP2034), ((NI) 0));
			prag = resizeString(prag, 6);
appendString(prag, ((NimStringDesc*) &TMP2083));
		}
		LA282: ;
		{
			NimStringDesc* LOC288;
			NimStringDesc* LOC289;
			if (!!((((NI) ((*t).locklevel)) == ((NI) -1)))) goto LA286;
			addsep_99447((&prag), ((NimStringDesc*) &TMP2034), ((NI) 0));
			LOC288 = 0;
			LOC289 = 0;
			LOC289 = HEX24_194096((*t).locklevel);
			LOC288 = rawNewString(LOC289->Sup.len + 7);
appendString(LOC288, ((NimStringDesc*) &TMP2084));
appendString(LOC288, LOC289);
			prag = resizeString(prag, LOC288->Sup.len + 0);
appendString(prag, LOC288);
		}
		LA286: ;
		{
			NimStringDesc* LOC294;
			if (!!(((prag ? prag->Sup.len : 0) == ((NI) 0)))) goto LA292;
			LOC294 = 0;
			LOC294 = rawNewString(prag->Sup.len + 4);
appendString(LOC294, ((NimStringDesc*) &TMP2087));
appendString(LOC294, prag);
appendString(LOC294, ((NimStringDesc*) &TMP2088));
			result = resizeString(result, LOC294->Sup.len + 0);
appendString(result, LOC294);
		}
		LA292: ;
	}
	break;
	case ((NU8) 48):
	case ((NU8) 49):
	{
		NimStringDesc* LOC296;
		LOC296 = 0;
		LOC296 = typetostring_221032((*t).sons->data[((NI) 0)], ((NU8) 0));
		result = nsuFormatSingleElem(typetostr_223609[((*t).kind)- 0], LOC296);
	}
	break;
	default:
	{
		result = copyString(typetostr_223609[((*t).kind)- 0]);
	}
	break;
	}
	{
		NimStringDesc* LOC302;
		if (!(((*t).flags &(1<<((((NU8) 15))&31)))!=0)) goto LA300;
		LOC302 = 0;
		LOC302 = rawNewString(result->Sup.len + 7);
appendString(LOC302, ((NimStringDesc*) &TMP2089));
appendString(LOC302, result);
		result = LOC302;
	}
	LA300: ;
	{
		if (!(((*t).flags &(1<<((((NU8) 16))&31)))!=0)) goto LA305;
		result = resizeString(result, 8);
appendString(result, ((NimStringDesc*) &TMP2090));
	}
	LA305: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, elemtype_221522)(Ttype191849* t) {
	Ttype191849* result;
	result = 0;
	switch ((*t).kind) {
	case ((NU8) 11):
	case ((NU8) 13):
	{
		Ttype191849* LOC2;
		LOC2 = 0;
		LOC2 = lastson_194442(t);
		result = elemtype_221522(LOC2);
	}
	break;
	case ((NU8) 16):
	case ((NU8) 4):
	{
		result = (*t).sons->data[((NI) 1)];
	}
	break;
	default:
	{
		result = lastson_194442(t);
	}
	break;
	}
	return result;
}

N_NIMCALL(void, initsametypeclosure_225863)(Tsametypeclosure225841* Result) {
}

N_NIMCALL(NIM_BOOL, isgenericalias_227091)(Ttype191849* t) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	Ttype191849* LOC3;
{	result = 0;
	LOC1 = 0;
	LOC1 = ((*t).kind == ((NU8) 11));
	if (!(LOC1)) goto LA2;
	LOC3 = 0;
	LOC3 = lastson_194442(t);
	LOC1 = ((*LOC3).kind == ((NU8) 11));
	LA2: ;
	result = LOC1;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, skipgenericalias_227119)(Ttype191849* t) {
	Ttype191849* result;
{	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = isgenericalias_227091(t);
		if (!LOC3) goto LA4;
		result = lastson_194442(t);
	}
	goto LA1;
	LA4: ;
	{
		result = t;
	}
	LA1: ;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

static N_INLINE(NIM_BOOL, sameflags_227141)(Ttype191849* a, Ttype191849* b) {
	NIM_BOOL result;
	result = 0;
	result = ((376832 & (*a).flags) == (376832 & (*b).flags));
	return result;
}

static N_INLINE(NI, find_225900)(TY225855* a, NI aLen0, TY225855 item) {
	NI result;
{	result = 0;
	{
		TY225855 i_225944;
		NI i_225978;
		memset((void*)(&i_225944), 0, sizeof(i_225944));
		i_225978 = ((NI) 0);
		{
			while (1) {
				if (!(i_225978 < aLen0)) goto LA3;
				i_225944 = a[i_225978];
				{
					NIM_BOOL LOC6;
					LOC6 = 0;
					LOC6 = HEX3DHEX3D_225946(i_225944, item);
					if (!LOC6) goto LA7;
					goto BeforeRet;
				}
				LA7: ;
				result += ((NI) 1);
				i_225978 += ((NI) 1);
			} LA3: ;
		}
	}
	result = ((NI) -1);
	}BeforeRet: ;
	return result;
}

static N_INLINE(NIM_BOOL, contains_225890)(TY225855* a, NI aLen0, TY225855 item) {
	NIM_BOOL result;
	NI LOC1;
{	result = 0;
	LOC1 = 0;
	LOC1 = find_225900(a, aLen0, item);
	result = (((NI) 0) <= LOC1);
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}
N_NIMCALL(void, TMP2632)(void* p, NI op) {
	TY225854* a;
	NI LOC1;
	a = (TY225854*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	}
}

N_NIMCALL(NIM_BOOL, containsorincl_225872)(Tsametypeclosure225841* c, Ttype191849* a, Ttype191849* b) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	TY225855 LOC3;
	result = 0;
	LOC1 = 0;
	LOC1 = !((*c).s == 0);
	if (!(LOC1)) goto LA2;
	LOC3.Field0 = (*a).Sup.id;
	LOC3.Field1 = (*b).Sup.id;
	LOC1 = contains_225890((*c).s->data, (*c).s->Sup.len, LOC3);
	LA2: ;
	result = LOC1;
	{
		TY225855 LOC12;
		if (!!(result)) goto LA6;
		{
			if (!(*c).s == 0) goto LA10;
			unsureAsgnRef((void**) (&(*c).s), (TY225854*) newSeq((&NTI225854), 0));
		}
		LA10: ;
		LOC12.Field0 = (*a).Sup.id;
		LOC12.Field1 = (*b).Sup.id;
		(*c).s = (TY225854*) incrSeq(&((*c).s)->Sup, sizeof(TY225855));
		(*c).s->data[(*c).s->Sup.len-1] = LOC12;
	}
	LA6: ;
	return result;
}

N_NIMCALL(NIM_BOOL, sametypeornilaux_226044)(Ttype191849* a, Ttype191849* b, Tsametypeclosure225841* c) {
	NIM_BOOL result;
	result = 0;
	{
		if (!(a == b)) goto LA3;
		result = NIM_TRUE;
	}
	goto LA1;
	LA3: ;
	{
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = (a == NIM_NIL);
			if (LOC8) goto LA9;
			LOC8 = (b == NIM_NIL);
			LA9: ;
			if (!LOC8) goto LA10;
			result = NIM_FALSE;
		}
		goto LA6;
		LA10: ;
		{
			result = sametypeaux_226035(a, b, c);
		}
		LA6: ;
	}
	LA1: ;
	return result;
}

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

N_NIMCALL(NIM_BOOL, sameobjecttree_226866)(Tnode191813* a, Tnode191813* b, Tsametypeclosure225841* c) {
	NIM_BOOL result;
{	result = 0;
	{
		if (!(a == b)) goto LA3;
		result = NIM_TRUE;
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC6;
		NIM_BOOL LOC7;
		Ttype191849* x;
		Ttype191849* y;
		LOC6 = 0;
		LOC7 = 0;
		LOC7 = !((a == NIM_NIL));
		if (!(LOC7)) goto LA8;
		LOC7 = !((b == NIM_NIL));
		LA8: ;
		LOC6 = LOC7;
		if (!(LOC6)) goto LA9;
		LOC6 = ((*a).kind == (*b).kind);
		LA9: ;
		if (!LOC6) goto LA10;
		x = (*a).typ;
		y = (*b).typ;
		{
			if (!(((*c).flags &(1<<((((NU8) 0))&7)))!=0)) goto LA14;
			{
				if (!!((x == NIM_NIL))) goto LA18;
				x = skiptypes_195167(x, 1050624);
			}
			LA18: ;
			{
				if (!!((y == NIM_NIL))) goto LA22;
				y = skiptypes_195167(y, 1050624);
			}
			LA22: ;
		}
		LA14: ;
		{
			NIM_BOOL LOC26;
			LOC26 = 0;
			LOC26 = sametypeornilaux_226044(x, y, c);
			if (!LOC26) goto LA27;
			switch ((*a).kind) {
			case ((NU8) 3):
			{
				result = ((*(*(*a).kindU.S4.sym).name).Sup.id == (*(*(*b).kindU.S4.sym).name).Sup.id);
			}
			break;
			case ((NU8) 2):
			{
				result = ((*(*a).kindU.S5.ident).Sup.id == (*(*b).kindU.S5.ident).Sup.id);
			}
			break;
			case ((NU8) 5) ... ((NU8) 10):
			{
				result = ((*a).kindU.S1.intval == (*b).kindU.S1.intval);
			}
			break;
			case ((NU8) 16) ... ((NU8) 18):
			{
				result = ((*a).kindU.S2.floatval == (*b).kindU.S2.floatval);
			}
			break;
			case ((NU8) 20) ... ((NU8) 22):
			{
				result = eqStrings((*a).kindU.S3.strval, (*b).kindU.S3.strval);
			}
			break;
			case ((NU8) 1):
			case ((NU8) 23):
			case ((NU8) 4):
			{
				result = NIM_TRUE;
			}
			break;
			default:
			{
				{
					NI LOC38;
					NI LOC39;
					LOC38 = 0;
					LOC38 = sonslen_194403(a);
					LOC39 = 0;
					LOC39 = sonslen_194403(b);
					if (!(LOC38 == LOC39)) goto LA40;
					{
						NI i_226979;
						NI HEX3Atmp_226983;
						NI LOC43;
						NI res_226986;
						i_226979 = 0;
						HEX3Atmp_226983 = 0;
						LOC43 = 0;
						LOC43 = sonslen_194403(a);
						HEX3Atmp_226983 = (NI)(LOC43 - ((NI) 1));
						res_226986 = ((NI) 0);
						{
							while (1) {
								if (!(res_226986 <= HEX3Atmp_226983)) goto LA45;
								i_226979 = res_226986;
								{
									NIM_BOOL LOC48;
									LOC48 = 0;
									LOC48 = sameobjecttree_226866((*a).kindU.S6.sons->data[i_226979], (*b).kindU.S6.sons->data[i_226979], c);
									if (!!(LOC48)) goto LA49;
									goto BeforeRet;
								}
								LA49: ;
								res_226986 += ((NI) 1);
							} LA45: ;
						}
					}
					result = NIM_TRUE;
				}
				LA40: ;
			}
			break;
			}
		}
		LA27: ;
	}
	goto LA1;
	LA10: ;
	LA1: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, sameobjectstructures_227005)(Ttype191849* a, Ttype191849* b, Tsametypeclosure225841* c) {
	NIM_BOOL result;
{	result = 0;
	{
		NI LOC3;
		NI LOC4;
		LOC3 = 0;
		LOC3 = sonslen_194351(a);
		LOC4 = 0;
		LOC4 = sonslen_194351(b);
		if (!!((LOC3 == LOC4))) goto LA5;
		goto BeforeRet;
	}
	LA5: ;
	{
		NI i_227024;
		NI HEX3Atmp_227026;
		NI LOC8;
		NI res_227029;
		i_227024 = 0;
		HEX3Atmp_227026 = 0;
		LOC8 = 0;
		LOC8 = sonslen_194351(a);
		HEX3Atmp_227026 = (NI)(LOC8 - ((NI) 1));
		res_227029 = ((NI) 0);
		{
			while (1) {
				if (!(res_227029 <= HEX3Atmp_227026)) goto LA10;
				i_227024 = res_227029;
				{
					NIM_BOOL LOC13;
					LOC13 = 0;
					LOC13 = sametypeornilaux_226044((*a).sons->data[i_227024], (*b).sons->data[i_227024], c);
					if (!!(LOC13)) goto LA14;
					goto BeforeRet;
				}
				LA14: ;
				res_227029 += ((NI) 1);
			} LA10: ;
		}
	}
	{
		NIM_BOOL LOC18;
		LOC18 = 0;
		LOC18 = sameobjecttree_226866((*a).n, (*b).n, c);
		if (!!(LOC18)) goto LA19;
		goto BeforeRet;
	}
	LA19: ;
	result = NIM_TRUE;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, sametuple_226622)(Ttype191849* a, Ttype191849* b, Tsametypeclosure225841* c) {
	NIM_BOOL result;
{	result = 0;
	{
		NI LOC3;
		NI LOC4;
		LOC3 = 0;
		LOC3 = sonslen_194351(a);
		LOC4 = 0;
		LOC4 = sonslen_194351(b);
		if (!(LOC3 == LOC4)) goto LA5;
		result = NIM_TRUE;
		{
			NI i_226641;
			NI HEX3Atmp_226732;
			NI LOC8;
			NI res_226735;
			i_226641 = 0;
			HEX3Atmp_226732 = 0;
			LOC8 = 0;
			LOC8 = sonslen_194351(a);
			HEX3Atmp_226732 = (NI)(LOC8 - ((NI) 1));
			res_226735 = ((NI) 0);
			{
				while (1) {
					Ttype191849* x;
					Ttype191849* y;
					if (!(res_226735 <= HEX3Atmp_226732)) goto LA10;
					i_226641 = res_226735;
					x = (*a).sons->data[i_226641];
					y = (*b).sons->data[i_226641];
					{
						if (!(((*c).flags &(1<<((((NU8) 0))&7)))!=0)) goto LA13;
						x = skiptypes_195167(x, 1050624);
						y = skiptypes_195167(y, 1050624);
					}
					LA13: ;
					result = sametypeaux_226035(x, y, c);
					{
						if (!!(result)) goto LA17;
						goto BeforeRet;
					}
					LA17: ;
					res_226735 += ((NI) 1);
				} LA10: ;
			}
		}
		{
			NIM_BOOL LOC21;
			NIM_BOOL LOC22;
			LOC21 = 0;
			LOC22 = 0;
			LOC22 = !(((*a).n == NIM_NIL));
			if (!(LOC22)) goto LA23;
			LOC22 = !(((*b).n == NIM_NIL));
			LA23: ;
			LOC21 = LOC22;
			if (!(LOC21)) goto LA24;
			LOC21 = !((((*c).flags &(1<<((((NU8) 0))&7)))!=0));
			LA24: ;
			if (!LOC21) goto LA25;
			{
				NI i_226702;
				NI HEX3Atmp_226740;
				NI LOC28;
				NI res_226743;
				i_226702 = 0;
				HEX3Atmp_226740 = 0;
				LOC28 = 0;
				LOC28 = sonslen_194403((*a).n);
				HEX3Atmp_226740 = (NI)(LOC28 - ((NI) 1));
				res_226743 = ((NI) 0);
				{
					while (1) {
						if (!(res_226743 <= HEX3Atmp_226740)) goto LA30;
						i_226702 = res_226743;
						{
							NIM_BOOL LOC33;
							Tsym191843* x;
							Tsym191843* y;
							LOC33 = 0;
							LOC33 = ((*(*(*a).n).kindU.S6.sons->data[i_226702]).kind == ((NU8) 3));
							if (!(LOC33)) goto LA34;
							LOC33 = ((*(*(*b).n).kindU.S6.sons->data[i_226702]).kind == ((NU8) 3));
							LA34: ;
							if (!LOC33) goto LA35;
							x = (*(*(*a).n).kindU.S6.sons->data[i_226702]).kindU.S4.sym;
							y = (*(*(*b).n).kindU.S6.sons->data[i_226702]).kindU.S4.sym;
							result = ((*(*x).name).Sup.id == (*(*y).name).Sup.id);
							{
								if (!!(result)) goto LA39;
								goto LA27;
							}
							LA39: ;
						}
						goto LA31;
						LA35: ;
						{
							internalerror_166199((*(*a).n).info, ((NimStringDesc*) &TMP2633));
						}
						LA31: ;
						res_226743 += ((NI) 1);
					} LA30: ;
				}
			} LA27: ;
		}
		LA25: ;
	}
	LA5: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, samechildrenaux_227048)(Ttype191849* a, Ttype191849* b, Tsametypeclosure225841* c) {
	NIM_BOOL result;
{	result = 0;
	{
		NI LOC3;
		NI LOC4;
		LOC3 = 0;
		LOC3 = sonslen_194351(a);
		LOC4 = 0;
		LOC4 = sonslen_194351(b);
		if (!!((LOC3 == LOC4))) goto LA5;
		result = NIM_FALSE;
		goto BeforeRet;
	}
	LA5: ;
	result = NIM_TRUE;
	{
		NI i_227067;
		NI HEX3Atmp_227069;
		NI LOC8;
		NI res_227072;
		i_227067 = 0;
		HEX3Atmp_227069 = 0;
		LOC8 = 0;
		LOC8 = sonslen_194351(a);
		HEX3Atmp_227069 = (NI)(LOC8 - ((NI) 1));
		res_227072 = ((NI) 0);
		{
			while (1) {
				if (!(res_227072 <= HEX3Atmp_227069)) goto LA10;
				i_227067 = res_227072;
				result = sametypeornilaux_226044((*a).sons->data[i_227067], (*b).sons->data[i_227067], c);
				{
					if (!!(result)) goto LA13;
					goto BeforeRet;
				}
				LA13: ;
				res_227072 += ((NI) 1);
			} LA10: ;
		}
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, sameconstraints_226240)(Tnode191813* a, Tnode191813* b) {
	NIM_BOOL result;
{	result = 0;
	{
		NI LOC3;
		NI LOC4;
		NimStringDesc* LOC7;
		LOC3 = 0;
		LOC3 = len_192097(a);
		LOC4 = 0;
		LOC4 = len_192097(b);
		if (!!((LOC3 == LOC4))) goto LA5;
		LOC7 = 0;
		LOC7 = HEX24_166306(TMP2634);
		internalerror_166218(LOC7);
	}
	LA5: ;
	{
		NI i_226273;
		NI HEX3Atmp_226279;
		NI LOC9;
		NI res_226282;
		i_226273 = 0;
		HEX3Atmp_226279 = 0;
		LOC9 = 0;
		LOC9 = len_192097(a);
		HEX3Atmp_226279 = (LOC9 - 1);
		res_226282 = ((NI) 1);
		{
			while (1) {
				if (!(res_226282 <= HEX3Atmp_226279)) goto LA11;
				i_226273 = res_226282;
				{
					Tnode191813* LOC14;
					Tnode191813* LOC15;
					NIM_BOOL LOC16;
					LOC14 = 0;
					LOC14 = HEX5BHEX5D_192244(a, i_226273);
					LOC15 = 0;
					LOC15 = HEX5BHEX5D_192244(b, i_226273);
					LOC16 = 0;
					LOC16 = exprstructuralequivalent_220149((*(*LOC14).kindU.S4.sym).constraint, (*(*LOC15).kindU.S4.sym).constraint);
					if (!!(LOC16)) goto LA17;
					result = NIM_FALSE;
					goto BeforeRet;
				}
				LA17: ;
				res_226282 += ((NI) 1);
			} LA11: ;
		}
	}
	result = NIM_TRUE;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, sametypeaux_226035)(Ttype191849* x, Ttype191849* y, Tsametypeclosure225841* c) {
	NIM_BOOL result;
	Ttype191849* a;
	Ttype191849* b;
{	result = 0;
	{
		if (!(x == y)) goto LA3;
		result = NIM_TRUE;
		goto BeforeRet;
	}
	LA3: ;
	a = skiptypes_195167(x, 2048);
	b = skiptypes_195167(y, 2048);
	{
		if (!!(((*a).kind == (*b).kind))) goto LA7;
		switch ((*c).cmp) {
		case ((NU8) 0):
		{
			result = NIM_FALSE;
			goto BeforeRet;
		}
		break;
		case ((NU8) 1):
		{
			{
				while (1) {
					if (!((*a).kind == ((NU8) 13))) goto LA12;
					a = (*a).sons->data[((NI) 0)];
				} LA12: ;
			}
			{
				while (1) {
					if (!((*b).kind == ((NU8) 13))) goto LA14;
					b = (*b).sons->data[((NI) 0)];
				} LA14: ;
			}
			{
				if (!!(((*a).kind == (*b).kind))) goto LA17;
				result = NIM_FALSE;
				goto BeforeRet;
			}
			LA17: ;
		}
		break;
		case ((NU8) 2):
		{
			{
				while (1) {
					if (!((*a).kind == ((NU8) 13))) goto LA21;
					a = (*a).sons->data[((NI) 0)];
				} LA21: ;
			}
			{
				if (!!(((*a).kind == (*b).kind))) goto LA24;
				result = NIM_FALSE;
				goto BeforeRet;
			}
			LA24: ;
		}
		break;
		}
	}
	LA7: ;
	{
		Ttype191849* lhs;
		Ttype191849* rhs;
		if (!((*x).kind == ((NU8) 11))) goto LA28;
		lhs = skipgenericalias_227119(x);
		rhs = skipgenericalias_227119(y);
		{
			NIM_BOOL LOC32;
			Ttype191849* LOC34;
			Ttype191849* LOC35;
			LOC32 = 0;
			LOC32 = !(((*rhs).kind == ((NU8) 11)));
			if (LOC32) goto LA33;
			LOC34 = 0;
			LOC34 = base_221039(lhs);
			LOC35 = 0;
			LOC35 = base_221039(rhs);
			LOC32 = !((LOC34 == LOC35));
			LA33: ;
			if (!LOC32) goto LA36;
			result = NIM_FALSE;
			goto BeforeRet;
		}
		LA36: ;
		{
			NI i_227696;
			NI HEX3Atmp_227981;
			NI LOC39;
			NI res_227984;
			i_227696 = 0;
			HEX3Atmp_227981 = 0;
			LOC39 = 0;
			LOC39 = len_194377(lhs);
			HEX3Atmp_227981 = (NI)(LOC39 - ((NI) 2));
			res_227984 = ((NI) 1);
			{
				while (1) {
					Ttype191849* ff;
					Ttype191849* aa;
					if (!(res_227984 <= HEX3Atmp_227981)) goto LA41;
					i_227696 = res_227984;
					ff = (*rhs).sons->data[i_227696];
					aa = (*lhs).sons->data[i_227696];
					{
						NIM_BOOL LOC44;
						LOC44 = 0;
						LOC44 = sametypeaux_226035(ff, aa, c);
						if (!!(LOC44)) goto LA45;
						result = NIM_FALSE;
						goto BeforeRet;
					}
					LA45: ;
					res_227984 += ((NI) 1);
				} LA41: ;
			}
		}
		result = NIM_TRUE;
		goto BeforeRet;
	}
	LA28: ;
	switch ((*a).kind) {
	case ((NU8) 3):
	case ((NU8) 2):
	case ((NU8) 1):
	case ((NU8) 5):
	case ((NU8) 26):
	case ((NU8) 28):
	case ((NU8) 29):
	case ((NU8) 31) ... ((NU8) 45):
	case ((NU8) 7):
	case ((NU8) 6):
	{
		result = sameflags_227141(a, b);
	}
	break;
	case ((NU8) 59):
	case ((NU8) 60):
	{
		NIM_BOOL LOC49;
		LOC49 = 0;
		LOC49 = exprstructuralequivalent_220149((*a).n, (*b).n);
		if (!(LOC49)) goto LA50;
		LOC49 = sameflags_227141(a, b);
		LA50: ;
		result = LOC49;
		{
			NIM_BOOL LOC53;
			NIM_BOOL LOC54;
			NI LOC56;
			NI LOC57;
			NI LOC59;
			LOC53 = 0;
			LOC54 = 0;
			LOC54 = result;
			if (!(LOC54)) goto LA55;
			LOC56 = 0;
			LOC56 = len_194377(a);
			LOC57 = 0;
			LOC57 = len_194377(b);
			LOC54 = (LOC56 == LOC57);
			LA55: ;
			LOC53 = LOC54;
			if (!(LOC53)) goto LA58;
			LOC59 = 0;
			LOC59 = len_194377(a);
			LOC53 = (LOC59 == ((NI) 1));
			LA58: ;
			if (!LOC53) goto LA60;
			{
				if (!((*c).reccheck < ((NI) 3))) goto LA64;
				(*c).reccheck += ((NI) 1);
			}
			goto LA62;
			LA64: ;
			{
				{
					NIM_BOOL LOC69;
					LOC69 = 0;
					LOC69 = containsorincl_225872(c, a, b);
					if (!LOC69) goto LA70;
					result = NIM_TRUE;
					goto BeforeRet;
				}
				LA70: ;
			}
			LA62: ;
			result = sametypeaux_226035((*a).sons->data[((NI) 0)], (*b).sons->data[((NI) 0)], c);
		}
		LA60: ;
	}
	break;
	case ((NU8) 17):
	{
		{
			if (!!(((((*a).flags | (*b).flags) &(1<<((((NU8) 8))&31)))!=0))) goto LA75;
			result = ((*a).Sup.id == (*b).Sup.id);
		}
		goto LA73;
		LA75: ;
		{
			{
				NIM_BOOL LOC80;
				NIM_BOOL LOC94;
				LOC80 = 0;
				LOC80 = ((((*a).flags & (*b).flags) &(1<<((((NU8) 8))&31)))!=0);
				if (!(LOC80)) goto LA81;
				LOC80 = ((*(*a).sym).Sup.id == (*(*b).sym).Sup.id);
				LA81: ;
				if (!LOC80) goto LA82;
				{
					if (!((*c).reccheck < ((NI) 3))) goto LA86;
					(*c).reccheck += ((NI) 1);
				}
				goto LA84;
				LA86: ;
				{
					{
						NIM_BOOL LOC91;
						LOC91 = 0;
						LOC91 = containsorincl_225872(c, a, b);
						if (!LOC91) goto LA92;
						result = NIM_TRUE;
						goto BeforeRet;
					}
					LA92: ;
				}
				LA84: ;
				LOC94 = 0;
				LOC94 = sameobjectstructures_227005(a, b, c);
				if (!(LOC94)) goto LA95;
				LOC94 = sameflags_227141(a, b);
				LA95: ;
				result = LOC94;
			}
			LA82: ;
		}
		LA73: ;
	}
	break;
	case ((NU8) 13):
	{
		{
			if (!((*c).reccheck < ((NI) 3))) goto LA99;
			(*c).reccheck += ((NI) 1);
		}
		goto LA97;
		LA99: ;
		{
			{
				NIM_BOOL LOC104;
				LOC104 = 0;
				LOC104 = containsorincl_225872(c, a, b);
				if (!LOC104) goto LA105;
				result = NIM_TRUE;
				goto BeforeRet;
			}
			LA105: ;
		}
		LA97: ;
		{
			if (!((*c).cmp == ((NU8) 0))) goto LA109;
			{
				NIM_BOOL LOC113;
				LOC113 = 0;
				LOC113 = sameflags_227141(a, b);
				if (!LOC113) goto LA114;
				{
					if (!!(((((*a).flags | (*b).flags) &(1<<((((NU8) 8))&31)))!=0))) goto LA118;
					result = ((*a).Sup.id == (*b).Sup.id);
				}
				goto LA116;
				LA118: ;
				{
					{
						NIM_BOOL LOC123;
						LOC123 = 0;
						LOC123 = ((((*a).flags & (*b).flags) &(1<<((((NU8) 8))&31)))!=0);
						if (!(LOC123)) goto LA124;
						LOC123 = ((*(*a).sym).Sup.id == (*(*b).sym).Sup.id);
						LA124: ;
						if (!LOC123) goto LA125;
						result = sametypeaux_226035((*a).sons->data[((NI) 0)], (*b).sons->data[((NI) 0)], c);
					}
					LA125: ;
				}
				LA116: ;
			}
			LA114: ;
		}
		goto LA107;
		LA109: ;
		{
			NIM_BOOL LOC128;
			LOC128 = 0;
			LOC128 = sametypeaux_226035((*a).sons->data[((NI) 0)], (*b).sons->data[((NI) 0)], c);
			if (!(LOC128)) goto LA129;
			LOC128 = sameflags_227141(a, b);
			LA129: ;
			result = LOC128;
		}
		LA107: ;
	}
	break;
	case ((NU8) 14):
	case ((NU8) 30):
	{
		NIM_BOOL LOC131;
		LOC131 = 0;
		LOC131 = ((*a).Sup.id == (*b).Sup.id);
		if (!(LOC131)) goto LA132;
		LOC131 = sameflags_227141(a, b);
		LA132: ;
		result = LOC131;
	}
	break;
	case ((NU8) 50):
	{
		result = ((*b).kind == ((NU8) 50));
	}
	break;
	case ((NU8) 18):
	{
		NIM_BOOL LOC145;
		{
			if (!((*c).reccheck < ((NI) 3))) goto LA137;
			(*c).reccheck += ((NI) 1);
		}
		goto LA135;
		LA137: ;
		{
			{
				NIM_BOOL LOC142;
				LOC142 = 0;
				LOC142 = containsorincl_225872(c, a, b);
				if (!LOC142) goto LA143;
				result = NIM_TRUE;
				goto BeforeRet;
			}
			LA143: ;
		}
		LA135: ;
		LOC145 = 0;
		LOC145 = sametuple_226622(a, b, c);
		if (!(LOC145)) goto LA146;
		LOC145 = sameflags_227141(a, b);
		LA146: ;
		result = LOC145;
	}
	break;
	case ((NU8) 8):
	{
		{
			if (!((*c).cmp == ((NU8) 1))) goto LA150;
			result = NIM_FALSE;
		}
		goto LA148;
		LA150: ;
		{
			NIM_BOOL LOC165;
			if (!(((*c).flags &(1<<((((NU8) 2))&7)))!=0)) goto LA153;
			{
				if (!((*c).reccheck < ((NI) 3))) goto LA157;
				(*c).reccheck += ((NI) 1);
			}
			goto LA155;
			LA157: ;
			{
				{
					NIM_BOOL LOC162;
					LOC162 = 0;
					LOC162 = containsorincl_225872(c, a, b);
					if (!LOC162) goto LA163;
					result = NIM_TRUE;
					goto BeforeRet;
				}
				LA163: ;
			}
			LA155: ;
			LOC165 = 0;
			LOC165 = samechildrenaux_227048(x, y, c);
			if (!(LOC165)) goto LA166;
			LOC165 = sameflags_227141(a, b);
			LA166: ;
			result = LOC165;
		}
		goto LA148;
		LA153: ;
		{
			result = sameflags_227141(a, b);
		}
		LA148: ;
	}
	break;
	case ((NU8) 12):
	{
		NIM_BOOL LOC169;
		LOC169 = 0;
		LOC169 = samechildrenaux_227048(a, b, c);
		if (!(LOC169)) goto LA170;
		LOC169 = sameflags_227141(a, b);
		LA170: ;
		result = LOC169;
		{
			NIM_BOOL LOC173;
			LOC173 = 0;
			LOC173 = result;
			if (!(LOC173)) goto LA174;
			LOC173 = (((*c).flags &(1<<((((NU8) 3))&7)))!=0);
			LA174: ;
			if (!LOC173) goto LA175;
			result = ((*(*a).sym).position == (*(*b).sym).position);
		}
		LA175: ;
	}
	break;
	case ((NU8) 9):
	case ((NU8) 10):
	case ((NU8) 24):
	case ((NU8) 27):
	case ((NU8) 19):
	case ((NU8) 22):
	case ((NU8) 21):
	case ((NU8) 23):
	case ((NU8) 4):
	case ((NU8) 16):
	case ((NU8) 25):
	case ((NU8) 46):
	case ((NU8) 47):
	case ((NU8) 48):
	case ((NU8) 49):
	case ((NU8) 15):
	case ((NU8) 51):
	case ((NU8) 61):
	case ((NU8) 54):
	case ((NU8) 52):
	case ((NU8) 53):
	case ((NU8) 55):
	case ((NU8) 56):
	case ((NU8) 57):
	case ((NU8) 58):
	{
		NIM_BOOL LOC194;
		{
			if (!((*c).reccheck < ((NI) 3))) goto LA180;
			(*c).reccheck += ((NI) 1);
		}
		goto LA178;
		LA180: ;
		{
			{
				NIM_BOOL LOC185;
				LOC185 = 0;
				LOC185 = containsorincl_225872(c, a, b);
				if (!LOC185) goto LA186;
				result = NIM_TRUE;
				goto BeforeRet;
			}
			LA186: ;
		}
		LA178: ;
		{
			NIM_BOOL LOC190;
			LOC190 = 0;
			LOC190 = ((*a).kind == ((NU8) 52));
			if (!(LOC190)) goto LA191;
			LOC190 = !(((*a).n == NIM_NIL));
			LA191: ;
			if (!LOC190) goto LA192;
			result = ((*a).n == (*b).n);
			goto BeforeRet;
		}
		LA192: ;
		LOC194 = 0;
		LOC194 = samechildrenaux_227048(a, b, c);
		if (!(LOC194)) goto LA195;
		LOC194 = sameflags_227141(a, b);
		LA195: ;
		result = LOC194;
		{
			NIM_BOOL LOC198;
			NIM_BOOL LOC202;
			NIM_BOOL LOC203;
			NIM_BOOL LOC206;
			LOC198 = 0;
			LOC198 = result;
			if (!(LOC198)) goto LA199;
			LOC198 = ((*a).kind == ((NU8) 25));
			LA199: ;
			if (!LOC198) goto LA200;
			LOC202 = 0;
			LOC203 = 0;
			LOC203 = (((*c).flags &(1<<((((NU8) 1))&7)))!=0);
			if (LOC203) goto LA204;
			LOC203 = ((*a).callconv == (*b).callconv);
			LA204: ;
			LOC202 = LOC203;
			if (!(LOC202)) goto LA205;
			LOC206 = 0;
			LOC206 = !((((*c).flags &(1<<((((NU8) 4))&7)))!=0));
			if (LOC206) goto LA207;
			LOC206 = sameconstraints_226240((*a).n, (*b).n);
			LA207: ;
			LOC202 = LOC206;
			LA205: ;
			result = LOC202;
		}
		LA200: ;
	}
	break;
	case ((NU8) 20):
	{
		NIM_BOOL LOC219;
		NIM_BOOL LOC220;
		{
			if (!((*c).reccheck < ((NI) 3))) goto LA211;
			(*c).reccheck += ((NI) 1);
		}
		goto LA209;
		LA211: ;
		{
			{
				NIM_BOOL LOC216;
				LOC216 = 0;
				LOC216 = containsorincl_225872(c, a, b);
				if (!LOC216) goto LA217;
				result = NIM_TRUE;
				goto BeforeRet;
			}
			LA217: ;
		}
		LA209: ;
		LOC219 = 0;
		LOC220 = 0;
		LOC220 = sametypeornilaux_226044((*a).sons->data[((NI) 0)], (*b).sons->data[((NI) 0)], c);
		if (!(LOC220)) goto LA221;
		LOC220 = samevalue_199324((*(*a).n).kindU.S6.sons->data[((NI) 0)], (*(*b).n).kindU.S6.sons->data[((NI) 0)]);
		LA221: ;
		LOC219 = LOC220;
		if (!(LOC219)) goto LA222;
		LOC219 = samevalue_199324((*(*a).n).kindU.S6.sons->data[((NI) 1)], (*(*b).n).kindU.S6.sons->data[((NI) 1)]);
		LA222: ;
		result = LOC219;
	}
	break;
	case ((NU8) 11):
	{
	}
	break;
	case ((NU8) 0):
	{
		result = NIM_FALSE;
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, comparetypes_228047)(Ttype191849* x, Ttype191849* y, NU8 cmp, NU8 flags) {
	NIM_BOOL result;
	Tsametypeclosure225841 c;
	result = 0;
	memset((void*)(&c), 0, sizeof(c));
	chckNil((void*)(&c));
	memset((void*)(&c), 0, sizeof(c));
	initsametypeclosure_225863((&c));
	c.cmp = cmp;
	c.flags = flags;
	result = sametypeaux_226035(x, y, (&c));
	return result;
}

N_NIMCALL(NIM_BOOL, iterovernode_222087)(Intset188056* marker, Tnode191813* n, Ttypeiter221046 iter, TNimObject* closure) {
	NIM_BOOL result;
{	result = 0;
	{
		if (!!((n == NIM_NIL))) goto LA3;
		switch ((*n).kind) {
		case ((NU8) 0) ... ((NU8) 23):
		{
			result = iterovertypeaux_222077(marker, (*n).typ, iter, closure);
		}
		break;
		default:
		{
			{
				NI i_222119;
				NI HEX3Atmp_222122;
				NI LOC8;
				NI res_222125;
				i_222119 = 0;
				HEX3Atmp_222122 = 0;
				LOC8 = 0;
				LOC8 = sonslen_194403(n);
				HEX3Atmp_222122 = (NI)(LOC8 - ((NI) 1));
				res_222125 = ((NI) 0);
				{
					while (1) {
						if (!(res_222125 <= HEX3Atmp_222122)) goto LA10;
						i_222119 = res_222125;
						result = iterovernode_222087(marker, (*n).kindU.S6.sons->data[i_222119], iter, closure);
						{
							if (!result) goto LA13;
							goto BeforeRet;
						}
						LA13: ;
						res_222125 += ((NI) 1);
					} LA10: ;
				}
			}
		}
		break;
		}
	}
	LA3: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, iterovertypeaux_222077)(Intset188056* marker, Ttype191849* t, Ttypeiter221046 iter, TNimObject* closure) {
	NIM_BOOL result;
{	result = 0;
	result = NIM_FALSE;
	{
		if (!(t == NIM_NIL)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	result = iter(t, closure);
	{
		if (!result) goto LA7;
		goto BeforeRet;
	}
	LA7: ;
	{
		NIM_BOOL LOC11;
		LOC11 = 0;
		LOC11 = containsorincl_188898(marker, (*t).Sup.id);
		if (!!(LOC11)) goto LA12;
		switch ((*t).kind) {
		case ((NU8) 11):
		case ((NU8) 10):
		{
			Ttype191849* LOC15;
			LOC15 = 0;
			LOC15 = lastson_194442(t);
			result = iterovertypeaux_222077(marker, LOC15, iter, closure);
		}
		break;
		default:
		{
			{
				NI i_222176;
				NI HEX3Atmp_222190;
				NI LOC18;
				NI res_222193;
				i_222176 = 0;
				HEX3Atmp_222190 = 0;
				LOC18 = 0;
				LOC18 = sonslen_194351(t);
				HEX3Atmp_222190 = (NI)(LOC18 - ((NI) 1));
				res_222193 = ((NI) 0);
				{
					while (1) {
						if (!(res_222193 <= HEX3Atmp_222190)) goto LA20;
						i_222176 = res_222193;
						result = iterovertypeaux_222077(marker, (*t).sons->data[i_222176], iter, closure);
						{
							if (!result) goto LA23;
							goto BeforeRet;
						}
						LA23: ;
						res_222193 += ((NI) 1);
					} LA20: ;
				}
			}
			{
				if (!!(((*t).n == NIM_NIL))) goto LA27;
				result = iterovernode_222087(marker, (*t).n, iter, closure);
			}
			LA27: ;
		}
		break;
		}
	}
	LA12: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, iterovertype_221062)(Ttype191849* t, Ttypeiter221046 iter, TNimObject* closure) {
	NIM_BOOL result;
	Intset188056 marker;
	result = 0;
	memset((void*)(&marker), 0, sizeof(marker));
	chckNil((void*)(&marker));
	memset((void*)(&marker), 0, sizeof(marker));
	initintset_188927((&marker));
	result = iterovertypeaux_222077((&marker), t, iter, closure);
	return result;
}

N_NIMCALL(NIM_BOOL, containsgenerictypeiter_230225)(Ttype191849* t, TNimObject* closure) {
	NIM_BOOL result;
{	result = 0;
	{
		if (!((*t).kind == ((NU8) 59))) goto LA3;
		result = ((*t).n == NIM_NIL);
		goto BeforeRet;
	}
	LA3: ;
	{
		if (!((*t).kind == ((NU8) 8))) goto LA7;
		{
			Ttype191849* LOC11;
			LOC11 = 0;
			LOC11 = base_221039(t);
			if (!((*LOC11).kind == ((NU8) 0))) goto LA12;
			result = NIM_TRUE;
			goto BeforeRet;
		}
		LA12: ;
		{
			Ttype191849* LOC16;
			NIM_BOOL LOC17;
			LOC16 = 0;
			LOC16 = base_221039(t);
			LOC17 = 0;
			LOC17 = containsgenerictypeiter_230225(LOC16, closure);
			if (!LOC17) goto LA18;
			result = NIM_TRUE;
			goto BeforeRet;
		}
		LA18: ;
		result = NIM_FALSE;
		goto BeforeRet;
	}
	LA7: ;
	{
		if (!((IL64(1727130457096590848) &(IL64(1)<<(((*t).kind)&IL64(63))))!=0)) goto LA22;
		result = NIM_TRUE;
		goto BeforeRet;
	}
	LA22: ;
	result = NIM_FALSE;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, containsgenerictype_230310)(Ttype191849* t) {
	NIM_BOOL result;
	result = 0;
	result = iterovertype_221062(t, containsgenerictypeiter_230225, NIM_NIL);
	return result;
}

N_NIMCALL(NI64, getordvalue_221178)(Tnode191813* n) {
	NI64 result;
	result = 0;
	switch ((*n).kind) {
	case ((NU8) 5) ... ((NU8) 15):
	{
		result = (*n).kindU.S1.intval;
	}
	break;
	case ((NU8) 23):
	{
		result = IL64(0);
	}
	break;
	case ((NU8) 58):
	{
		result = getordvalue_221178((*n).kindU.S6.sons->data[((NI) 1)]);
	}
	break;
	default:
	{
		localerror_166155((*n).info, ((NU16) 74), ((NimStringDesc*) &TMP1968));
		result = IL64(0);
	}
	break;
	}
	return result;
}

N_NIMCALL(NI64, firstord_221004)(Ttype191849* t) {
	NI64 result;
	result = 0;
	switch ((*t).kind) {
	case ((NU8) 1):
	case ((NU8) 2):
	case ((NU8) 24):
	case ((NU8) 27):
	case ((NU8) 28):
	case ((NU8) 48):
	case ((NU8) 50):
	{
		result = IL64(0);
	}
	break;
	case ((NU8) 19):
	case ((NU8) 23):
	{
		result = firstord_221004((*t).sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 16):
	case ((NU8) 4):
	{
		result = firstord_221004((*t).sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 20):
	{
		result = getordvalue_221178((*(*t).n).kindU.S6.sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 31):
	{
		{
			if (!(intsize_160623 == ((NI) 4))) goto LA8;
			result = IL64(-2147483648);
		}
		goto LA6;
		LA8: ;
		{
			result = (IL64(-9223372036854775807) - IL64(1));
		}
		LA6: ;
	}
	break;
	case ((NU8) 32):
	{
		result = IL64(-128);
	}
	break;
	case ((NU8) 33):
	{
		result = IL64(-32768);
	}
	break;
	case ((NU8) 34):
	{
		result = IL64(-2147483648);
	}
	break;
	case ((NU8) 35):
	{
		result = (IL64(-9223372036854775807) - IL64(1));
	}
	break;
	case ((NU8) 40) ... ((NU8) 44):
	{
		result = IL64(0);
	}
	break;
	case ((NU8) 14):
	{
		{
			NIM_BOOL LOC19;
			NI LOC20;
			LOC19 = 0;
			LOC20 = 0;
			LOC20 = sonslen_194351(t);
			LOC19 = (((NI) 0) < LOC20);
			if (!(LOC19)) goto LA21;
			LOC19 = !(((*t).sons->data[((NI) 0)] == NIM_NIL));
			LA21: ;
			if (!LOC19) goto LA22;
			result = firstord_221004((*t).sons->data[((NI) 0)]);
		}
		goto LA17;
		LA22: ;
		{
			result = ((NI64) ((*(*(*(*t).n).kindU.S6.sons->data[((NI) 0)]).kindU.S4.sym).position));
		}
		LA17: ;
	}
	break;
	case ((NU8) 11):
	case ((NU8) 13):
	case ((NU8) 46):
	case ((NU8) 47):
	case ((NU8) 8):
	case ((NU8) 61):
	{
		Ttype191849* LOC26;
		LOC26 = 0;
		LOC26 = lastson_194442(t);
		result = firstord_221004(LOC26);
	}
	break;
	case ((NU8) 15):
	{
		{
			NI LOC30;
			Ttype191849* LOC33;
			LOC30 = 0;
			LOC30 = len_194377(t);
			if (!(((NI) 0) < LOC30)) goto LA31;
			LOC33 = 0;
			LOC33 = lastson_194442(t);
			result = firstord_221004(LOC33);
		}
		goto LA28;
		LA31: ;
		{
			NimStringDesc* LOC35;
			LOC35 = 0;
			LOC35 = rawNewString(reprEnum((*t).kind, (&NTI191260))->Sup.len + 24);
appendString(LOC35, ((NimStringDesc*) &TMP2644));
appendString(LOC35, reprEnum((*t).kind, (&NTI191260)));
appendChar(LOC35, 41);
			internalerror_166218(LOC35);
		}
		LA28: ;
	}
	break;
	default:
	{
		NimStringDesc* LOC37;
		LOC37 = 0;
		LOC37 = rawNewString(reprEnum((*t).kind, (&NTI191260))->Sup.len + 24);
appendString(LOC37, ((NimStringDesc*) &TMP2644));
appendString(LOC37, reprEnum((*t).kind, (&NTI191260)));
appendChar(LOC37, 41);
		internalerror_166218(LOC37);
		result = IL64(0);
	}
	break;
	}
	return result;
}

N_NIMCALL(NI64, lastord_221010)(Ttype191849* t) {
	NI64 result;
	result = 0;
	switch ((*t).kind) {
	case ((NU8) 1):
	{
		result = IL64(1);
	}
	break;
	case ((NU8) 2):
	{
		result = IL64(255);
	}
	break;
	case ((NU8) 19):
	case ((NU8) 23):
	{
		result = lastord_221010((*t).sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 16):
	case ((NU8) 4):
	{
		result = lastord_221010((*t).sons->data[((NI) 0)]);
	}
	break;
	case ((NU8) 20):
	{
		result = getordvalue_221178((*(*t).n).kindU.S6.sons->data[((NI) 1)]);
	}
	break;
	case ((NU8) 31):
	{
		{
			if (!(intsize_160623 == ((NI) 4))) goto LA9;
			result = IL64(2147483647);
		}
		goto LA7;
		LA9: ;
		{
			result = IL64(9223372036854775807);
		}
		LA7: ;
	}
	break;
	case ((NU8) 32):
	{
		result = IL64(127);
	}
	break;
	case ((NU8) 33):
	{
		result = IL64(32767);
	}
	break;
	case ((NU8) 34):
	{
		result = IL64(2147483647);
	}
	break;
	case ((NU8) 35):
	{
		result = IL64(9223372036854775807);
	}
	break;
	case ((NU8) 40):
	{
		{
			if (!(intsize_160623 == ((NI) 4))) goto LA19;
			result = IL64(4294967295);
		}
		goto LA17;
		LA19: ;
		{
			result = IL64(9223372036854775807);
		}
		LA17: ;
	}
	break;
	case ((NU8) 41):
	{
		result = IL64(255);
	}
	break;
	case ((NU8) 42):
	{
		result = IL64(65535);
	}
	break;
	case ((NU8) 43):
	{
		result = IL64(4294967295);
	}
	break;
	case ((NU8) 44):
	{
		result = IL64(9223372036854775807);
	}
	break;
	case ((NU8) 14):
	{
		NI LOC27;
		LOC27 = 0;
		LOC27 = sonslen_194403((*t).n);
		result = ((NI64) ((*(*(*(*t).n).kindU.S6.sons->data[(NI)(LOC27 - ((NI) 1))]).kindU.S4.sym).position));
	}
	break;
	case ((NU8) 11):
	case ((NU8) 13):
	case ((NU8) 46):
	case ((NU8) 47):
	case ((NU8) 8):
	case ((NU8) 61):
	{
		Ttype191849* LOC29;
		LOC29 = 0;
		LOC29 = lastson_194442(t);
		result = lastord_221010(LOC29);
	}
	break;
	case ((NU8) 50):
	{
		result = IL64(0);
	}
	break;
	case ((NU8) 15):
	{
		{
			NI LOC34;
			Ttype191849* LOC37;
			LOC34 = 0;
			LOC34 = len_194377(t);
			if (!(((NI) 0) < LOC34)) goto LA35;
			LOC37 = 0;
			LOC37 = lastson_194442(t);
			result = lastord_221010(LOC37);
		}
		goto LA32;
		LA35: ;
		{
			NimStringDesc* LOC39;
			LOC39 = 0;
			LOC39 = rawNewString(reprEnum((*t).kind, (&NTI191260))->Sup.len + 23);
appendString(LOC39, ((NimStringDesc*) &TMP2645));
appendString(LOC39, reprEnum((*t).kind, (&NTI191260)));
appendChar(LOC39, 41);
			internalerror_166218(LOC39);
		}
		LA32: ;
	}
	break;
	default:
	{
		NimStringDesc* LOC41;
		LOC41 = 0;
		LOC41 = rawNewString(reprEnum((*t).kind, (&NTI191260))->Sup.len + 23);
appendString(LOC41, ((NimStringDesc*) &TMP2645));
appendString(LOC41, reprEnum((*t).kind, (&NTI191260)));
appendChar(LOC41, 41);
		internalerror_166218(LOC41);
		result = IL64(0);
	}
	break;
	}
	return result;
}

N_NIMCALL(NI64, lengthord_221016)(Ttype191849* t) {
	NI64 result;
	result = 0;
	switch ((*t).kind) {
	case ((NU8) 35):
	case ((NU8) 34):
	case ((NU8) 31):
	{
		result = lastord_221010(t);
	}
	break;
	case ((NU8) 13):
	case ((NU8) 46):
	case ((NU8) 47):
	{
		result = lengthord_221016((*t).sons->data[((NI) 0)]);
	}
	break;
	default:
	{
		NI64 LOC4;
		NI64 LOC5;
		LOC4 = 0;
		LOC4 = lastord_221010(t);
		LOC5 = 0;
		LOC5 = firstord_221004(t);
		result = (NI64)((NI64)(LOC4 - LOC5) + IL64(1));
	}
	break;
	}
	return result;
}

N_NIMCALL(NIM_BOOL, isordinaltype_221093)(Ttype191849* t) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	NIM_BOOL LOC3;
	result = 0;
	LOC1 = 0;
	LOC1 = ((IL64(15459734798342) &(IL64(1)<<(((*t).kind)&IL64(63))))!=0);
	if (LOC1) goto LA2;
	LOC3 = 0;
	LOC3 = ((IL64(211106233616384) &(IL64(1)<<(((*t).kind)&IL64(63))))!=0);
	if (!(LOC3)) goto LA4;
	LOC3 = isordinaltype_221093((*t).sons->data[((NI) 0)]);
	LA4: ;
	LOC1 = LOC3;
	LA2: ;
	result = LOC1;
	return result;
}

N_NIMCALL(NIM_BOOL, sametype_226092)(Ttype191849* a, Ttype191849* b, NU8 flags) {
	NIM_BOOL result;
	Tsametypeclosure225841 c;
	result = 0;
	memset((void*)(&c), 0, sizeof(c));
	chckNil((void*)(&c));
	memset((void*)(&c), 0, sizeof(c));
	initsametypeclosure_225863((&c));
	c.flags = flags;
	result = sametypeaux_226035(a, b, (&c));
	return result;
}

N_NIMCALL(NIM_BOOL, sameobjecttypes_226785)(Ttype191849* a, Ttype191849* b) {
	NIM_BOOL result;
	result = 0;
	{
		if (!!(((((*a).flags | (*b).flags) &(1<<((((NU8) 8))&31)))!=0))) goto LA3;
		result = ((*a).Sup.id == (*b).Sup.id);
	}
	goto LA1;
	LA3: ;
	{
		{
			NIM_BOOL LOC8;
			Tsametypeclosure225841 c;
			LOC8 = 0;
			LOC8 = ((((*a).flags & (*b).flags) &(1<<((((NU8) 8))&31)))!=0);
			if (!(LOC8)) goto LA9;
			LOC8 = ((*(*a).sym).Sup.id == (*(*b).sym).Sup.id);
			LA9: ;
			if (!LOC8) goto LA10;
			memset((void*)(&c), 0, sizeof(c));
			chckNil((void*)(&c));
			memset((void*)(&c), 0, sizeof(c));
			initsametypeclosure_225863((&c));
			result = sametypeaux_226035(a, b, (&c));
		}
		LA10: ;
	}
	LA1: ;
	return result;
}

N_NIMCALL(NI, inheritancediff_228064)(Ttype191849* a, Ttype191849* b) {
	NI result;
	Ttype191849* x;
	Ttype191849* y;
{	result = 0;
	{
		NIM_BOOL LOC3;
		NIM_BOOL LOC4;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = (a == b);
		if (LOC4) goto LA5;
		LOC4 = ((*a).kind == ((NU8) 50));
		LA5: ;
		LOC3 = LOC4;
		if (LOC3) goto LA6;
		LOC3 = ((*b).kind == ((NU8) 50));
		LA6: ;
		if (!LOC3) goto LA7;
		result = ((NI) 0);
		goto BeforeRet;
	}
	LA7: ;
	x = a;
	result = ((NI) 0);
	{
		while (1) {
			if (!!((x == NIM_NIL))) goto LA10;
			x = skiptypes_195167(x, IL64(211106247215360));
			{
				NIM_BOOL LOC13;
				LOC13 = 0;
				LOC13 = sameobjecttypes_226785(x, b);
				if (!LOC13) goto LA14;
				goto BeforeRet;
			}
			LA14: ;
			x = (*x).sons->data[((NI) 0)];
			result -= ((NI) 1);
		} LA10: ;
	}
	y = b;
	result = ((NI) 0);
	{
		while (1) {
			if (!!((y == NIM_NIL))) goto LA17;
			y = skiptypes_195167(y, IL64(211106247215360));
			{
				NIM_BOOL LOC20;
				LOC20 = 0;
				LOC20 = sameobjecttypes_226785(y, a);
				if (!LOC20) goto LA21;
				goto BeforeRet;
			}
			LA21: ;
			y = (*y).sons->data[((NI) 0)];
			result += ((NI) 1);
		} LA17: ;
	}
	result = ((NI) IL64(9223372036854775807));
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NI, safeinheritancediff_230388)(Ttype191849* a, Ttype191849* b) {
	NI result;
	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = ((*a).kind == ((NU8) 50));
		if (LOC3) goto LA4;
		LOC3 = ((*b).kind == ((NU8) 50));
		LA4: ;
		if (!LOC3) goto LA5;
		result = ((NI) -1);
	}
	goto LA1;
	LA5: ;
	{
		result = inheritancediff_228064(a, b);
	}
	LA1: ;
	return result;
}

N_NIMCALL(NIM_BOOL, compatibleeffectsaux_230417)(Tnode191813* se, Tnode191813* re) {
	NIM_BOOL result;
{	result = 0;
	{
		if (!re == 0) goto LA3;
		result = NIM_FALSE;
		goto BeforeRet;
	}
	LA3: ;
	{
		Tnode191813* r_230431;
		r_230431 = 0;
		{
			NI i_230449;
			NI HEX3Atmp_230451;
			NI LOC7;
			NI res_230453;
			i_230449 = 0;
			HEX3Atmp_230451 = 0;
			LOC7 = 0;
			LOC7 = len_192097(re);
			HEX3Atmp_230451 = (LOC7 - 1);
			res_230453 = ((NI) 0);
			{
				while (1) {
					if (!(res_230453 <= HEX3Atmp_230451)) goto LA9;
					i_230449 = res_230453;
					r_230431 = (*re).kindU.S6.sons->data[i_230449];
					{
						{
							Tnode191813* s_230433;
							s_230433 = 0;
							{
								NI i_230439;
								NI HEX3Atmp_230441;
								NI LOC13;
								NI res_230443;
								i_230439 = 0;
								HEX3Atmp_230441 = 0;
								LOC13 = 0;
								LOC13 = len_192097(se);
								HEX3Atmp_230441 = (LOC13 - 1);
								res_230443 = ((NI) 0);
								{
									while (1) {
										if (!(res_230443 <= HEX3Atmp_230441)) goto LA15;
										i_230439 = res_230443;
										s_230433 = (*se).kindU.S6.sons->data[i_230439];
										{
											NI LOC18;
											LOC18 = 0;
											LOC18 = safeinheritancediff_230388((*r_230431).typ, (*s_230433).typ);
											if (!(LOC18 <= ((NI) 0))) goto LA19;
											goto LA10;
										}
										LA19: ;
										res_230443 += ((NI) 1);
									} LA15: ;
								}
							}
						}
						result = NIM_FALSE;
						goto BeforeRet;
					} LA10: ;
					res_230453 += ((NI) 1);
				} LA9: ;
			}
		}
	}
	result = NIM_TRUE;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, compatibleeffects_230489)(Ttype191849* formal, Ttype191849* actual) {
	NIM_BOOL result;
	Tnode191813* spec;
	NIM_BOOL LOC46;
{	result = 0;
	{
		NimStringDesc* LOC5;
		if (!!(((*(*(*formal).n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 152)))) goto LA3;
		LOC5 = 0;
		LOC5 = HEX24_166306(TMP2648);
		internalerror_166218(LOC5);
	}
	LA3: ;
	{
		NimStringDesc* LOC10;
		if (!!(((*(*(*actual).n).kindU.S6.sons->data[((NI) 0)]).kind == ((NU8) 152)))) goto LA8;
		LOC10 = 0;
		LOC10 = HEX24_166306(TMP2649);
		internalerror_166218(LOC10);
	}
	LA8: ;
	spec = (*(*formal).n).kindU.S6.sons->data[((NI) 0)];
	{
		NI LOC13;
		Tnode191813* real;
		Tnode191813* se;
		Tnode191813* st;
		LOC13 = 0;
		LOC13 = len_192097(spec);
		if (!!((LOC13 == ((NI) 0)))) goto LA14;
		real = (*(*actual).n).kindU.S6.sons->data[((NI) 0)];
		se = (*spec).kindU.S6.sons->data[((NI) 0)];
		{
			NIM_BOOL LOC18;
			LOC18 = 0;
			LOC18 = !(se == 0);
			if (!(LOC18)) goto LA19;
			LOC18 = !(((*se).kind == ((NU8) 152)));
			LA19: ;
			if (!LOC18) goto LA20;
			{
				NI LOC24;
				LOC24 = 0;
				LOC24 = len_192097(real);
				if (!(LOC24 == ((NI) 0))) goto LA25;
				result = NIM_FALSE;
				goto BeforeRet;
			}
			LA25: ;
			result = compatibleeffectsaux_230417(se, (*real).kindU.S6.sons->data[((NI) 0)]);
			{
				if (!!(result)) goto LA29;
				goto BeforeRet;
			}
			LA29: ;
		}
		LA20: ;
		st = (*spec).kindU.S6.sons->data[((NI) 3)];
		{
			NIM_BOOL LOC33;
			LOC33 = 0;
			LOC33 = !(st == 0);
			if (!(LOC33)) goto LA34;
			LOC33 = !(((*st).kind == ((NU8) 152)));
			LA34: ;
			if (!LOC33) goto LA35;
			{
				NI LOC39;
				LOC39 = 0;
				LOC39 = len_192097(real);
				if (!(LOC39 == ((NI) 0))) goto LA40;
				result = NIM_FALSE;
				goto BeforeRet;
			}
			LA40: ;
			result = compatibleeffectsaux_230417(st, (*real).kindU.S6.sons->data[((NI) 3)]);
			{
				if (!!(result)) goto LA44;
				goto BeforeRet;
			}
			LA44: ;
		}
		LA35: ;
	}
	LA14: ;
	LOC46 = 0;
	LOC46 = (((NI) ((*formal).locklevel)) < ((NI) 0));
	if (LOC46) goto LA47;
	LOC46 = (((NI) ((*actual).locklevel)) <= ((NI) ((*formal).locklevel)));
	LA47: ;
	result = LOC46;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NimStringDesc*, getprocheader_221447)(Tsym191843* sym, NU8 prefer) {
	NimStringDesc* result;
	NimStringDesc* LOC1;
	Tnode191813* n;
	result = 0;
	LOC1 = 0;
	LOC1 = rawNewString((*(*(*sym).owner).name).s->Sup.len + (*(*sym).name).s->Sup.len + 2);
appendString(LOC1, (*(*(*sym).owner).name).s);
appendChar(LOC1, 46);
appendString(LOC1, (*(*sym).name).s);
appendChar(LOC1, 40);
	result = LOC1;
	n = (*(*sym).typ).n;
	{
		NI i_221469;
		NI HEX3Atmp_221500;
		NI LOC3;
		NI res_221503;
		i_221469 = 0;
		HEX3Atmp_221500 = 0;
		LOC3 = 0;
		LOC3 = sonslen_194403(n);
		HEX3Atmp_221500 = (NI)(LOC3 - ((NI) 1));
		res_221503 = ((NI) 1);
		{
			while (1) {
				Tnode191813* p;
				if (!(res_221503 <= HEX3Atmp_221500)) goto LA5;
				i_221469 = res_221503;
				p = (*n).kindU.S6.sons->data[i_221469];
				{
					NimStringDesc* LOC10;
					if (!((*p).kind == ((NU8) 3))) goto LA8;
					result = resizeString(result, (*(*(*p).kindU.S4.sym).name).s->Sup.len + 0);
appendString(result, (*(*(*p).kindU.S4.sym).name).s);
					result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TMP2067));
					LOC10 = 0;
					LOC10 = typetostring_221032((*(*p).kindU.S4.sym).typ, prefer);
					result = resizeString(result, LOC10->Sup.len + 0);
appendString(result, LOC10);
					{
						NI LOC13;
						LOC13 = 0;
						LOC13 = sonslen_194403(n);
						if (!!((i_221469 == (NI)(LOC13 - ((NI) 1))))) goto LA14;
						result = resizeString(result, 2);
appendString(result, ((NimStringDesc*) &TMP2034));
					}
					LA14: ;
				}
				goto LA6;
				LA8: ;
				{
					internalerror_166218(((NimStringDesc*) &TMP2656));
				}
				LA6: ;
				res_221503 += ((NI) 1);
			} LA5: ;
		}
	}
	result = addChar(result, 41);
	{
		NimStringDesc* LOC21;
		NimStringDesc* LOC22;
		if (!!(((*(*n).kindU.S6.sons->data[((NI) 0)]).typ == NIM_NIL))) goto LA19;
		LOC21 = 0;
		LOC22 = 0;
		LOC22 = typetostring_221032((*(*n).kindU.S6.sons->data[((NI) 0)]).typ, prefer);
		LOC21 = rawNewString(LOC22->Sup.len + 2);
appendString(LOC21, ((NimStringDesc*) &TMP2067));
appendString(LOC21, LOC22);
		result = resizeString(result, LOC21->Sup.len + 0);
appendString(result, LOC21);
	}
	LA19: ;
	return result;
}

N_NIMCALL(NIM_BOOL, isemptycontainer_230978)(Ttype191849* t) {
	NIM_BOOL result;
	result = 0;
	switch ((*t).kind) {
	case ((NU8) 6):
	case ((NU8) 5):
	{
		result = NIM_TRUE;
	}
	break;
	case ((NU8) 16):
	case ((NU8) 4):
	{
		result = ((*(*t).sons->data[((NI) 1)]).kind == ((NU8) 3));
	}
	break;
	case ((NU8) 19):
	case ((NU8) 24):
	case ((NU8) 27):
	case ((NU8) 48):
	{
		result = ((*(*t).sons->data[((NI) 0)]).kind == ((NU8) 3));
	}
	break;
	case ((NU8) 11):
	{
		Ttype191849* LOC5;
		LOC5 = 0;
		LOC5 = lastson_194442(t);
		result = isemptycontainer_230978(LOC5);
	}
	break;
	default:
	{
		result = NIM_FALSE;
	}
	break;
	}
	return result;
}

N_NIMCALL(NU8, classify_230913)(Ttype191849* t) {
	NU8 result;
	result = 0;
	{
		if (!(t == NIM_NIL)) goto LA3;
		result = ((NU8) 0);
	}
	goto LA1;
	LA3: ;
	{
		Ttype191849* LOC6;
		LOC6 = 0;
		LOC6 = skiptypes_195167(t, IL64(211106242013440));
		switch ((*LOC6).kind) {
		case ((NU8) 36) ... ((NU8) 39):
		{
			result = ((NU8) 2);
		}
		break;
		case ((NU8) 31) ... ((NU8) 35):
		case ((NU8) 40) ... ((NU8) 44):
		case ((NU8) 1):
		case ((NU8) 2):
		case ((NU8) 14):
		{
			result = ((NU8) 1);
		}
		break;
		default:
		{
			result = ((NU8) 0);
		}
		break;
		}
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, skipconv_230935)(Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = n;
	switch ((*n).kind) {
	case ((NU8) 67):
	case ((NU8) 66):
	case ((NU8) 70):
	case ((NU8) 68):
	case ((NU8) 69):
	{
		{
			NU8 LOC4;
			NU8 LOC5;
			LOC4 = 0;
			LOC4 = classify_230913((*(*n).kindU.S6.sons->data[((NI) 0)]).typ);
			LOC5 = 0;
			LOC5 = classify_230913((*n).typ);
			if (!(LOC4 == LOC5)) goto LA6;
			result = (*n).kindU.S6.sons->data[((NI) 0)];
		}
		LA6: ;
	}
	break;
	case ((NU8) 58):
	case ((NU8) 59):
	case ((NU8) 60):
	{
		{
			NU8 LOC11;
			NU8 LOC12;
			LOC11 = 0;
			LOC11 = classify_230913((*(*n).kindU.S6.sons->data[((NI) 1)]).typ);
			LOC12 = 0;
			LOC12 = classify_230913((*n).typ);
			if (!(LOC11 == LOC12)) goto LA13;
			result = (*n).kindU.S6.sons->data[((NI) 1)];
		}
		LA13: ;
	}
	break;
	default:
	{
	}
	break;
	}
	return result;
}

N_NIMCALL(NI64, align_229669)(NI64 address, NI64 alignment) {
	NI64 result;
	result = 0;
	result = (NI64)((NI64)(address + (NI64)(alignment - IL64(1))) & (NI64)((NU64) ~((NI64)(alignment - IL64(1)))));
	return result;
}

N_NIMCALL(NIM_BOOL, isobjectwithtypefieldpredicate_222556)(Ttype191849* t) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	NIM_BOOL LOC2;
	NIM_BOOL LOC3;
	NIM_BOOL LOC6;
	result = 0;
	LOC1 = 0;
	LOC2 = 0;
	LOC3 = 0;
	LOC3 = ((*t).kind == ((NU8) 17));
	if (!(LOC3)) goto LA4;
	LOC3 = ((*t).sons->data[((NI) 0)] == NIM_NIL);
	LA4: ;
	LOC2 = LOC3;
	if (!(LOC2)) goto LA5;
	LOC6 = 0;
	LOC6 = !(((*t).sym == NIM_NIL));
	if (!(LOC6)) goto LA7;
	LOC6 = !(((134218240 & (*(*t).sym).flags) == 0));
	LA7: ;
	LOC2 = !(LOC6);
	LA5: ;
	LOC1 = LOC2;
	if (!(LOC1)) goto LA8;
	LOC1 = !((((*t).flags &(1<<((((NU8) 2))&31)))!=0));
	LA8: ;
	result = LOC1;
	return result;
}

N_NIMCALL(NI64, computerecsizeaux_229694)(Tnode191813* n, NI64* a, NI64* curroffset) {
	NI64 result;
	NI64 maxalign;
	NI64 maxsize;
	NI64 b;
	NI64 res;
{	result = 0;
	maxalign = 0;
	maxsize = 0;
	b = 0;
	res = 0;
	switch ((*n).kind) {
	case ((NU8) 139):
	{
		NI64 LOC13;
		NI64 LOC14;
		result = computerecsizeaux_229694((*n).kindU.S6.sons->data[((NI) 0)], a, curroffset);
		maxsize = IL64(0);
		maxalign = IL64(1);
		{
			NI i_229814;
			NI HEX3Atmp_229850;
			NI LOC3;
			NI res_229853;
			i_229814 = 0;
			HEX3Atmp_229850 = 0;
			LOC3 = 0;
			LOC3 = sonslen_194403(n);
			HEX3Atmp_229850 = (NI)(LOC3 - ((NI) 1));
			res_229853 = ((NI) 1);
			{
				while (1) {
					if (!(res_229853 <= HEX3Atmp_229850)) goto LA5;
					i_229814 = res_229853;
					switch ((*(*n).kindU.S6.sons->data[i_229814]).kind) {
					case ((NU8) 85):
					case ((NU8) 88):
					{
						Tnode191813* LOC7;
						LOC7 = 0;
						LOC7 = lastson_194431((*n).kindU.S6.sons->data[i_229814]);
						res = computerecsizeaux_229694(LOC7, (&b), curroffset);
						{
							if (!(res < IL64(0))) goto LA10;
							result = res;
							goto BeforeRet;
						}
						LA10: ;
						maxsize = ((maxsize >= res) ? maxsize : res);
						maxalign = ((maxalign >= b) ? maxalign : b);
					}
					break;
					default:
					{
						internalerror_166218(((NimStringDesc*) &TMP2813));
					}
					break;
					}
					res_229853 += ((NI) 1);
				} LA5: ;
			}
		}
		LOC13 = 0;
		LOC13 = align_229669((*curroffset), maxalign);
		(*curroffset) = (NI64)(LOC13 + maxsize);
		LOC14 = 0;
		LOC14 = align_229669(result, maxalign);
		result = (NI64)(LOC14 + maxsize);
		(*a) = maxalign;
	}
	break;
	case ((NU8) 138):
	{
		result = IL64(0);
		maxalign = IL64(1);
		{
			NI i_229838;
			NI HEX3Atmp_229858;
			NI LOC17;
			NI res_229861;
			i_229838 = 0;
			HEX3Atmp_229858 = 0;
			LOC17 = 0;
			LOC17 = sonslen_194403(n);
			HEX3Atmp_229858 = (NI)(LOC17 - ((NI) 1));
			res_229861 = ((NI) 0);
			{
				while (1) {
					NI64 LOC24;
					NI64 LOC25;
					if (!(res_229861 <= HEX3Atmp_229858)) goto LA19;
					i_229838 = res_229861;
					res = computerecsizeaux_229694((*n).kindU.S6.sons->data[i_229838], (&b), curroffset);
					{
						if (!(res < IL64(0))) goto LA22;
						result = res;
						goto BeforeRet;
					}
					LA22: ;
					LOC24 = 0;
					LOC24 = align_229669((*curroffset), b);
					(*curroffset) = (NI64)(LOC24 + res);
					LOC25 = 0;
					LOC25 = align_229669(result, b);
					result = (NI64)(LOC25 + res);
					{
						if (!(maxalign < b)) goto LA28;
						maxalign = b;
					}
					LA28: ;
					res_229861 += ((NI) 1);
				} LA19: ;
			}
		}
		(*a) = maxalign;
	}
	break;
	case ((NU8) 3):
	{
		result = computesizeaux_229686((*(*n).kindU.S4.sym).typ, a);
		(*(*n).kindU.S4.sym).offset = ((NI) ((*curroffset)));
	}
	break;
	default:
	{
		(*a) = IL64(1);
		result = IL64(-3);
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NI64, computesizeaux_229686)(Ttype191849* typ, NI64* a) {
	NI64 result;
	NI64 res;
	NI64 maxalign;
	NI64 length;
	NI64 curroffset;
{	result = 0;
	res = 0;
	maxalign = 0;
	length = 0;
	curroffset = 0;
	{
		if (!((*typ).size == IL64(-2))) goto LA3;
		result = IL64(-2);
		goto BeforeRet;
	}
	LA3: ;
	{
		if (!(IL64(0) <= (*typ).size)) goto LA7;
		result = (*typ).size;
		(*a) = ((NI64) ((*typ).align));
		goto BeforeRet;
	}
	LA7: ;
	(*typ).size = IL64(-2);
	switch ((*typ).kind) {
	case ((NU8) 31):
	case ((NU8) 40):
	{
		result = ((NI64) (intsize_160623));
		(*a) = result;
	}
	break;
	case ((NU8) 32):
	case ((NU8) 41):
	case ((NU8) 1):
	case ((NU8) 2):
	{
		result = IL64(1);
		(*a) = result;
	}
	break;
	case ((NU8) 33):
	case ((NU8) 42):
	{
		result = IL64(2);
		(*a) = result;
	}
	break;
	case ((NU8) 34):
	case ((NU8) 43):
	case ((NU8) 37):
	{
		result = IL64(4);
		(*a) = result;
	}
	break;
	case ((NU8) 35):
	case ((NU8) 44):
	case ((NU8) 38):
	{
		result = IL64(8);
		(*a) = result;
	}
	break;
	case ((NU8) 39):
	{
		result = IL64(16);
		(*a) = result;
	}
	break;
	case ((NU8) 36):
	{
		result = ((NI64) (floatsize_160624));
		(*a) = result;
	}
	break;
	case ((NU8) 25):
	{
		{
			if (!((*typ).callconv == ((NU8) 8))) goto LA19;
			result = ((NI64) ((NI)(((NI) 2) * ptrsize_160625)));
		}
		goto LA17;
		LA19: ;
		{
			result = ((NI64) (ptrsize_160625));
		}
		LA17: ;
		(*a) = ((NI64) (ptrsize_160625));
	}
	break;
	case ((NU8) 5):
	case ((NU8) 29):
	case ((NU8) 28):
	case ((NU8) 24):
	case ((NU8) 21):
	case ((NU8) 22):
	case ((NU8) 23):
	case ((NU8) 27):
	case ((NU8) 45):
	{
		Ttype191849* base;
		base = lastson_194442(typ);
		{
			NIM_BOOL LOC25;
			NIM_BOOL LOC27;
			LOC25 = 0;
			LOC25 = (base == typ);
			if (LOC25) goto LA26;
			LOC27 = 0;
			LOC27 = ((*base).kind == ((NU8) 18));
			if (!(LOC27)) goto LA28;
			LOC27 = ((*base).size == IL64(-2));
			LA28: ;
			LOC25 = LOC27;
			LA26: ;
			if (!LOC25) goto LA29;
			result = IL64(-2);
		}
		goto LA23;
		LA29: ;
		{
			result = ((NI64) (ptrsize_160625));
		}
		LA23: ;
		(*a) = result;
	}
	break;
	case ((NU8) 16):
	case ((NU8) 4):
	{
		NI64 elemsize;
		NI64 LOC37;
		elemsize = computesizeaux_229686((*typ).sons->data[((NI) 1)], a);
		{
			if (!(elemsize < IL64(0))) goto LA35;
			result = elemsize;
			goto BeforeRet;
		}
		LA35: ;
		LOC37 = 0;
		LOC37 = lengthord_221016((*typ).sons->data[((NI) 0)]);
		result = (NI64)(LOC37 * elemsize);
	}
	break;
	case ((NU8) 14):
	{
		{
			NI64 LOC41;
			LOC41 = 0;
			LOC41 = firstord_221004(typ);
			if (!(LOC41 < IL64(0))) goto LA42;
			result = IL64(4);
		}
		goto LA39;
		LA42: ;
		{
			length = lastord_221010(typ);
			{
				if (!((NI64)(length + IL64(1)) < IL64(256))) goto LA47;
				result = IL64(1);
			}
			goto LA45;
			LA47: ;
			{
				if (!((NI64)(length + IL64(1)) < IL64(65536))) goto LA50;
				result = IL64(2);
			}
			goto LA45;
			LA50: ;
			{
				if (!((NI64)(length + IL64(1)) < IL64(4294967296))) goto LA53;
				result = IL64(4);
			}
			goto LA45;
			LA53: ;
			{
				result = IL64(8);
			}
			LA45: ;
		}
		LA39: ;
		(*a) = result;
	}
	break;
	case ((NU8) 19):
	{
		length = lengthord_221016((*typ).sons->data[((NI) 0)]);
		{
			if (!(length <= IL64(8))) goto LA59;
			result = IL64(1);
		}
		goto LA57;
		LA59: ;
		{
			if (!(length <= IL64(16))) goto LA62;
			result = IL64(2);
		}
		goto LA57;
		LA62: ;
		{
			if (!(length <= IL64(32))) goto LA65;
			result = IL64(4);
		}
		goto LA57;
		LA65: ;
		{
			if (!(length <= IL64(64))) goto LA68;
			result = IL64(8);
		}
		goto LA57;
		LA68: ;
		{
			NI64 LOC71;
			NI64 LOC74;
			LOC71 = 0;
			LOC71 = align_229669(length, IL64(8));
			if (!(((NI) ((NI64)(LOC71 % IL64(8)))) == ((NI) 0))) goto LA72;
			LOC74 = 0;
			LOC74 = align_229669(length, IL64(8));
			result = (NI64)(LOC74 / IL64(8));
		}
		goto LA57;
		LA72: ;
		{
			NI64 LOC76;
			LOC76 = 0;
			LOC76 = align_229669(length, IL64(8));
			result = (NI64)((NI64)(LOC76 / IL64(8)) + IL64(1));
		}
		LA57: ;
		(*a) = result;
	}
	break;
	case ((NU8) 20):
	{
		result = computesizeaux_229686((*typ).sons->data[((NI) 0)], a);
	}
	break;
	case ((NU8) 18):
	{
		result = IL64(0);
		maxalign = IL64(1);
		{
			NI i_229946;
			NI HEX3Atmp_229969;
			NI LOC80;
			NI res_229972;
			i_229946 = 0;
			HEX3Atmp_229969 = 0;
			LOC80 = 0;
			LOC80 = sonslen_194351(typ);
			HEX3Atmp_229969 = (NI)(LOC80 - ((NI) 1));
			res_229972 = ((NI) 0);
			{
				while (1) {
					NI64 LOC87;
					if (!(res_229972 <= HEX3Atmp_229969)) goto LA82;
					i_229946 = res_229972;
					res = computesizeaux_229686((*typ).sons->data[i_229946], a);
					{
						if (!(res < IL64(0))) goto LA85;
						result = res;
						goto BeforeRet;
					}
					LA85: ;
					maxalign = ((maxalign >= (*a)) ? maxalign : (*a));
					LOC87 = 0;
					LOC87 = align_229669(result, (*a));
					result = (NI64)(LOC87 + res);
					res_229972 += ((NI) 1);
				} LA82: ;
			}
		}
		result = align_229669(result, maxalign);
		(*a) = maxalign;
	}
	break;
	case ((NU8) 17):
	{
		{
			if (!!(((*typ).sons->data[((NI) 0)] == NIM_NIL))) goto LA91;
			result = computesizeaux_229686((*typ).sons->data[((NI) 0)], a);
			{
				if (!(result < IL64(0))) goto LA95;
				goto BeforeRet;
			}
			LA95: ;
			maxalign = (*a);
		}
		goto LA89;
		LA91: ;
		{
			NIM_BOOL LOC98;
			LOC98 = 0;
			LOC98 = isobjectwithtypefieldpredicate_222556(typ);
			if (!LOC98) goto LA99;
			result = ((NI64) (intsize_160623));
			maxalign = result;
		}
		goto LA89;
		LA99: ;
		{
			result = IL64(0);
			maxalign = IL64(1);
		}
		LA89: ;
		curroffset = result;
		result = computerecsizeaux_229694((*typ).n, a, (&curroffset));
		{
			if (!(result < IL64(0))) goto LA104;
			goto BeforeRet;
		}
		LA104: ;
		{
			if (!((*a) < maxalign)) goto LA108;
			(*a) = maxalign;
		}
		LA108: ;
		result = align_229669(result, (*a));
	}
	break;
	case ((NU8) 11):
	case ((NU8) 13):
	case ((NU8) 10):
	case ((NU8) 47):
	case ((NU8) 46):
	case ((NU8) 49):
	{
		Ttype191849* LOC111;
		LOC111 = 0;
		LOC111 = lastson_194442(typ);
		result = computesizeaux_229686(LOC111, a);
	}
	break;
	case ((NU8) 8):
	{
		Ttype191849* LOC113;
		LOC113 = 0;
		LOC113 = base_221039(typ);
		result = computesizeaux_229686(LOC113, a);
	}
	break;
	case ((NU8) 30):
	{
		result = IL64(-2);
		goto BeforeRet;
	}
	break;
	default:
	{
		result = IL64(-1);
	}
	break;
	}
	(*typ).size = result;
	(*typ).align = ((NI16) ((*a)));
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NI64, computesize_221184)(Ttype191849* typ) {
	NI64 result;
	NI64 a;
	result = 0;
	a = IL64(1);
	result = computesizeaux_229686(typ, (&a));
	return result;
}

N_NIMCALL(NI64, getsize_221190)(Ttype191849* typ) {
	NI64 result;
	result = 0;
	result = computesize_221184(typ);
	{
		NimStringDesc* LOC5;
		if (!(result < IL64(0))) goto LA3;
		LOC5 = 0;
		LOC5 = rawNewString(reprEnum((*typ).kind, (&NTI191260))->Sup.len + 9);
appendString(LOC5, ((NimStringDesc*) &TMP2814));
appendString(LOC5, reprEnum((*typ).kind, (&NTI191260)));
		internalerror_166218(LOC5);
	}
	LA3: ;
	return result;
}

N_NIMCALL(NIM_BOOL, enumhasholes_221099)(Ttype191849* t) {
	NIM_BOOL result;
	Ttype191849* b;
	NIM_BOOL LOC3;
	result = 0;
	b = t;
	{
		while (1) {
			if (!((IL64(211106233583616) &(IL64(1)<<(((*b).kind)&IL64(63))))!=0)) goto LA2;
			b = (*b).sons->data[((NI) 0)];
		} LA2: ;
	}
	LOC3 = 0;
	LOC3 = ((*b).kind == ((NU8) 14));
	if (!(LOC3)) goto LA4;
	LOC3 = (((*b).flags &(1<<((((NU8) 5))&31)))!=0);
	LA4: ;
	result = LOC3;
	return result;
}

N_NIMCALL(NIM_BOOL, sametypeornil_226108)(Ttype191849* a, Ttype191849* b, NU8 flags) {
	NIM_BOOL result;
	result = 0;
	{
		if (!(a == b)) goto LA3;
		result = NIM_TRUE;
	}
	goto LA1;
	LA3: ;
	{
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = (a == NIM_NIL);
			if (LOC8) goto LA9;
			LOC8 = (b == NIM_NIL);
			LA9: ;
			if (!LOC8) goto LA10;
			result = NIM_FALSE;
		}
		goto LA6;
		LA10: ;
		{
			result = sametype_226092(a, b, flags);
		}
		LA6: ;
	}
	LA1: ;
	return result;
}

N_NIMCALL(NU8, equalparam_226157)(Tsym191843* a, Tsym191843* b) {
	NU8 result;
	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = sametypeornil_226108((*a).typ, (*b).typ, 4);
		if (!(LOC3)) goto LA4;
		LOC3 = exprstructuralequivalent_220149((*a).constraint, (*b).constraint);
		LA4: ;
		if (!LOC3) goto LA5;
		{
			if (!((*a).ast == (*b).ast)) goto LA9;
			result = ((NU8) 1);
		}
		goto LA7;
		LA9: ;
		{
			NIM_BOOL LOC12;
			LOC12 = 0;
			LOC12 = !(((*a).ast == NIM_NIL));
			if (!(LOC12)) goto LA13;
			LOC12 = !(((*b).ast == NIM_NIL));
			LA13: ;
			if (!LOC12) goto LA14;
			{
				NIM_BOOL LOC18;
				LOC18 = 0;
				LOC18 = exprstructuralequivalent_220149((*a).ast, (*b).ast);
				if (!LOC18) goto LA19;
				result = ((NU8) 1);
			}
			goto LA16;
			LA19: ;
			{
				result = ((NU8) 2);
			}
			LA16: ;
		}
		goto LA7;
		LA14: ;
		{
			if (!!(((*a).ast == NIM_NIL))) goto LA23;
			result = ((NU8) 1);
		}
		goto LA7;
		LA23: ;
		{
			if (!!(((*b).ast == NIM_NIL))) goto LA26;
			result = ((NU8) 2);
		}
		goto LA7;
		LA26: ;
		LA7: ;
	}
	goto LA1;
	LA5: ;
	{
		result = ((NU8) 0);
	}
	LA1: ;
	return result;
}

N_NIMCALL(NU8, equalparams_221086)(Tnode191813* a, Tnode191813* b) {
	NU8 result;
	NI length;
{	result = 0;
	result = ((NU8) 1);
	length = sonslen_194403(a);
	{
		NI LOC3;
		LOC3 = 0;
		LOC3 = sonslen_194403(b);
		if (!!((length == LOC3))) goto LA4;
		result = ((NU8) 0);
	}
	goto LA1;
	LA4: ;
	{
		{
			NI i_226319;
			NI HEX3Atmp_226433;
			NI res_226436;
			i_226319 = 0;
			HEX3Atmp_226433 = 0;
			HEX3Atmp_226433 = (NI)(length - ((NI) 1));
			res_226436 = ((NI) 1);
			{
				while (1) {
					Tsym191843* m;
					Tsym191843* n;
					NU8 LOC10;
					if (!(res_226436 <= HEX3Atmp_226433)) goto LA9;
					i_226319 = res_226436;
					m = (*(*a).kindU.S6.sons->data[i_226319]).kindU.S4.sym;
					n = (*(*b).kindU.S6.sons->data[i_226319]).kindU.S4.sym;
					LOC10 = 0;
					LOC10 = equalparam_226157(m, n);
					switch (LOC10) {
					case ((NU8) 0):
					{
						result = ((NU8) 0);
						goto BeforeRet;
					}
					break;
					case ((NU8) 1):
					{
					}
					break;
					case ((NU8) 2):
					{
						result = ((NU8) 2);
					}
					break;
					}
					{
						if (!!(((*(*m).name).Sup.id == (*(*n).name).Sup.id))) goto LA16;
						result = ((NU8) 0);
						goto BeforeRet;
					}
					LA16: ;
					res_226436 += ((NI) 1);
				} LA9: ;
			}
		}
		{
			NIM_BOOL LOC20;
			LOC20 = 0;
			LOC20 = sametypeornil_226108((*(*a).kindU.S6.sons->data[((NI) 0)]).typ, (*(*b).kindU.S6.sons->data[((NI) 0)]).typ, 4);
			if (!!(LOC20)) goto LA21;
			{
				NIM_BOOL LOC25;
				LOC25 = 0;
				LOC25 = ((*(*a).kindU.S6.sons->data[((NI) 0)]).typ == NIM_NIL);
				if (LOC25) goto LA26;
				LOC25 = ((*(*b).kindU.S6.sons->data[((NI) 0)]).typ == NIM_NIL);
				LA26: ;
				if (!LOC25) goto LA27;
				result = ((NU8) 0);
			}
			goto LA23;
			LA27: ;
			{
				result = ((NU8) 2);
			}
			LA23: ;
		}
		LA21: ;
	}
	LA1: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, typeallowednode_228870)(Intset188056* marker, Tnode191813* n, NU8 kind, NU8 flags) {
	Ttype191849* result;
{	result = 0;
	{
		if (!!((n == NIM_NIL))) goto LA3;
		result = typeallowedaux_228858(marker, (*n).typ, kind, flags);
		{
			if (!(result == NIM_NIL)) goto LA7;
			switch ((*n).kind) {
			case ((NU8) 0) ... ((NU8) 23):
			{
			}
			break;
			default:
			{
				{
					NI i_228916;
					NI HEX3Atmp_228950;
					NI LOC12;
					NI res_228953;
					i_228916 = 0;
					HEX3Atmp_228950 = 0;
					LOC12 = 0;
					LOC12 = sonslen_194403(n);
					HEX3Atmp_228950 = (NI)(LOC12 - ((NI) 1));
					res_228953 = ((NI) 0);
					{
						while (1) {
							Tnode191813* it;
							if (!(res_228953 <= HEX3Atmp_228950)) goto LA14;
							i_228916 = res_228953;
							it = (*n).kindU.S6.sons->data[i_228916];
							{
								NIM_BOOL LOC17;
								LOC17 = 0;
								LOC17 = ((*it).kind == ((NU8) 139));
								if (!(LOC17)) goto LA18;
								LOC17 = (kind == ((NU8) 10));
								LA18: ;
								if (!LOC17) goto LA19;
								result = (*n).typ;
								goto BeforeRet;
							}
							LA19: ;
							result = typeallowednode_228870(marker, it, kind, flags);
							{
								if (!!((result == NIM_NIL))) goto LA23;
								goto LA11;
							}
							LA23: ;
							res_228953 += ((NI) 1);
						} LA14: ;
					}
				} LA11: ;
			}
			break;
			}
		}
		LA7: ;
	}
	LA3: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, typeallowedaux_228858)(Intset188056* marker, Ttype191849* typ, NU8 kind, NU8 flags_228866) {
	Ttype191849* result;
	Ttype191849* t;
{	result = 0;
	result = NIM_NIL;
	{
		if (!(typ == NIM_NIL)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	{
		NIM_BOOL LOC7;
		LOC7 = 0;
		LOC7 = containsorincl_188898(marker, (*typ).Sup.id);
		if (!LOC7) goto LA8;
		goto BeforeRet;
	}
	LA8: ;
	t = skiptypes_195167(typ, IL64(211106232576000));
	switch ((*t).kind) {
	case ((NU8) 23):
	{
		Ttype191849* t2;
		{
			if (!(kind == ((NU8) 10))) goto LA13;
			result = t;
			goto BeforeRet;
		}
		LA13: ;
		t2 = skiptypes_195167((*t).sons->data[((NI) 0)], IL64(211106232576000));
		switch ((*t2).kind) {
		case ((NU8) 23):
		{
			{
				if (!!(((flags_228866 &(1<<((((NU8) 1))&7)))!=0))) goto LA18;
				result = t2;
			}
			LA18: ;
		}
		break;
		case ((NU8) 27):
		{
			{
				if (!!((kind == ((NU8) 3)))) goto LA23;
				result = t;
			}
			goto LA21;
			LA23: ;
			{
				result = typeallowedaux_228858(marker, t2, kind, flags_228866);
			}
			LA21: ;
		}
		break;
		default:
		{
			{
				if (!!(((2056 &(1<<((kind)&31)))!=0))) goto LA29;
				result = t;
			}
			goto LA27;
			LA29: ;
			{
				result = typeallowedaux_228858(marker, t2, kind, flags_228866);
			}
			LA27: ;
		}
		break;
		}
	}
	break;
	case ((NU8) 25):
	{
		{
			NI i_229292;
			NI HEX3Atmp_229598;
			NI LOC34;
			NI res_229601;
			i_229292 = 0;
			HEX3Atmp_229598 = 0;
			LOC34 = 0;
			LOC34 = sonslen_194351(t);
			HEX3Atmp_229598 = (NI)(LOC34 - ((NI) 1));
			res_229601 = ((NI) 1);
			{
				while (1) {
					if (!(res_229601 <= HEX3Atmp_229598)) goto LA36;
					i_229292 = res_229601;
					result = typeallowedaux_228858(marker, (*t).sons->data[i_229292], ((NU8) 3), flags_228866);
					{
						if (!!((result == NIM_NIL))) goto LA39;
						goto LA33;
					}
					LA39: ;
					res_229601 += ((NI) 1);
				} LA36: ;
			}
		} LA33: ;
		{
			NIM_BOOL LOC43;
			LOC43 = 0;
			LOC43 = result == 0;
			if (!(LOC43)) goto LA44;
			LOC43 = !(((*t).sons->data[((NI) 0)] == NIM_NIL));
			LA44: ;
			if (!LOC43) goto LA45;
			result = typeallowedaux_228858(marker, (*t).sons->data[((NI) 0)], ((NU8) 11), flags_228866);
		}
		LA45: ;
	}
	break;
	case ((NU8) 8):
	{
		result = NIM_NIL;
	}
	break;
	case ((NU8) 6):
	case ((NU8) 7):
	case ((NU8) 59):
	{
		{
			if (!!(((2056 &(1<<((kind)&31)))!=0))) goto LA51;
			result = t;
		}
		LA51: ;
	}
	break;
	case ((NU8) 3):
	{
		{
			if (!!(((flags_228866 &(1<<((((NU8) 0))&7)))!=0))) goto LA56;
			result = t;
		}
		LA56: ;
	}
	break;
	case ((NU8) 51):
	case ((NU8) 54):
	case ((NU8) 52):
	case ((NU8) 53):
	case ((NU8) 55):
	case ((NU8) 56):
	case ((NU8) 57):
	case ((NU8) 58):
	{
		{
			NIM_BOOL LOC61;
			LOC61 = 0;
			LOC61 = (((*t).flags &(1<<((((NU8) 23))&31)))!=0);
			if (LOC61) goto LA62;
			LOC61 = !(((flags_228866 &(1<<((((NU8) 0))&7)))!=0));
			LA62: ;
			if (!!(LOC61)) goto LA63;
			result = t;
		}
		LA63: ;
	}
	break;
	case ((NU8) 10):
	case ((NU8) 12):
	case ((NU8) 9):
	case ((NU8) 0):
	case ((NU8) 30):
	case ((NU8) 60):
	case ((NU8) 61):
	{
		result = t;
	}
	break;
	case ((NU8) 5):
	{
		{
			if (!!((kind == ((NU8) 10)))) goto LA69;
			result = t;
		}
		LA69: ;
	}
	break;
	case ((NU8) 28):
	case ((NU8) 1):
	case ((NU8) 2):
	case ((NU8) 14):
	case ((NU8) 31) ... ((NU8) 45):
	case ((NU8) 29):
	case ((NU8) 26):
	{
		result = NIM_NIL;
	}
	break;
	case ((NU8) 15):
	{
		{
			if (!!((kind == ((NU8) 3)))) goto LA75;
			result = t;
		}
		LA75: ;
	}
	break;
	case ((NU8) 11):
	case ((NU8) 13):
	{
		Ttype191849* LOC78;
		LOC78 = 0;
		LOC78 = lastson_194442(t);
		result = typeallowedaux_228858(marker, LOC78, kind, flags_228866);
	}
	break;
	case ((NU8) 20):
	{
		{
			Ttype191849* LOC82;
			LOC82 = 0;
			LOC82 = skiptypes_195167((*t).sons->data[((NI) 0)], IL64(211106232576000));
			if (!!(((IL64(16490526949380) &(IL64(1)<<(((*LOC82).kind)&IL64(63))))!=0))) goto LA83;
			result = t;
		}
		LA83: ;
	}
	break;
	case ((NU8) 27):
	case ((NU8) 48):
	{
		{
			if (!!((kind == ((NU8) 3)))) goto LA88;
			result = t;
		}
		goto LA86;
		LA88: ;
		{
			result = typeallowedaux_228858(marker, (*t).sons->data[((NI) 0)], ((NU8) 8), flags_228866);
		}
		LA86: ;
	}
	break;
	case ((NU8) 24):
	{
		{
			if (!!(((*(*t).sons->data[((NI) 0)]).kind == ((NU8) 3)))) goto LA94;
			result = typeallowedaux_228858(marker, (*t).sons->data[((NI) 0)], ((NU8) 8), (flags_228866 | 2));
		}
		LA94: ;
	}
	break;
	case ((NU8) 16):
	{
		{
			if (!!(((*(*t).sons->data[((NI) 1)]).kind == ((NU8) 3)))) goto LA99;
			result = typeallowedaux_228858(marker, (*t).sons->data[((NI) 1)], ((NU8) 8), flags_228866);
		}
		LA99: ;
	}
	break;
	case ((NU8) 22):
	{
		{
			if (!(kind == ((NU8) 10))) goto LA104;
			result = t;
		}
		goto LA102;
		LA104: ;
		{
			Ttype191849* LOC107;
			LOC107 = 0;
			LOC107 = lastson_194442(t);
			result = typeallowedaux_228858(marker, LOC107, ((NU8) 8), (flags_228866 | 2));
		}
		LA102: ;
	}
	break;
	case ((NU8) 21):
	{
		Ttype191849* LOC109;
		LOC109 = 0;
		LOC109 = lastson_194442(t);
		result = typeallowedaux_228858(marker, LOC109, ((NU8) 8), (flags_228866 | 2));
	}
	break;
	case ((NU8) 4):
	case ((NU8) 19):
	case ((NU8) 46):
	case ((NU8) 47):
	case ((NU8) 49):
	{
		{
			NI i_229495;
			NI HEX3Atmp_229606;
			NI LOC112;
			NI res_229609;
			i_229495 = 0;
			HEX3Atmp_229606 = 0;
			LOC112 = 0;
			LOC112 = sonslen_194351(t);
			HEX3Atmp_229606 = (NI)(LOC112 - ((NI) 1));
			res_229609 = ((NI) 0);
			{
				while (1) {
					if (!(res_229609 <= HEX3Atmp_229606)) goto LA114;
					i_229495 = res_229609;
					result = typeallowedaux_228858(marker, (*t).sons->data[i_229495], kind, flags_228866);
					{
						if (!!((result == NIM_NIL))) goto LA117;
						goto LA111;
					}
					LA117: ;
					res_229609 += ((NI) 1);
				} LA114: ;
			}
		} LA111: ;
	}
	break;
	case ((NU8) 17):
	case ((NU8) 18):
	{
		NU8 flags;
		{
			NIM_BOOL LOC122;
			NIM_BOOL LOC123;
			LOC122 = 0;
			LOC123 = 0;
			LOC123 = (kind == ((NU8) 10));
			if (!(LOC123)) goto LA124;
			LOC123 = ((*t).kind == ((NU8) 17));
			LA124: ;
			LOC122 = LOC123;
			if (!(LOC122)) goto LA125;
			LOC122 = !(((*t).sons->data[((NI) 0)] == NIM_NIL));
			LA125: ;
			if (!LOC122) goto LA126;
			result = t;
			goto BeforeRet;
		}
		LA126: ;
		flags = (flags_228866 | 1);
		{
			NI i_229564;
			NI HEX3Atmp_229614;
			NI LOC129;
			NI res_229617;
			i_229564 = 0;
			HEX3Atmp_229614 = 0;
			LOC129 = 0;
			LOC129 = sonslen_194351(t);
			HEX3Atmp_229614 = (NI)(LOC129 - ((NI) 1));
			res_229617 = ((NI) 0);
			{
				while (1) {
					if (!(res_229617 <= HEX3Atmp_229614)) goto LA131;
					i_229564 = res_229617;
					result = typeallowedaux_228858(marker, (*t).sons->data[i_229564], kind, flags);
					{
						if (!!((result == NIM_NIL))) goto LA134;
						goto LA128;
					}
					LA134: ;
					res_229617 += ((NI) 1);
				} LA131: ;
			}
		} LA128: ;
		{
			NIM_BOOL LOC138;
			LOC138 = 0;
			LOC138 = result == 0;
			if (!(LOC138)) goto LA139;
			LOC138 = !(((*t).n == NIM_NIL));
			LA139: ;
			if (!LOC138) goto LA140;
			result = typeallowednode_228870(marker, (*t).n, kind, flags);
		}
		LA140: ;
	}
	break;
	case ((NU8) 50):
	{
		result = NIM_NIL;
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Ttype191849*, typeallowed_229654)(Ttype191849* t, NU8 kind) {
	Ttype191849* result;
	Intset188056 marker;
	result = 0;
	memset((void*)(&marker), 0, sizeof(marker));
	chckNil((void*)(&marker));
	memset((void*)(&marker), 0, sizeof(marker));
	initintset_188927((&marker));
	result = typeallowedaux_228858((&marker), t, kind, 0);
	return result;
}

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

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

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

N_NIMCALL(Ttype191849*, taketype_231006)(Ttype191849* formal, Ttype191849* arg) {
	Ttype191849* result;
	result = 0;
	{
		if (!((*arg).kind == ((NU8) 5))) goto LA3;
		result = formal;
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC6;
		Ttype191849* a;
		Ttype191849* LOC10;
		LOC6 = 0;
		LOC6 = ((IL64(281475127705600) &(IL64(1)<<(((*formal).kind)&IL64(63))))!=0);
		if (!(LOC6)) goto LA7;
		LOC6 = isemptycontainer_230978(arg);
		LA7: ;
		if (!LOC6) goto LA8;
		LOC10 = 0;
		LOC10 = skiptypes_195167(arg, 2048);
		a = copytype_194549(LOC10, (*arg).owner, NIM_FALSE);
		asgnRefNoCycle((void**) (&(*a).sons->data[((65552 &(IL64(1)<<(((*arg).kind)&IL64(63))))!=0)]), (*formal).sons->data[((NI) 0)]);
		result = a;
	}
	goto LA1;
	LA8: ;
	{
		NIM_BOOL LOC12;
		LOC12 = 0;
		LOC12 = ((786432 &(IL64(1)<<(((*formal).kind)&IL64(63))))!=0);
		if (!(LOC12)) goto LA13;
		LOC12 = ((*arg).kind == (*formal).kind);
		LA13: ;
		if (!LOC12) goto LA14;
		result = formal;
	}
	goto LA1;
	LA14: ;
	{
		result = arg;
	}
	LA1: ;
	return result;
}

N_NIMCALL(Ttype191849*, baseofdistinct_230320)(Ttype191849* t) {
	Ttype191849* result;
	result = 0;
	{
		if (!((*t).kind == ((NU8) 13))) goto LA3;
		result = (*t).sons->data[((NI) 0)];
	}
	goto LA1;
	LA3: ;
	{
		Ttype191849* parent;
		Ttype191849* it;
		result = copytype_194549(t, (*t).owner, NIM_FALSE);
		parent = NIM_NIL;
		it = result;
		{
			while (1) {
				if (!((6291456 &(IL64(1)<<(((*it).kind)&IL64(63))))!=0)) goto LA7;
				parent = it;
				it = lastson_194442(it);
			} LA7: ;
		}
		{
			if (!((*it).kind == ((NU8) 13))) goto LA10;
			{
				NimStringDesc* LOC16;
				if (!!(!((parent == NIM_NIL)))) goto LA14;
				LOC16 = 0;
				LOC16 = HEX24_166306(TMP3346);
				internalerror_166218(LOC16);
			}
			LA14: ;
			asgnRefNoCycle((void**) (&(*parent).sons->data[((NI) 0)]), (*it).sons->data[((NI) 0)]);
		}
		LA10: ;
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, skiphiddensubconv_231078)(Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	{
		Ttype191849* formal;
		Ttype191849* arg;
		Ttype191849* dest;
		if (!((*n).kind == ((NU8) 59))) goto LA3;
		formal = (*n).typ;
		result = (*n).kindU.S6.sons->data[((NI) 1)];
		arg = (*result).typ;
		dest = taketype_231006(formal, arg);
		{
			NIM_BOOL LOC7;
			LOC7 = 0;
			LOC7 = (dest == arg);
			if (!(LOC7)) goto LA8;
			LOC7 = !(((*formal).kind == ((NU8) 6)));
			LA8: ;
			if (!LOC7) goto LA9;
			result = n;
		}
		goto LA5;
		LA9: ;
		{
			result = copytree_196028(result);
			asgnRefNoCycle((void**) (&(*result).typ), dest);
		}
		LA5: ;
	}
	goto LA1;
	LA3: ;
	{
		result = n;
	}
	LA1: ;
	return result;
}

N_NIMCALL(Tnode191813*, skipconvtaketype_230967)(Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	result = skipconv_230935(n);
	asgnRefNoCycle((void**) (&(*result).typ), (*n).typ);
	return result;
}

N_NIMCALL(NIM_BOOL, searchtypenodeforaux_222235)(Tnode191813* n, Ttypepredicate221050 p, Intset188056* marker) {
	NIM_BOOL result;
{	result = 0;
	result = NIM_FALSE;
	switch ((*n).kind) {
	case ((NU8) 138):
	{
		{
			NI i_222254;
			NI HEX3Atmp_222420;
			NI LOC3;
			NI res_222423;
			i_222254 = 0;
			HEX3Atmp_222420 = 0;
			LOC3 = 0;
			LOC3 = sonslen_194403(n);
			HEX3Atmp_222420 = (NI)(LOC3 - ((NI) 1));
			res_222423 = ((NI) 0);
			{
				while (1) {
					if (!(res_222423 <= HEX3Atmp_222420)) goto LA5;
					i_222254 = res_222423;
					result = searchtypenodeforaux_222235((*n).kindU.S6.sons->data[i_222254], p, marker);
					{
						if (!result) goto LA8;
						goto BeforeRet;
					}
					LA8: ;
					res_222423 += ((NI) 1);
				} LA5: ;
			}
		}
	}
	break;
	case ((NU8) 139):
	{
		result = searchtypenodeforaux_222235((*n).kindU.S6.sons->data[((NI) 0)], p, marker);
		{
			if (!result) goto LA13;
			goto BeforeRet;
		}
		LA13: ;
		{
			NI i_222414;
			NI HEX3Atmp_222428;
			NI LOC16;
			NI res_222431;
			i_222414 = 0;
			HEX3Atmp_222428 = 0;
			LOC16 = 0;
			LOC16 = sonslen_194403(n);
			HEX3Atmp_222428 = (NI)(LOC16 - ((NI) 1));
			res_222431 = ((NI) 1);
			{
				while (1) {
					if (!(res_222431 <= HEX3Atmp_222428)) goto LA18;
					i_222414 = res_222431;
					switch ((*(*n).kindU.S6.sons->data[i_222414]).kind) {
					case ((NU8) 85):
					case ((NU8) 88):
					{
						Tnode191813* LOC20;
						LOC20 = 0;
						LOC20 = lastson_194431((*n).kindU.S6.sons->data[i_222414]);
						result = searchtypenodeforaux_222235(LOC20, p, marker);
						{
							if (!result) goto LA23;
							goto BeforeRet;
						}
						LA23: ;
					}
					break;
					default:
					{
						internalerror_166218(((NimStringDesc*) &TMP3409));
					}
					break;
					}
					res_222431 += ((NI) 1);
				} LA18: ;
			}
		}
	}
	break;
	case ((NU8) 3):
	{
		result = searchtypeforaux_222226((*(*n).kindU.S4.sym).typ, p, marker);
	}
	break;
	default:
	{
		internalerror_166199((*n).info, ((NimStringDesc*) &TMP3410));
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, searchtypeforaux_222226)(Ttype191849* t, Ttypepredicate221050 predicate, Intset188056* marker) {
	NIM_BOOL result;
{	result = 0;
	result = NIM_FALSE;
	{
		if (!(t == NIM_NIL)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	{
		NIM_BOOL LOC7;
		LOC7 = 0;
		LOC7 = containsorincl_188898(marker, (*t).Sup.id);
		if (!LOC7) goto LA8;
		goto BeforeRet;
	}
	LA8: ;
	result = predicate(t);
	{
		if (!result) goto LA12;
		goto BeforeRet;
	}
	LA12: ;
	switch ((*t).kind) {
	case ((NU8) 17):
	{
		result = searchtypeforaux_222226((*t).sons->data[((NI) 0)], predicate, marker);
		{
			if (!!(result)) goto LA17;
			result = searchtypenodeforaux_222235((*t).n, predicate, marker);
		}
		LA17: ;
	}
	break;
	case ((NU8) 11):
	case ((NU8) 13):
	{
		Ttype191849* LOC20;
		LOC20 = 0;
		LOC20 = lastson_194442(t);
		result = searchtypeforaux_222226(LOC20, predicate, marker);
	}
	break;
	case ((NU8) 16):
	case ((NU8) 4):
	case ((NU8) 19):
	case ((NU8) 18):
	{
		{
			NI i_222490;
			NI HEX3Atmp_222492;
			NI LOC23;
			NI res_222495;
			i_222490 = 0;
			HEX3Atmp_222492 = 0;
			LOC23 = 0;
			LOC23 = sonslen_194351(t);
			HEX3Atmp_222492 = (NI)(LOC23 - ((NI) 1));
			res_222495 = ((NI) 0);
			{
				while (1) {
					if (!(res_222495 <= HEX3Atmp_222492)) goto LA25;
					i_222490 = res_222495;
					result = searchtypeforaux_222226((*t).sons->data[i_222490], predicate, marker);
					{
						if (!result) goto LA28;
						goto BeforeRet;
					}
					LA28: ;
					res_222495 += ((NI) 1);
				} LA25: ;
			}
		}
	}
	break;
	default:
	{
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, searchtypefor_222514)(Ttype191849* t, Ttypepredicate221050 predicate) {
	NIM_BOOL result;
	Intset188056 marker;
	result = 0;
	memset((void*)(&marker), 0, sizeof(marker));
	chckNil((void*)(&marker));
	memset((void*)(&marker), 0, sizeof(marker));
	initintset_188927((&marker));
	result = searchtypeforaux_222226(t, predicate, (&marker));
	return result;
}

N_NIMCALL(NIM_BOOL, isgcref_222783)(Ttype191849* t) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	NIM_BOOL LOC3;
	result = 0;
	LOC1 = 0;
	LOC1 = ((289406976 &(IL64(1)<<(((*t).kind)&IL64(63))))!=0);
	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(NIM_BOOL, containsgarbagecollectedref_221154)(Ttype191849* typ) {
	NIM_BOOL result;
	result = 0;
	result = searchtypefor_222514(typ, isgcref_222783);
	return result;
}

N_NIMCALL(Ttype191849*, commonsuperclass_228468)(Ttype191849* a, Ttype191849* b) {
	Ttype191849* result;
	Ttype191849* x;
	Intset188056 ancestors;
	Ttype191849* y;
{	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = sameobjecttypes_226785(a, b);
		if (!LOC3) goto LA4;
		result = a;
		goto BeforeRet;
	}
	LA4: ;
	x = a;
	memset((void*)(&ancestors), 0, sizeof(ancestors));
	chckNil((void*)(&ancestors));
	memset((void*)(&ancestors), 0, sizeof(ancestors));
	initintset_188927((&ancestors));
	{
		while (1) {
			if (!!((x == NIM_NIL))) goto LA7;
			x = skiptypes_195167(x, IL64(211106247215360));
			incl_188856((&ancestors), (*x).Sup.id);
			x = (*x).sons->data[((NI) 0)];
		} LA7: ;
	}
	y = b;
	{
		while (1) {
			if (!!((y == NIM_NIL))) goto LA9;
			y = skiptypes_195167(y, IL64(211106247215360));
			{
				NIM_BOOL LOC12;
				LOC12 = 0;
				LOC12 = contains_188829((&ancestors), (*y).Sup.id);
				if (!LOC12) goto LA13;
				result = y;
				goto BeforeRet;
			}
			LA13: ;
			y = (*y).sons->data[((NI) 0)];
		} LA9: ;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, samebackendtype_228024)(Ttype191849* x, Ttype191849* y) {
	NIM_BOOL result;
	Tsametypeclosure225841 c;
	result = 0;
	memset((void*)(&c), 0, sizeof(c));
	chckNil((void*)(&c));
	memset((void*)(&c), 0, sizeof(c));
	initsametypeclosure_225863((&c));
	c.flags |= ((NI8)1)<<((((NU8) 0))%(sizeof(NI8)*8));
	result = sametypeaux_226035(x, y, (&c));
	return result;
}

N_NIMCALL(NIM_BOOL, ispureobject_221196)(Ttype191849* typ) {
	NIM_BOOL result;
	Ttype191849* t;
	NIM_BOOL LOC5;
	result = 0;
	t = typ;
	{
		while (1) {
			NIM_BOOL LOC3;
			LOC3 = 0;
			LOC3 = ((*t).kind == ((NU8) 17));
			if (!(LOC3)) goto LA4;
			LOC3 = !(((*t).sons->data[((NI) 0)] == NIM_NIL));
			LA4: ;
			if (!LOC3) goto LA2;
			t = (*t).sons->data[((NI) 0)];
		} LA2: ;
	}
	LOC5 = 0;
	LOC5 = !(((*t).sym == NIM_NIL));
	if (!(LOC5)) goto LA6;
	LOC5 = (((*(*t).sym).flags &(1<<((((NU8) 9))&31)))!=0);
	LA6: ;
	result = LOC5;
	return result;
}

N_NIMCALL(NIM_BOOL, canformacyclenode_222918)(Intset188056* marker, Tnode191813* n, NI startid) {
	NIM_BOOL result;
{	result = 0;
	result = NIM_FALSE;
	{
		if (!!((n == NIM_NIL))) goto LA3;
		result = canformacycleaux_222909(marker, (*n).typ, startid);
		{
			if (!!(result)) goto LA7;
			switch ((*n).kind) {
			case ((NU8) 0) ... ((NU8) 23):
			{
			}
			break;
			default:
			{
				{
					NI i_222949;
					NI HEX3Atmp_222952;
					NI LOC12;
					NI res_222955;
					i_222949 = 0;
					HEX3Atmp_222952 = 0;
					LOC12 = 0;
					LOC12 = sonslen_194403(n);
					HEX3Atmp_222952 = (NI)(LOC12 - ((NI) 1));
					res_222955 = ((NI) 0);
					{
						while (1) {
							if (!(res_222955 <= HEX3Atmp_222952)) goto LA14;
							i_222949 = res_222955;
							result = canformacyclenode_222918(marker, (*n).kindU.S6.sons->data[i_222949], startid);
							{
								if (!result) goto LA17;
								goto BeforeRet;
							}
							LA17: ;
							res_222955 += ((NI) 1);
						} LA14: ;
					}
				}
			}
			break;
			}
		}
		LA7: ;
	}
	LA3: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, canformacycleaux_222909)(Intset188056* marker, Ttype191849* typ, NI startid) {
	NIM_BOOL result;
	Ttype191849* t;
{	result = 0;
	result = NIM_FALSE;
	{
		if (!(typ == NIM_NIL)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	{
		if (!(((*typ).flags &(1<<((((NU8) 4))&31)))!=0)) goto LA7;
		goto BeforeRet;
	}
	LA7: ;
	t = skiptypes_195167(typ, IL64(211106232576000));
	{
		if (!(((*t).flags &(1<<((((NU8) 4))&31)))!=0)) goto LA11;
		goto BeforeRet;
	}
	LA11: ;
	switch ((*t).kind) {
	case ((NU8) 18):
	case ((NU8) 17):
	case ((NU8) 22):
	case ((NU8) 24):
	case ((NU8) 16):
	case ((NU8) 4):
	case ((NU8) 27):
	case ((NU8) 48):
	{
		{
			NIM_BOOL LOC16;
			LOC16 = 0;
			LOC16 = containsorincl_188898(marker, (*t).Sup.id);
			if (!!(LOC16)) goto LA17;
			{
				NI i_223039;
				NI HEX3Atmp_223081;
				NI LOC20;
				NI res_223084;
				i_223039 = 0;
				HEX3Atmp_223081 = 0;
				LOC20 = 0;
				LOC20 = sonslen_194351(t);
				HEX3Atmp_223081 = (NI)(LOC20 - ((NI) 1));
				res_223084 = ((NI) 0);
				{
					while (1) {
						if (!(res_223084 <= HEX3Atmp_223081)) goto LA22;
						i_223039 = res_223084;
						result = canformacycleaux_222909(marker, (*t).sons->data[i_223039], startid);
						{
							if (!result) goto LA25;
							goto BeforeRet;
						}
						LA25: ;
						res_223084 += ((NI) 1);
					} LA22: ;
				}
			}
			{
				if (!!(((*t).n == NIM_NIL))) goto LA29;
				result = canformacyclenode_222918(marker, (*t).n, startid);
			}
			LA29: ;
		}
		goto LA14;
		LA17: ;
		{
			result = ((*t).Sup.id == startid);
		}
		LA14: ;
		{
			NIM_BOOL LOC34;
			LOC34 = 0;
			LOC34 = ((*t).kind == ((NU8) 17));
			if (!(LOC34)) goto LA35;
			LOC34 = !((((*t).flags &(1<<((((NU8) 2))&31)))!=0));
			LA35: ;
			if (!LOC34) goto LA36;
			result = NIM_TRUE;
		}
		LA36: ;
	}
	break;
	case ((NU8) 25):
	{
		result = ((*typ).callconv == ((NU8) 8));
	}
	break;
	default:
	{
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, canformacycle_221166)(Ttype191849* typ) {
	NIM_BOOL result;
	Intset188056 marker;
	result = 0;
	memset((void*)(&marker), 0, sizeof(marker));
	chckNil((void*)(&marker));
	memset((void*)(&marker), 0, sizeof(marker));
	initintset_188927((&marker));
	result = canformacycleaux_222909((&marker), typ, (*typ).Sup.id);
	return result;
}

N_NIMCALL(NU8, analyseobjectwithtypefieldaux_222637)(Ttype191849* t, Intset188056* marker) {
	NU8 result;
	NU8 res;
{	result = 0;
	res = 0;
	result = ((NU8) 0);
	{
		if (!(t == NIM_NIL)) goto LA3;
		goto BeforeRet;
	}
	LA3: ;
	switch ((*t).kind) {
	case ((NU8) 17):
	{
		{
			if (!!(((*t).n == NIM_NIL))) goto LA8;
			{
				NIM_BOOL LOC12;
				LOC12 = 0;
				LOC12 = searchtypenodeforaux_222235((*t).n, isobjectwithtypefieldpredicate_222556, marker);
				if (!LOC12) goto LA13;
				result = ((NU8) 2);
				goto BeforeRet;
			}
			LA13: ;
		}
		LA8: ;
		{
			NI i_222680;
			NI HEX3Atmp_222732;
			NI LOC16;
			NI res_222735;
			i_222680 = 0;
			HEX3Atmp_222732 = 0;
			LOC16 = 0;
			LOC16 = sonslen_194351(t);
			HEX3Atmp_222732 = (NI)(LOC16 - ((NI) 1));
			res_222735 = ((NI) 0);
			{
				while (1) {
					if (!(res_222735 <= HEX3Atmp_222732)) goto LA18;
					i_222680 = res_222735;
					res = analyseobjectwithtypefieldaux_222637((*t).sons->data[i_222680], marker);
					{
						if (!(res == ((NU8) 2))) goto LA21;
						result = ((NU8) 2);
						goto BeforeRet;
					}
					LA21: ;
					{
						if (!(res == ((NU8) 1))) goto LA25;
						result = ((NU8) 1);
					}
					LA25: ;
					res_222735 += ((NI) 1);
				} LA18: ;
			}
		}
		{
			if (!(result == ((NU8) 0))) goto LA29;
			{
				NIM_BOOL LOC33;
				LOC33 = 0;
				LOC33 = isobjectwithtypefieldpredicate_222556(t);
				if (!LOC33) goto LA34;
				result = ((NU8) 1);
			}
			LA34: ;
		}
		LA29: ;
	}
	break;
	case ((NU8) 11):
	case ((NU8) 13):
	case ((NU8) 46):
	case ((NU8) 47):
	{
		Ttype191849* LOC37;
		LOC37 = 0;
		LOC37 = lastson_194442(t);
		result = analyseobjectwithtypefieldaux_222637(LOC37, marker);
	}
	break;
	case ((NU8) 16):
	case ((NU8) 4):
	case ((NU8) 18):
	{
		{
			NI i_222720;
			NI HEX3Atmp_222740;
			NI LOC40;
			NI res_222743;
			i_222720 = 0;
			HEX3Atmp_222740 = 0;
			LOC40 = 0;
			LOC40 = sonslen_194351(t);
			HEX3Atmp_222740 = (NI)(LOC40 - ((NI) 1));
			res_222743 = ((NI) 0);
			{
				while (1) {
					if (!(res_222743 <= HEX3Atmp_222740)) goto LA42;
					i_222720 = res_222743;
					res = analyseobjectwithtypefieldaux_222637((*t).sons->data[i_222720], marker);
					{
						if (!!((res == ((NU8) 0)))) goto LA45;
						result = ((NU8) 2);
						goto BeforeRet;
					}
					LA45: ;
					res_222743 += ((NI) 1);
				} LA42: ;
			}
		}
	}
	break;
	default:
	{
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NU8, analyseobjectwithtypefield_221216)(Ttype191849* t) {
	NU8 result;
	Intset188056 marker;
	result = 0;
	memset((void*)(&marker), 0, sizeof(marker));
	chckNil((void*)(&marker));
	memset((void*)(&marker), 0, sizeof(marker));
	initintset_188927((&marker));
	result = analyseobjectwithtypefieldaux_222637(t, (&marker));
	return result;
}

N_NIMCALL(NIM_BOOL, ishiddenpointer_222878)(Ttype191849* t) {
	NIM_BOOL result;
	result = 0;
	result = ((285212672 &(IL64(1)<<(((*t).kind)&IL64(63))))!=0);
	return result;
}

N_NIMCALL(NIM_BOOL, containshiddenpointer_221160)(Ttype191849* typ) {
	NIM_BOOL result;
	result = 0;
	result = searchtypefor_222514(typ, ishiddenpointer_222878);
	return result;
}

static N_INLINE(NIM_BOOL, iscompiletimeonly_230712)(Ttype191849* t) {
	NIM_BOOL result;
	result = 0;
	result = ((IL64(576460752303423744) &(IL64(1)<<(((*t).kind)&IL64(63))))!=0);
	return result;
}

N_NIMCALL(NIM_BOOL, containscompiletimeonly_230733)(Ttype191849* t) {
	NIM_BOOL result;
{	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = iscompiletimeonly_230712(t);
		if (!LOC3) goto LA4;
		result = NIM_TRUE;
		goto BeforeRet;
	}
	LA4: ;
	{
		NIM_BOOL LOC8;
		LOC8 = 0;
		LOC8 = HEX3DHEX3D_230739((*t).sons, NIM_NIL);
		if (!!(LOC8)) goto LA9;
		{
			NI i_230869;
			NI HEX3Atmp_230883;
			NI LOC12;
			NI res_230886;
			i_230869 = 0;
			HEX3Atmp_230883 = 0;
			LOC12 = 0;
			LOC12 = sonslen_194351(t);
			HEX3Atmp_230883 = (LOC12 - 1);
			res_230886 = ((NI) 0);
			{
				while (1) {
					if (!(res_230886 <= HEX3Atmp_230883)) goto LA14;
					i_230869 = res_230886;
					{
						NIM_BOOL LOC17;
						LOC17 = 0;
						LOC17 = !(((*t).sons->data[i_230869] == NIM_NIL));
						if (!(LOC17)) goto LA18;
						LOC17 = iscompiletimeonly_230712((*t).sons->data[i_230869]);
						LA18: ;
						if (!LOC17) goto LA19;
						result = NIM_TRUE;
						goto BeforeRet;
					}
					LA19: ;
					res_230886 += ((NI) 1);
				} LA14: ;
			}
		}
	}
	LA9: ;
	result = NIM_FALSE;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}
NIM_EXTERNC N_NOINLINE(void, nimsrc_typesInit)(void) {
}

NIM_EXTERNC N_NOINLINE(void, nimsrc_typesDatInit)(void) {
static TNimNode* TMP2631[2];
static TNimNode TMP813[3];
NTI225855.size = sizeof(TY225855);
NTI225855.kind = 18;
NTI225855.base = 0;
NTI225855.flags = 3;
TMP2631[0] = &TMP813[1];
TMP813[1].kind = 1;
TMP813[1].offset = offsetof(TY225855, Field0);
TMP813[1].typ = (&NTI108);
TMP813[1].name = "Field0";
TMP2631[1] = &TMP813[2];
TMP813[2].kind = 1;
TMP813[2].offset = offsetof(TY225855, Field1);
TMP813[2].typ = (&NTI108);
TMP813[2].name = "Field1";
TMP813[0].len = 2; TMP813[0].kind = 2; TMP813[0].sons = &TMP2631[0];
NTI225855.node = &TMP813[0];
NTI225854.size = sizeof(TY225854*);
NTI225854.kind = 24;
NTI225854.base = (&NTI225855);
NTI225854.flags = 2;
NTI225854.marker = TMP2632;
}

