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

#include <string.h>
typedef struct tsym224846 tsym224846;
typedef struct NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
typedef struct tcell44935 tcell44935;
typedef struct TNimType TNimType;
typedef struct tcellseq44951 tcellseq44951;
typedef struct tgcheap47016 tgcheap47016;
typedef struct tcellset44947 tcellset44947;
typedef struct tpagedesc44943 tpagedesc44943;
typedef struct tmemregion27210 tmemregion27210;
typedef struct tsmallchunk26440 tsmallchunk26440;
typedef struct tllchunk27204 tllchunk27204;
typedef struct tbigchunk26442 tbigchunk26442;
typedef struct tintset26417 tintset26417;
typedef struct ttrunk26413 ttrunk26413;
typedef struct tavlnode27208 tavlnode27208;
typedef struct tgcstat47014 tgcstat47014;
typedef struct tnode224816 tnode224816;
typedef struct analysisctx482026 analysisctx482026;
typedef struct TY482036 TY482036;
typedef struct monotonicvar482024 monotonicvar482024;
typedef struct TY482038 TY482038;
typedef struct TY482039 TY482039;
typedef struct tnodeseq224810 tnodeseq224810;
typedef struct tsymseq224818 tsymseq224818;
typedef struct TNimNode TNimNode;
typedef struct ttype224852 ttype224852;
typedef struct tlineinfo194539 tlineinfo194539;
typedef struct tident199021 tident199021;
typedef struct tidobj199015 tidobj199015;
typedef struct TNimObject TNimObject;
typedef struct ttypeseq224848 ttypeseq224848;
typedef struct tscope224840 tscope224840;
typedef struct TY224947 TY224947;
typedef struct tinstantiation224836 tinstantiation224836;
typedef struct tstrtable224820 tstrtable224820;
typedef struct tloc224830 tloc224830;
typedef struct trope176009 trope176009;
typedef struct tlib224834 tlib224834;
typedef struct tbasechunk26438 tbasechunk26438;
typedef struct tfreecell26430 tfreecell26430;
typedef struct TY224936 TY224936;
typedef struct tlistentry126022 tlistentry126022;
struct  TGenericSeq  {
NI len;
NI reserved;
};
struct  NimStringDesc  {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
struct  tcell44935  {
NI Refcount;
TNimType* Typ;
};
struct  tcellseq44951  {
NI Len;
NI Cap;
tcell44935** D;
};
struct  tcellset44947  {
NI Counter;
NI Max;
tpagedesc44943* Head;
tpagedesc44943** Data;
};
typedef tsmallchunk26440* TY27222[512];
typedef ttrunk26413* ttrunkbuckets26415[256];
struct  tintset26417  {
ttrunkbuckets26415 Data;
};
struct  tmemregion27210  {
NI Minlargeobj;
NI Maxlargeobj;
TY27222 Freesmallchunks;
tllchunk27204* Llmem;
NI Currmem;
NI Maxmem;
NI Freemem;
NI Lastsize;
tbigchunk26442* Freechunkslist;
tintset26417 Chunkstarts;
tavlnode27208* Root;
tavlnode27208* Deleted;
tavlnode27208* Last;
tavlnode27208* Freeavlnodes;
};
struct  tgcstat47014  {
NI Stackscans;
NI Cyclecollections;
NI Maxthreshold;
NI Maxstacksize;
NI Maxstackcells;
NI Cycletablesize;
NI64 Maxpause;
};
struct  tgcheap47016  {
void* Stackbottom;
NI Cyclethreshold;
tcellseq44951 Zct;
tcellseq44951 Decstack;
tcellset44947 Cycleroots;
tcellseq44951 Tempstack;
NI Recgclock;
tmemregion27210 Region;
tgcstat47014 Stat;
};
struct  monotonicvar482024  {
tsym224846* V;
tsym224846* Alias;
tnode224816* Lower;
tnode224816* Upper;
tnode224816* Stride;
NU8 Dir;
NIM_BOOL Blacklisted;
};
struct TY482039 {
tnode224816* Field0;
tnode224816* Field1;
tnode224816* Field2;
NI Field3;
NIM_BOOL Field4;
};
struct  analysisctx482026  {
TY482036* Locals;
TY482038* Slices;
tnodeseq224810* Guards;
tsymseq224818* Args;
NI Spawns;
NI Currentspawnid;
NI Inloop;
};
typedef N_NIMCALL_PTR(void, TY3089) (void* p, NI op);
typedef N_NIMCALL_PTR(void*, TY3094) (void* p);
struct  TNimType  {
NI size;
NU8 kind;
NU8 flags;
TNimType* base;
TNimNode* node;
void* finalizer;
TY3089 marker;
TY3094 deepcopy;
};
struct  TNimNode  {
NU8 kind;
NI offset;
TNimType* typ;
NCSTRING name;
NI len;
TNimNode** sons;
};
struct  tlineinfo194539  {
NI16 Line;
NI16 Col;
NI32 Fileindex;
};
struct  tnode224816  {
ttype224852* Typ;
tlineinfo194539 Info;
NU16 Flags;
NU8 Kind;
union {
struct {NI64 Intval;
} S1;
struct {NF Floatval;
} S2;
struct {NimStringDesc* Strval;
} S3;
struct {tsym224846* Sym;
} S4;
struct {tident199021* Ident;
} S5;
struct {tnodeseq224810* Sons;
} S6;
} kindU;
NimStringDesc* Comment;
};
struct  TNimObject  {
TNimType* m_type;
};
struct  tidobj199015  {
  TNimObject Sup;
NI Id;
};
struct  tstrtable224820  {
NI Counter;
tsymseq224818* Data;
};
struct  tloc224830  {
NU8 K;
NU8 S;
NU8 Flags;
ttype224852* T;
trope176009* R;
trope176009* Heaproot;
};
struct  tsym224846  {
  tidobj199015 Sup;
NU8 Kind;
union {
struct {ttypeseq224848* Typeinstcache;
tscope224840* Typscope;
} S1;
struct {TY224947* Procinstcache;
tscope224840* Scope;
} S2;
struct {TY224947* Usedgenerics;
tstrtable224820 Tab;
} S3;
struct {tsym224846* Guard;
} S4;
} kindU;
NU16 Magic;
ttype224852* Typ;
tident199021* Name;
tlineinfo194539 Info;
tsym224846* Owner;
NU32 Flags;
tnode224816* Ast;
NU32 Options;
NI Position;
NI Offset;
tloc224830 Loc;
tlib224834* Annex;
tnode224816* Constraint;
};
struct  tident199021  {
  tidobj199015 Sup;
NimStringDesc* S;
tident199021* Next;
NI H;
};
typedef NimStringDesc* TY482908[6];
typedef NimStringDesc* TY196620[4];
struct  ttype224852  {
  tidobj199015 Sup;
NU8 Kind;
NU8 Callconv;
NU32 Flags;
ttypeseq224848* Sons;
tnode224816* N;
tsym224846* Owner;
tsym224846* Sym;
tsym224846* Destructor;
tsym224846* Deepcopy;
NI64 Size;
NI16 Align;
NI16 Locklevel;
tloc224830 Loc;
};
typedef NI TY26420[8];
struct  tpagedesc44943  {
tpagedesc44943* Next;
NI Key;
TY26420 Bits;
};
struct  tbasechunk26438  {
NI Prevsize;
NI Size;
NIM_BOOL Used;
};
struct  tsmallchunk26440  {
  tbasechunk26438 Sup;
tsmallchunk26440* Next;
tsmallchunk26440* Prev;
tfreecell26430* Freelist;
NI Free;
NI Acc;
NF Data;
};
struct  tllchunk27204  {
NI Size;
NI Acc;
tllchunk27204* Next;
};
struct  tbigchunk26442  {
  tbasechunk26438 Sup;
tbigchunk26442* Next;
tbigchunk26442* Prev;
NI Align;
NF Data;
};
struct  ttrunk26413  {
ttrunk26413* Next;
NI Key;
TY26420 Bits;
};
typedef tavlnode27208* TY27214[2];
struct  tavlnode27208  {
TY27214 Link;
NI Key;
NI Upperbound;
NI Level;
};
struct  tscope224840  {
NI Depthlevel;
tstrtable224820 Symbols;
tnodeseq224810* Usingsyms;
tscope224840* Parent;
};
struct  tinstantiation224836  {
tsym224846* Sym;
ttypeseq224848* Concretetypes;
TY224936* Usedby;
};
struct  trope176009  {
  TNimObject Sup;
trope176009* Left;
trope176009* Right;
NI Length;
NimStringDesc* Data;
};
struct  tlistentry126022  {
  TNimObject Sup;
tlistentry126022* Prev;
tlistentry126022* Next;
};
struct  tlib224834  {
  tlistentry126022 Sup;
NU8 Kind;
NIM_BOOL Generated;
NIM_BOOL Isoverriden;
trope176009* Name;
tnode224816* Path;
};
struct  tfreecell26430  {
tfreecell26430* Next;
NI Zerofield;
};
struct TY482036 {
  TGenericSeq Sup;
  monotonicvar482024 data[SEQ_DECL_SIZE];
};
struct TY482038 {
  TGenericSeq Sup;
  TY482039 data[SEQ_DECL_SIZE];
};
struct tnodeseq224810 {
  TGenericSeq Sup;
  tnode224816* data[SEQ_DECL_SIZE];
};
struct tsymseq224818 {
  TGenericSeq Sup;
  tsym224846* data[SEQ_DECL_SIZE];
};
struct ttypeseq224848 {
  TGenericSeq Sup;
  ttype224852* data[SEQ_DECL_SIZE];
};
struct TY224947 {
  TGenericSeq Sup;
  tinstantiation224836* data[SEQ_DECL_SIZE];
};
struct TY224936 {
  TGenericSeq Sup;
  NI32 data[SEQ_DECL_SIZE];
};
N_NIMCALL(tsym224846*, createmagic_367405)(NimStringDesc* name, NU16 m);
static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src);
static N_INLINE(tcell44935*, usrtocell_48646)(void* usr);
static N_INLINE(void, rtladdzct_50204)(tcell44935* c);
N_NOINLINE(void, addzct_48617)(tcellseq44951* s, tcell44935* c);
N_NIMCALL(void, initanalysisctx_482059)(analysisctx482026* Result);
N_NIMCALL(void, nimGCvisit)(void* d, NI op);
N_NIMCALL(void, TMP3864)(void* p, NI op);
N_NIMCALL(void*, newSeq)(TNimType* typ, NI len);
N_NIMCALL(void, unsureAsgnRef)(void** dest, void* src);
N_NIMCALL(void, TMP3866)(void* p, NI op);
N_NOINLINE(void, chckNil)(void* p);
static N_INLINE(tnode224816*, lastson_225261)(tnode224816* n);
static N_INLINE(NI, sonslen_225249)(tnode224816* n);
N_NIMCALL(void, analyse_483509)(analysisctx482026* c, tnode224816* n);
N_NIMCALL(NIM_BOOL, issingleassignable_482416)(tnode224816* n);
static N_INLINE(tnode224816*, HEX5BHEX5D_225698)(tnode224816* n, NI i);
N_NIMCALL(NIM_BOOL, islocal_482501)(tnode224816* n);
N_NIMCALL(monotonicvar482024*, getslot_482239)(analysisctx482026* c, tsym224846* v);
N_NIMCALL(NI, lookupslot_482148)(analysisctx482026* c, tsym224846* s);
N_NIMCALL(TGenericSeq*, setLengthSeq)(TGenericSeq* seq, NI elemsize, NI newlen);
N_NIMCALL(void, invalidatefacts_369774)(tnodeseq224810** m, tnode224816* n);
N_NIMCALL(NU16, getmagic_260845)(tnode224816* op);
N_NIMCALL(void, gatherargs_482283)(analysisctx482026* c, tnode224816* n);
static N_INLINE(NI, safelen_225424)(tnode224816* n);
N_NIMCALL(tsym224846*, getroot_425533)(tnode224816* n);
N_NIMCALL(TGenericSeq*, incrSeq)(TGenericSeq* seq, NI elemsize);
N_NIMCALL(void, analysesons_483517)(analysisctx482026* c, tnode224816* n);
N_NIMCALL(void, addasgnfact_373618)(tnodeseq224810** m, tnode224816* key, tnode224816* value);
N_NIMCALL(void, analysecall_483647)(analysisctx482026* c, tnode224816* n, tsym224846* op);
static N_INLINE(NIM_BOOL, eqStrings)(NimStringDesc* a, NimStringDesc* b);
N_NIMCALL(NIM_BOOL, fromsystem_483616)(tsym224846* op);
N_NIMCALL(tsym224846*, getmodule_234243)(tsym224846* s);
N_NIMCALL(tnode224816*, skipconv_272732)(tnode224816* n);
N_NIMCALL(tnode224816*, min_483565)(tnode224816* a, tnode224816* b);
N_NIMCALL(void, addslice_482835)(analysisctx482026* c, tnode224816* n, tnode224816* x, tnode224816* le_482841, tnode224816* ri_482842);
N_NIMCALL(void, checklocal_482586)(analysisctx482026* c, tnode224816* n);
N_NIMCALL(void, localerror_196966)(tlineinfo194539 info, NimStringDesc* arg);
N_NIMCALL(tnode224816*, canon_368513)(tnode224816* n);
N_NIMCALL(void, addlowerboundasfacts_482708)(analysisctx482026* c);
N_NIMCALL(void, addfactle_373018)(tnodeseq224810** m, tnode224816* a, tnode224816* b);
N_NIMCALL(tnode224816*, newsymnode_225132)(tsym224846* sym);
N_NIMCALL(void, checkbounds_482697)(analysisctx482026* c, tnode224816* arr, tnode224816* idx);
N_NIMCALL(void, checkle_482686)(analysisctx482026* c, tnode224816* a, tnode224816* b);
N_NIMCALL(NU8, provele_372995)(tnodeseq224810* m, tnode224816* a, tnode224816* b);
static N_INLINE(void, appendString)(NimStringDesc* dest, NimStringDesc* src);
N_NIMCALL(NimStringDesc*, rendertree_249058)(tnode224816* n, NU8 renderflags);
N_NIMCALL(NimStringDesc*, rawNewString)(NI space);
N_NIMCALL(tnode224816*, lowbound_368448)(tnode224816* x);
N_NIMCALL(tnode224816*, highbound_368458)(tnode224816* x);
N_NIMCALL(void, genericAssign)(void* dest, void* src, TNimType* mt);
static N_INLINE(NI, len_225364)(tnode224816* n);
N_NIMCALL(void, internalerror_196987)(tlineinfo194539 info, NimStringDesc* errmsg);
N_NIMCALL(void, analysecase_483738)(analysisctx482026* c, tnode224816* n);
N_NIMCALL(void, addcasebranchfacts_373755)(tnodeseq224810** m, tnode224816* n, NI i);
N_NIMCALL(void, analyseif_483911)(analysisctx482026* c, tnode224816* n);
N_NIMCALL(void, addfact_369349)(tnodeseq224810** m, tnode224816* n_369353);
N_NIMCALL(void, addfactneg_369396)(tnodeseq224810** m, tnode224816* n_369400);
N_NIMCALL(NIM_BOOL, istrue_380730)(tnode224816* n);
N_NIMCALL(NIM_BOOL, hassubnodewith_225308)(tnode224816* n, NU8 kind);
N_NIMCALL(void, checkslicesaredisjoint_483168)(analysisctx482026* c);
N_NIMCALL(void, overlap_482899)(tnodeseq224810* m, tnode224816* x, tnode224816* y, tnode224816* c, tnode224816* d);
N_NIMCALL(NimStringDesc*, nsuFormatOpenArray)(NimStringDesc* formatstr, NimStringDesc** a, NI aLen0);
N_NIMCALL(tnode224816*, substride_483044)(analysisctx482026* c, tnode224816* n);
N_NIMCALL(tnode224816*, HEX2BHEX40_368779)(tnode224816* a, NI64 b);
N_NIMCALL(tnode224816*, shallowcopy_230347)(tnode224816* src);
N_NIMCALL(NIM_BOOL, sametree_369425)(tnode224816* a, tnode224816* b);
N_NIMCALL(NI64, simpleslice_372066)(tnode224816* a, tnode224816* b);
N_NIMCALL(NI64, stride_482924)(analysisctx482026* c, tnode224816* n);
N_NIMCALL(void, checkargs_484951)(analysisctx482026* a, tnode224816* n);
N_NIMCALL(tnode224816*, newnodei_225138)(NU8 kind, tlineinfo194539 info);
N_NIMCALL(tsym224846*, newsym_225074)(NU8 symkind, tident199021* name, tsym224846* owner, tlineinfo194539 info);
N_NIMCALL(tident199021*, getident_199472)(NimStringDesc* identifier);
N_NIMCALL(tsym224846*, getcompilerproc_281036)(NimStringDesc* name);
N_NIMCALL(void, addvar_423053)(tnode224816* father, tnode224816* v);
N_NIMCALL(tnode224816*, genaddrof_424872)(tnode224816* n);
N_NIMCALL(void, generatealiaschecks_484962)(analysisctx482026* a, tnode224816* result);
N_NIMCALL(void, add_225498)(tnode224816* father, tnode224816* son);
N_NIMCALL(tnode224816*, callcodegenproc_424906)(NimStringDesc* name, tnode224816* arg1, tnode224816* arg2, tnode224816* arg3);
N_NIMCALL(tnode224816*, transformspawn_484729)(tsym224846* owner, tnode224816* n, tnode224816* barrier);
N_NIMCALL(tnode224816*, transformslices_484615)(tnode224816* n);
N_NIMCALL(tnode224816*, copynode_225323)(tnode224816* src);
N_NIMCALL(NU8, spawnresult_424994)(ttype224852* t, NIM_BOOL inparallel);
N_NIMCALL(tnode224816*, wrapprocforspawn_425897)(tsym224846* owner, tnode224816* spawnexpr, ttype224852* rettype, tnode224816* barrier, tnode224816* dest);
N_NIMCALL(tnode224816*, transformspawnsons_484737)(tsym224846* owner, tnode224816* n, tnode224816* barrier);
STRING_LITERAL(TMP952, "slice", 5);
STRING_LITERAL(TMP3867, "+=", 2);
STRING_LITERAL(TMP3868, "[]", 2);
STRING_LITERAL(TMP3869, "invalid usage of counter after increment", 40);
STRING_LITERAL(TMP3874, "cannot prove: ", 14);
STRING_LITERAL(TMP3875, " <= ", 4);
STRING_LITERAL(TMP3876, "can prove: ", 11);
STRING_LITERAL(TMP3877, " > ", 3);
STRING_LITERAL(TMP3878, "[]=", 3);
STRING_LITERAL(TMP3879, "invalid control flow for \'parallel\'", 35);
STRING_LITERAL(TMP3880, "slot already has a lower bound", 30);
STRING_LITERAL(TMP3881, "\'parallel\' section without \'spawn\'", 34);
STRING_LITERAL(TMP3882, "cannot prove: $# > $#; required for ($#)..($#) disjoint from ($"
"#)..($#)", 71);
STRING_LITERAL(TMP3883, "($#)..($#) not disjoint from ($#)..($#)", 39);
STRING_LITERAL(TMP3884, "cannot prove ($#)..($#) disjoint from ($#)..($#)", 48);
STRING_LITERAL(TMP3885, "barrier", 7);
STRING_LITERAL(TMP3886, "Barrier", 7);
STRING_LITERAL(TMP3887, "openBarrier", 11);
STRING_LITERAL(TMP3888, "invalid context for \'spawn\'", 27);
STRING_LITERAL(TMP3889, "closeBarrier", 12);
tsym224846* opslice_482055;
extern tgcheap47016 gch_47044;
TNimType NTI482024; /* MonotonicVar */
extern TNimType NTI224814; /* PSym */
extern TNimType NTI224808; /* PNode */
TNimType NTI482022; /* TDirection */
extern TNimType NTI138; /* bool */
TNimType NTI482036; /* seq[MonotonicVar] */
TNimType NTI482039; /* tuple[x: PNode, a: PNode, b: PNode, spawnId: int, inLoop: bool] */
extern TNimType NTI108; /* int */
TNimType NTI482038; /* seq[tuple[x: PNode, a: PNode, b: PNode, spawnId: int, inLoop: bool]] */
extern TNimType NTI224818; /* TSymSeq */
extern TNimType NTI224810; /* TNodeSeq */
extern tnode224816* emptynode_225738;

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

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

static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src) {
	{
		tcell44935* c;
		if (!!((src == NIM_NIL))) goto LA3;
		c = usrtocell_48646(src);
		(*c).Refcount += 8;
	}
	LA3: ;
	{
		tcell44935* c;
		if (!!(((*dest) == NIM_NIL))) goto LA7;
		c = usrtocell_48646((*dest));
		{
			(*c).Refcount -= 8;
			if (!((NU64)((*c).Refcount) < (NU64)(8))) goto LA11;
			rtladdzct_50204(c);
		}
		LA11: ;
	}
	LA7: ;
	(*dest) = src;
}
N_NIMCALL(void, TMP3864)(void* p, NI op) {
	TY482036* a;
	NI LOC1;
	a = (TY482036*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1].V, op);
	nimGCvisit((void*)a->data[LOC1].Alias, op);
	nimGCvisit((void*)a->data[LOC1].Lower, op);
	nimGCvisit((void*)a->data[LOC1].Upper, op);
	nimGCvisit((void*)a->data[LOC1].Stride, op);
	}
}
N_NIMCALL(void, TMP3866)(void* p, NI op) {
	TY482038* a;
	NI LOC1;
	a = (TY482038*)p;
	LOC1 = 0;
	for (LOC1 = 0; LOC1 < a->Sup.len; LOC1++) {
	nimGCvisit((void*)a->data[LOC1].Field0, op);
	nimGCvisit((void*)a->data[LOC1].Field1, op);
	nimGCvisit((void*)a->data[LOC1].Field2, op);
	}
}

N_NIMCALL(void, initanalysisctx_482059)(analysisctx482026* Result) {
	unsureAsgnRef((void**) (&(*Result).Locals), (TY482036*) newSeq((&NTI482036), 0));
	unsureAsgnRef((void**) (&(*Result).Slices), (TY482038*) newSeq((&NTI482038), 0));
	unsureAsgnRef((void**) (&(*Result).Args), (tsymseq224818*) newSeq((&NTI224818), 0));
	unsureAsgnRef((void**) (&(*Result).Guards), (tnodeseq224810*) newSeq((&NTI224810), 0));
}

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

static N_INLINE(tnode224816*, lastson_225261)(tnode224816* n) {
	tnode224816* result;
	NI LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = sonslen_225249(n);
	result = (*n).kindU.S6.Sons->data[(NI64)(LOC1 - 1)];
	return result;
}

N_NIMCALL(NIM_BOOL, issingleassignable_482416)(tnode224816* n) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	tsym224846* s;
	NIM_BOOL LOC3;
	result = 0;
	LOC1 = 0;
	LOC1 = ((*n).Kind == ((NU8) 3));
	if (!(LOC1)) goto LA2;
	s = (*n).kindU.S4.Sym;
	LOC3 = 0;
	LOC3 = ((2097696 &(1<<(((*s).Kind)&31)))!=0);
	if (!(LOC3)) goto LA4;
	LOC3 = ((32776 & (*s).Flags) == 0);
	LA4: ;
	LOC1 = LOC3;
	LA2: ;
	result = LOC1;
	return result;
}

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

N_NIMCALL(NIM_BOOL, islocal_482501)(tnode224816* n) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	tsym224846* s;
	NIM_BOOL LOC3;
	result = 0;
	LOC1 = 0;
	LOC1 = ((*n).Kind == ((NU8) 3));
	if (!(LOC1)) goto LA2;
	s = (*n).kindU.S4.Sym;
	LOC3 = 0;
	LOC3 = ((2100000 &(1<<(((*s).Kind)&31)))!=0);
	if (!(LOC3)) goto LA4;
	LOC3 = ((32776 & (*s).Flags) == 0);
	LA4: ;
	LOC1 = LOC3;
	LA2: ;
	result = LOC1;
	return result;
}

N_NIMCALL(NI, lookupslot_482148)(analysisctx482026* c, tsym224846* s) {
	NI result;
	result = 0;
	{
		NI i_482185;
		NI HEX3Atmp_482219;
		NI res_482222;
		i_482185 = 0;
		HEX3Atmp_482219 = 0;
		HEX3Atmp_482219 = ((*c).Locals->Sup.len - 1);
		res_482222 = 0;
		{
			while (1) {
				if (!(res_482222 <= HEX3Atmp_482219)) goto LA3;
				i_482185 = res_482222;
				{
					NIM_BOOL LOC6;
					LOC6 = 0;
					LOC6 = ((*c).Locals->data[i_482185].V == s);
					if (LOC6) goto LA7;
					LOC6 = ((*c).Locals->data[i_482185].Alias == s);
					LA7: ;
					if (!LOC6) goto LA8;
					result = i_482185;
					goto BeforeRet;
				}
				LA8: ;
				res_482222 += 1;
			} LA3: ;
		}
	}
	result = -1;
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

N_NIMCALL(monotonicvar482024*, getslot_482239)(analysisctx482026* c, tsym224846* v) {
	monotonicvar482024* result;
	NI s;
	NI l;
	result = 0;
	s = lookupslot_482148((&(*c)), v);
	{
		if (!(0 <= s)) goto LA3;
		result = (&(*c).Locals->data[s]);
		goto BeforeRet;
	}
	LA3: ;
	l = (*c).Locals->Sup.len;
	(*c).Locals = (TY482036*) setLengthSeq(&((*c).Locals)->Sup, sizeof(monotonicvar482024), (NI64)(l + 1));
	asgnRefNoCycle((void**) (&(*c).Locals->data[l].V), v);
	result = (&(*c).Locals->data[l]);
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

static N_INLINE(NI, safelen_225424)(tnode224816* n) {
	NI result;
	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = ((*n).Kind >= ((NU8) 0) && (*n).Kind <= ((NU8) 23));
		if (LOC3) goto LA4;
		LOC3 = (*n).kindU.S6.Sons == 0;
		LA4: ;
		if (!LOC3) goto LA5;
		result = 0;
	}
	goto LA1;
	LA5: ;
	{
		result = (*n).kindU.S6.Sons->Sup.len;
	}
	LA1: ;
	return result;
}

N_NIMCALL(void, gatherargs_482283)(analysisctx482026* c, tnode224816* n) {
	{
		NI i_482309;
		NI HEX3Atmp_482384;
		NI LOC2;
		NI res_482387;
		i_482309 = 0;
		HEX3Atmp_482384 = 0;
		LOC2 = 0;
		LOC2 = safelen_225424(n);
		HEX3Atmp_482384 = (LOC2 - 1);
		res_482387 = 0;
		{
			while (1) {
				tsym224846* root;
				tnode224816* LOC5;
				tnode224816* LOC18;
				if (!(res_482387 <= HEX3Atmp_482384)) goto LA4;
				i_482309 = res_482387;
				LOC5 = 0;
				LOC5 = HEX5BHEX5D_225698(n, i_482309);
				root = getroot_425533(LOC5);
				{
					if (!!((root == NIM_NIL))) goto LA8;
					{
						{
							tsym224846* r_482341;
							tsymseq224818* HEX3Atmp_482378;
							NI i_482381;
							NI l_482383;
							r_482341 = 0;
							HEX3Atmp_482378 = 0;
							HEX3Atmp_482378 = (*c).Args;
							i_482381 = 0;
							l_482383 = HEX3Atmp_482378->Sup.len;
							{
								while (1) {
									if (!(i_482381 < l_482383)) goto LA13;
									r_482341 = HEX3Atmp_482378->data[i_482381];
									{
										if (!(r_482341 == root)) goto LA16;
										goto LA10;
									}
									LA16: ;
									i_482381 += 1;
								} LA13: ;
							}
						}
						(*c).Args = (tsymseq224818*) incrSeq(&((*c).Args)->Sup, sizeof(tsym224846*));
						asgnRefNoCycle((void**) (&(*c).Args->data[(*c).Args->Sup.len-1]), root);
					} LA10: ;
				}
				LA8: ;
				LOC18 = 0;
				LOC18 = HEX5BHEX5D_225698(n, i_482309);
				gatherargs_482283(c, LOC18);
				res_482387 += 1;
			} LA4: ;
		}
	}
}

N_NIMCALL(void, analysesons_483517)(analysisctx482026* c, tnode224816* n) {
	{
		NI i_483543;
		NI HEX3Atmp_483545;
		NI LOC2;
		NI res_483548;
		i_483543 = 0;
		HEX3Atmp_483545 = 0;
		LOC2 = 0;
		LOC2 = safelen_225424(n);
		HEX3Atmp_483545 = (LOC2 - 1);
		res_483548 = 0;
		{
			while (1) {
				tnode224816* LOC5;
				if (!(res_483548 <= HEX3Atmp_483545)) goto LA4;
				i_483543 = res_483548;
				LOC5 = 0;
				LOC5 = HEX5BHEX5D_225698(n, i_483543);
				analyse_483509(c, LOC5);
				res_483548 += 1;
			} LA4: ;
		}
	}
}

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)), (NI64)((*a).Sup.len * 1));
	LOC11 = (LOC13 == ((NI32) 0));
	LA12: ;
	result = LOC11;
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, fromsystem_483616)(tsym224846* op) {
	NIM_BOOL result;
	tsym224846* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = getmodule_234243(op);
	result = (((*LOC1).Flags &(1<<((((NU8) 13))&31)))!=0);
	return result;
}

N_NIMCALL(tnode224816*, min_483565)(tnode224816* a, tnode224816* b) {
	tnode224816* result;
	result = 0;
	{
		if (!a == 0) goto LA3;
		result = b;
	}
	goto LA1;
	LA3: ;
	{
		if (!((*a).kindU.S1.Intval < (*b).kindU.S1.Intval)) goto LA6;
		result = a;
	}
	goto LA1;
	LA6: ;
	{
		result = b;
	}
	LA1: ;
	return result;
}

N_NIMCALL(void, checklocal_482586)(analysisctx482026* c, tnode224816* n) {
	{
		NIM_BOOL LOC3;
		NI s;
		LOC3 = 0;
		LOC3 = islocal_482501(n);
		if (!LOC3) goto LA4;
		s = lookupslot_482148(c, (*n).kindU.S4.Sym);
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = (0 <= s);
			if (!(LOC8)) goto LA9;
			LOC8 = !(((*c).Locals->data[s].Stride == NIM_NIL));
			LA9: ;
			if (!LOC8) goto LA10;
			localerror_196966((*n).Info, ((NimStringDesc*) &TMP3869));
		}
		LA10: ;
	}
	goto LA1;
	LA4: ;
	{
		{
			NI i_482643;
			NI HEX3Atmp_482659;
			NI LOC14;
			NI res_482662;
			i_482643 = 0;
			HEX3Atmp_482659 = 0;
			LOC14 = 0;
			LOC14 = safelen_225424(n);
			HEX3Atmp_482659 = (LOC14 - 1);
			res_482662 = 0;
			{
				while (1) {
					if (!(res_482662 <= HEX3Atmp_482659)) goto LA16;
					i_482643 = res_482662;
					checklocal_482586(c, (*n).kindU.S6.Sons->data[i_482643]);
					res_482662 += 1;
				} LA16: ;
			}
		}
	}
	LA1: ;
}

N_NIMCALL(void, addlowerboundasfacts_482708)(analysisctx482026* c) {
	{
		monotonicvar482024 v_482811;
		TY482036* HEX3Atmp_482814;
		NI i_482817;
		NI l_482819;
		memset((void*)(&v_482811), 0, sizeof(v_482811));
		HEX3Atmp_482814 = 0;
		HEX3Atmp_482814 = (*c).Locals;
		i_482817 = 0;
		l_482819 = HEX3Atmp_482814->Sup.len;
		{
			while (1) {
				if (!(i_482817 < l_482819)) goto LA3;
				memcpy((void*)(&v_482811), (NIM_CONST void*)(&HEX3Atmp_482814->data[i_482817]), sizeof(v_482811));
				{
					tnode224816* LOC8;
					if (!!(v_482811.Blacklisted)) goto LA6;
					LOC8 = 0;
					LOC8 = newsymnode_225132(v_482811.V);
					addfactle_373018((&(*c).Guards), v_482811.Lower, LOC8);
				}
				LA6: ;
				i_482817 += 1;
			} LA3: ;
		}
	}
}

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

N_NIMCALL(void, checkle_482686)(analysisctx482026* c, tnode224816* a, tnode224816* b) {
	NU8 LOC1;
	LOC1 = 0;
	LOC1 = provele_372995((*c).Guards, a, b);
	switch (LOC1) {
	case ((NU8) 0):
	{
		NimStringDesc* LOC3;
		NimStringDesc* LOC4;
		NimStringDesc* LOC5;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = rendertree_249058(a, 0);
		LOC5 = 0;
		LOC5 = rendertree_249058(b, 0);
		LOC3 = rawNewString(LOC4->Sup.len + LOC5->Sup.len + 18);
appendString(LOC3, ((NimStringDesc*) &TMP3874));
appendString(LOC3, LOC4);
appendString(LOC3, ((NimStringDesc*) &TMP3875));
appendString(LOC3, LOC5);
		localerror_196966((*a).Info, LOC3);
	}
	break;
	case ((NU8) 2):
	{
	}
	break;
	case ((NU8) 1):
	{
		NimStringDesc* LOC8;
		NimStringDesc* LOC9;
		NimStringDesc* LOC10;
		LOC8 = 0;
		LOC9 = 0;
		LOC9 = rendertree_249058(a, 0);
		LOC10 = 0;
		LOC10 = rendertree_249058(b, 0);
		LOC8 = rawNewString(LOC9->Sup.len + LOC10->Sup.len + 14);
appendString(LOC8, ((NimStringDesc*) &TMP3876));
appendString(LOC8, LOC9);
appendString(LOC8, ((NimStringDesc*) &TMP3877));
appendString(LOC8, LOC10);
		localerror_196966((*a).Info, LOC8);
	}
	break;
	}
}

N_NIMCALL(void, checkbounds_482697)(analysisctx482026* c, tnode224816* arr, tnode224816* idx) {
	tnode224816* LOC1;
	tnode224816* LOC2;
	LOC1 = 0;
	LOC1 = lowbound_368448(arr);
	checkle_482686(c, LOC1, idx);
	LOC2 = 0;
	LOC2 = highbound_368458(arr);
	checkle_482686(c, idx, LOC2);
}

N_NIMCALL(void, addslice_482835)(analysisctx482026* c, tnode224816* n, tnode224816* x, tnode224816* le_482841, tnode224816* ri_482842) {
	tnode224816* le;
	tnode224816* ri;
	NI oldstate;
	TY482039 LOC1;
	checklocal_482586((&(*c)), n);
	le = canon_368513(le_482841);
	ri = canon_368513(ri_482842);
	oldstate = (*c).Guards->Sup.len;
	addlowerboundasfacts_482708(c);
	checkbounds_482697((&(*c)), x, le);
	checkbounds_482697((&(*c)), x, ri);
	(*c).Guards = (tnodeseq224810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode224816*), oldstate);
	memset((void*)(&LOC1), 0, sizeof(LOC1));
	LOC1.Field0 = x;
	LOC1.Field1 = le;
	LOC1.Field2 = ri;
	LOC1.Field3 = (*c).Currentspawnid;
	LOC1.Field4 = (0 < (*c).Inloop);
	(*c).Slices = (TY482038*) incrSeq(&((*c).Slices)->Sup, sizeof(TY482039));
	genericAssign((void*)(&(*c).Slices->data[(*c).Slices->Sup.len-1]), (void*)(&LOC1), (&NTI482039));
}

N_NIMCALL(void, analysecall_483647)(analysisctx482026* c, tnode224816* n, tsym224846* op) {
	{
		NI oldspawnid;
		tnode224816* LOC5;
		if (!((*op).Magic == ((NU16) 213))) goto LA3;
		(*c).Spawns += 1;
		oldspawnid = (*c).Currentspawnid;
		(*c).Currentspawnid = (*c).Spawns;
		LOC5 = 0;
		LOC5 = HEX5BHEX5D_225698(n, 1);
		gatherargs_482283(c, LOC5);
		analysesons_483517(c, n);
		(*c).Currentspawnid = oldspawnid;
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC7;
		NIM_BOOL LOC9;
		LOC7 = 0;
		LOC7 = ((*op).Magic == ((NU16) 21));
		if (LOC7) goto LA8;
		LOC9 = 0;
		LOC9 = eqStrings((*(*op).Name).S, ((NimStringDesc*) &TMP3867));
		if (!(LOC9)) goto LA10;
		LOC9 = fromsystem_483616(op);
		LA10: ;
		LOC7 = LOC9;
		LA8: ;
		if (!LOC7) goto LA11;
		{
			tnode224816* LOC15;
			NIM_BOOL LOC16;
			tnode224816* incr;
			tnode224816* LOC19;
			LOC15 = 0;
			LOC15 = HEX5BHEX5D_225698(n, 1);
			LOC16 = 0;
			LOC16 = islocal_482501(LOC15);
			if (!LOC16) goto LA17;
			LOC19 = 0;
			LOC19 = HEX5BHEX5D_225698(n, 2);
			incr = skipconv_272732(LOC19);
			{
				NIM_BOOL LOC22;
				monotonicvar482024* slot;
				tnode224816* LOC26;
				LOC22 = 0;
				LOC22 = ((*incr).Kind >= ((NU8) 5) && (*incr).Kind <= ((NU8) 14));
				if (!(LOC22)) goto LA23;
				LOC22 = (IL64(0) < (*incr).kindU.S1.Intval);
				LA23: ;
				if (!LOC22) goto LA24;
				LOC26 = 0;
				LOC26 = HEX5BHEX5D_225698(n, 1);
				slot = getslot_482239(c, (*LOC26).kindU.S4.Sym);
				unsureAsgnRef((void**) (&(*slot).Stride), min_483565((*slot).Stride, incr));
			}
			LA24: ;
		}
		LA17: ;
		analysesons_483517(c, n);
	}
	goto LA1;
	LA11: ;
	{
		NIM_BOOL LOC28;
		tnode224816* LOC32;
		tnode224816* LOC33;
		tnode224816* LOC34;
		tnode224816* LOC35;
		tnode224816* LOC36;
		LOC28 = 0;
		LOC28 = eqStrings((*(*op).Name).S, ((NimStringDesc*) &TMP3868));
		if (!(LOC28)) goto LA29;
		LOC28 = fromsystem_483616(op);
		LA29: ;
		if (!LOC28) goto LA30;
		LOC32 = 0;
		LOC32 = HEX5BHEX5D_225698(n, 1);
		LOC33 = 0;
		LOC33 = HEX5BHEX5D_225698(n, 2);
		LOC34 = 0;
		LOC34 = HEX5BHEX5D_225698(LOC33, 1);
		LOC35 = 0;
		LOC35 = HEX5BHEX5D_225698(n, 2);
		LOC36 = 0;
		LOC36 = HEX5BHEX5D_225698(LOC35, 2);
		addslice_482835(c, n, LOC32, LOC34, LOC36);
		analysesons_483517(c, n);
	}
	goto LA1;
	LA30: ;
	{
		NIM_BOOL LOC38;
		tnode224816* LOC42;
		tnode224816* LOC43;
		tnode224816* LOC44;
		tnode224816* LOC45;
		tnode224816* LOC46;
		LOC38 = 0;
		LOC38 = eqStrings((*(*op).Name).S, ((NimStringDesc*) &TMP3878));
		if (!(LOC38)) goto LA39;
		LOC38 = fromsystem_483616(op);
		LA39: ;
		if (!LOC38) goto LA40;
		LOC42 = 0;
		LOC42 = HEX5BHEX5D_225698(n, 1);
		LOC43 = 0;
		LOC43 = HEX5BHEX5D_225698(n, 2);
		LOC44 = 0;
		LOC44 = HEX5BHEX5D_225698(LOC43, 1);
		LOC45 = 0;
		LOC45 = HEX5BHEX5D_225698(n, 2);
		LOC46 = 0;
		LOC46 = HEX5BHEX5D_225698(LOC45, 2);
		addslice_482835(c, n, LOC42, LOC44, LOC46);
		analysesons_483517(c, n);
	}
	goto LA1;
	LA40: ;
	{
		analysesons_483517(c, n);
	}
	LA1: ;
}

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

N_NIMCALL(void, analysecase_483738)(analysisctx482026* c, tnode224816* n) {
	NI oldfacts;
	analyse_483509(c, (*n).kindU.S6.Sons->data[0]);
	oldfacts = (*c).Guards->Sup.len;
	{
		NI i_483790;
		NI HEX3Atmp_483882;
		NI LOC2;
		NI res_483885;
		i_483790 = 0;
		HEX3Atmp_483882 = 0;
		LOC2 = 0;
		LOC2 = len_225364(n);
		HEX3Atmp_483882 = (LOC2 - 1);
		res_483885 = 1;
		{
			while (1) {
				tnode224816* branch;
				if (!(res_483885 <= HEX3Atmp_483882)) goto LA4;
				i_483790 = res_483885;
				branch = (*n).kindU.S6.Sons->data[i_483790];
				(*c).Guards = (tnodeseq224810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode224816*), oldfacts);
				addcasebranchfacts_373755((&(*c).Guards), n, i_483790);
				{
					NI i_483844;
					NI HEX3Atmp_483877;
					NI LOC6;
					NI res_483880;
					i_483844 = 0;
					HEX3Atmp_483877 = 0;
					LOC6 = 0;
					LOC6 = len_225364(branch);
					HEX3Atmp_483877 = (LOC6 - 1);
					res_483880 = 0;
					{
						while (1) {
							if (!(res_483880 <= HEX3Atmp_483877)) goto LA8;
							i_483844 = res_483880;
							analyse_483509(c, (*branch).kindU.S6.Sons->data[i_483844]);
							res_483880 += 1;
						} LA8: ;
					}
				}
				res_483885 += 1;
			} LA4: ;
		}
	}
	(*c).Guards = (tnodeseq224810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode224816*), oldfacts);
}

N_NIMCALL(void, analyseif_483911)(analysisctx482026* c, tnode224816* n) {
	NI oldfacts;
	tnode224816* LOC1;
	analyse_483509(c, (*(*n).kindU.S6.Sons->data[0]).kindU.S6.Sons->data[0]);
	oldfacts = (*c).Guards->Sup.len;
	LOC1 = 0;
	LOC1 = canon_368513((*(*n).kindU.S6.Sons->data[0]).kindU.S6.Sons->data[0]);
	addfact_369349((&(*c).Guards), LOC1);
	analyse_483509(c, (*(*n).kindU.S6.Sons->data[0]).kindU.S6.Sons->data[1]);
	{
		NI i_484034;
		NI HEX3Atmp_484187;
		NI LOC3;
		NI res_484190;
		i_484034 = 0;
		HEX3Atmp_484187 = 0;
		LOC3 = 0;
		LOC3 = len_225364(n);
		HEX3Atmp_484187 = (LOC3 - 1);
		res_484190 = 1;
		{
			while (1) {
				tnode224816* branch;
				if (!(res_484190 <= HEX3Atmp_484187)) goto LA5;
				i_484034 = res_484190;
				branch = (*n).kindU.S6.Sons->data[i_484034];
				(*c).Guards = (tnodeseq224810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode224816*), oldfacts);
				{
					NI j_484076;
					NI HEX3Atmp_484176;
					NI res_484179;
					j_484076 = 0;
					HEX3Atmp_484176 = 0;
					HEX3Atmp_484176 = (NI64)(i_484034 - 1);
					res_484179 = 0;
					{
						while (1) {
							tnode224816* LOC9;
							if (!(res_484179 <= HEX3Atmp_484176)) goto LA8;
							j_484076 = res_484179;
							LOC9 = 0;
							LOC9 = canon_368513((*(*n).kindU.S6.Sons->data[j_484076]).kindU.S6.Sons->data[0]);
							addfactneg_369396((&(*c).Guards), LOC9);
							res_484179 += 1;
						} LA8: ;
					}
				}
				{
					NI LOC12;
					tnode224816* LOC15;
					LOC12 = 0;
					LOC12 = len_225364(branch);
					if (!(1 < LOC12)) goto LA13;
					LOC15 = 0;
					LOC15 = canon_368513((*branch).kindU.S6.Sons->data[0]);
					addfact_369349((&(*c).Guards), LOC15);
				}
				LA13: ;
				{
					NI i_484143;
					NI HEX3Atmp_484182;
					NI LOC17;
					NI res_484185;
					i_484143 = 0;
					HEX3Atmp_484182 = 0;
					LOC17 = 0;
					LOC17 = len_225364(branch);
					HEX3Atmp_484182 = (LOC17 - 1);
					res_484185 = 0;
					{
						while (1) {
							if (!(res_484185 <= HEX3Atmp_484182)) goto LA19;
							i_484143 = res_484185;
							analyse_483509(c, (*branch).kindU.S6.Sons->data[i_484143]);
							res_484185 += 1;
						} LA19: ;
					}
				}
				res_484190 += 1;
			} LA5: ;
		}
	}
	(*c).Guards = (tnodeseq224810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode224816*), oldfacts);
}

N_NIMCALL(void, analyse_483509)(analysisctx482026* c, tnode224816* n) {
	switch ((*n).Kind) {
	case ((NU8) 73):
	case ((NU8) 74):
	{
		tnode224816* LOC18;
		tnode224816* value;
		tnode224816* LOC28;
		tnode224816* LOC29;
		{
			NIM_BOOL LOC4;
			tnode224816* LOC5;
			tnode224816* LOC7;
			monotonicvar482024* slot;
			tnode224816* LOC10;
			tnode224816* LOC11;
			LOC4 = 0;
			LOC5 = 0;
			LOC5 = HEX5BHEX5D_225698(n, 0);
			LOC4 = issingleassignable_482416(LOC5);
			if (!(LOC4)) goto LA6;
			LOC7 = 0;
			LOC7 = HEX5BHEX5D_225698(n, 1);
			LOC4 = islocal_482501(LOC7);
			LA6: ;
			if (!LOC4) goto LA8;
			LOC10 = 0;
			LOC10 = HEX5BHEX5D_225698(n, 1);
			slot = getslot_482239(c, (*LOC10).kindU.S4.Sym);
			LOC11 = 0;
			LOC11 = HEX5BHEX5D_225698(n, 0);
			unsureAsgnRef((void**) (&(*slot).Alias), (*LOC11).kindU.S4.Sym);
		}
		goto LA2;
		LA8: ;
		{
			tnode224816* LOC13;
			NIM_BOOL LOC14;
			monotonicvar482024* slot;
			tnode224816* LOC17;
			LOC13 = 0;
			LOC13 = HEX5BHEX5D_225698(n, 0);
			LOC14 = 0;
			LOC14 = islocal_482501(LOC13);
			if (!LOC14) goto LA15;
			LOC17 = 0;
			LOC17 = HEX5BHEX5D_225698(n, 0);
			slot = getslot_482239(c, (*LOC17).kindU.S4.Sym);
			(*slot).Blacklisted = NIM_TRUE;
		}
		goto LA2;
		LA15: ;
		LA2: ;
		LOC18 = 0;
		LOC18 = HEX5BHEX5D_225698(n, 0);
		invalidatefacts_369774((&(*c).Guards), LOC18);
		value = HEX5BHEX5D_225698(n, 1);
		{
			NU16 LOC21;
			NI oldspawnid;
			tnode224816* LOC24;
			tnode224816* LOC25;
			tnode224816* LOC26;
			LOC21 = 0;
			LOC21 = getmagic_260845(value);
			if (!(LOC21 == ((NU16) 213))) goto LA22;
			(*c).Spawns += 1;
			oldspawnid = (*c).Currentspawnid;
			(*c).Currentspawnid = (*c).Spawns;
			LOC24 = 0;
			LOC24 = HEX5BHEX5D_225698(value, 1);
			gatherargs_482283(c, LOC24);
			LOC25 = 0;
			LOC25 = HEX5BHEX5D_225698(value, 1);
			analysesons_483517(c, LOC25);
			LOC26 = 0;
			LOC26 = HEX5BHEX5D_225698(n, 0);
			analyse_483509(c, LOC26);
			(*c).Currentspawnid = oldspawnid;
		}
		goto LA19;
		LA22: ;
		{
			analysesons_483517(c, n);
		}
		LA19: ;
		LOC28 = 0;
		LOC28 = HEX5BHEX5D_225698(n, 0);
		LOC29 = 0;
		LOC29 = HEX5BHEX5D_225698(n, 1);
		addasgnfact_373618((&(*c).Guards), LOC28, LOC29);
	}
	break;
	case ((NU8) 27):
	case ((NU8) 29):
	case ((NU8) 30):
	case ((NU8) 31):
	case ((NU8) 26):
	case ((NU8) 28):
	case ((NU8) 32):
	{
		{
			tnode224816* LOC33;
			tnode224816* LOC36;
			LOC33 = 0;
			LOC33 = HEX5BHEX5D_225698(n, 0);
			if (!((*LOC33).Kind == ((NU8) 3))) goto LA34;
			LOC36 = 0;
			LOC36 = HEX5BHEX5D_225698(n, 0);
			analysecall_483647(c, n, (*LOC36).kindU.S4.Sym);
		}
		goto LA31;
		LA34: ;
		{
			analysesons_483517(c, n);
		}
		LA31: ;
	}
	break;
	case ((NU8) 42):
	{
		tnode224816* LOC39;
		tnode224816* LOC40;
		tnode224816* LOC41;
		LOC39 = 0;
		LOC39 = HEX5BHEX5D_225698(n, 0);
		LOC40 = 0;
		LOC40 = HEX5BHEX5D_225698(n, 1);
		LOC41 = 0;
		LOC41 = HEX5BHEX5D_225698(n, 1);
		addslice_482835(c, n, LOC39, LOC40, LOC41);
		analysesons_483517(c, n);
	}
	break;
	case ((NU8) 109):
	case ((NU8) 108):
	case ((NU8) 106):
	{
		localerror_196966((*n).Info, ((NimStringDesc*) &TMP3879));
	}
	break;
	case ((NU8) 99):
	case ((NU8) 100):
	{
		{
			tnode224816* it_484322;
			it_484322 = 0;
			{
				NI i_484583;
				NI HEX3Atmp_484585;
				NI LOC46;
				NI res_484587;
				i_484583 = 0;
				HEX3Atmp_484585 = 0;
				LOC46 = 0;
				LOC46 = len_225364(n);
				HEX3Atmp_484585 = (LOC46 - 1);
				res_484587 = 0;
				{
					while (1) {
						tnode224816* value;
						NIM_BOOL isspawned;
						NU16 LOC49;
						if (!(res_484587 <= HEX3Atmp_484585)) goto LA48;
						i_484583 = res_484587;
						it_484322 = (*n).kindU.S6.Sons->data[i_484583];
						value = lastson_225261(it_484322);
						LOC49 = 0;
						LOC49 = getmagic_260845(value);
						isspawned = (LOC49 == ((NU16) 213));
						{
							NI oldspawnid;
							tnode224816* LOC54;
							tnode224816* LOC55;
							if (!isspawned) goto LA52;
							(*c).Spawns += 1;
							oldspawnid = (*c).Currentspawnid;
							(*c).Currentspawnid = (*c).Spawns;
							LOC54 = 0;
							LOC54 = HEX5BHEX5D_225698(value, 1);
							gatherargs_482283(c, LOC54);
							LOC55 = 0;
							LOC55 = HEX5BHEX5D_225698(value, 1);
							analysesons_483517(c, LOC55);
							(*c).Currentspawnid = oldspawnid;
						}
						LA52: ;
						{
							if (!!(((*value).Kind == ((NU8) 1)))) goto LA58;
							{
								NI j_484366;
								NI HEX3Atmp_484575;
								NI LOC61;
								NI res_484578;
								j_484366 = 0;
								HEX3Atmp_484575 = 0;
								LOC61 = 0;
								LOC61 = len_225364(it_484322);
								HEX3Atmp_484575 = (NI64)(LOC61 - 3);
								res_484578 = 0;
								{
									while (1) {
										if (!(res_484578 <= HEX3Atmp_484575)) goto LA63;
										j_484366 = res_484578;
										{
											tnode224816* LOC66;
											NIM_BOOL LOC67;
											monotonicvar482024* slot;
											tnode224816* LOC70;
											LOC66 = 0;
											LOC66 = HEX5BHEX5D_225698(it_484322, j_484366);
											LOC67 = 0;
											LOC67 = islocal_482501(LOC66);
											if (!LOC67) goto LA68;
											LOC70 = 0;
											LOC70 = HEX5BHEX5D_225698(it_484322, j_484366);
											slot = getslot_482239(c, (*LOC70).kindU.S4.Sym);
											{
												if (!(*slot).Lower == 0) goto LA73;
												unsureAsgnRef((void**) (&(*slot).Lower), value);
											}
											goto LA71;
											LA73: ;
											{
												internalerror_196987((*it_484322).Info, ((NimStringDesc*) &TMP3880));
											}
											LA71: ;
										}
										LA68: ;
										res_484578 += 1;
									} LA63: ;
								}
							}
							{
								if (!!(isspawned)) goto LA78;
								analyse_483509(c, value);
							}
							LA78: ;
						}
						LA58: ;
						res_484587 += 1;
					} LA48: ;
				}
			}
		}
	}
	break;
	case ((NU8) 97):
	{
		analysecase_483738(c, n);
	}
	break;
	case ((NU8) 92):
	case ((NU8) 48):
	{
		analyseif_483911(c, n);
	}
	break;
	case ((NU8) 96):
	{
		analyse_483509(c, (*n).kindU.S6.Sons->data[0]);
		(*c).Inloop += 1;
		{
			NIM_BOOL LOC85;
			LOC85 = 0;
			LOC85 = istrue_380730((*n).kindU.S6.Sons->data[0]);
			if (!LOC85) goto LA86;
			analysesons_483517(c, (*n).kindU.S6.Sons->data[1]);
		}
		goto LA83;
		LA86: ;
		{
			NI oldstate;
			NI oldfacts;
			tnode224816* LOC89;
			oldstate = (*c).Locals->Sup.len;
			oldfacts = (*c).Guards->Sup.len;
			LOC89 = 0;
			LOC89 = canon_368513((*n).kindU.S6.Sons->data[0]);
			addfact_369349((&(*c).Guards), LOC89);
			analyse_483509(c, (*n).kindU.S6.Sons->data[1]);
			(*c).Locals = (TY482036*) setLengthSeq(&((*c).Locals)->Sup, sizeof(monotonicvar482024), oldstate);
			(*c).Guards = (tnodeseq224810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode224816*), oldfacts);
			{
				NIM_BOOL LOC92;
				tnode224816* LOC95;
				LOC92 = 0;
				LOC92 = hassubnodewith_225308((*n).kindU.S6.Sons->data[1], ((NU8) 110));
				if (!!(LOC92)) goto LA93;
				LOC95 = 0;
				LOC95 = canon_368513((*n).kindU.S6.Sons->data[0]);
				addfactneg_369396((&(*c).Guards), LOC95);
			}
			LA93: ;
		}
		LA83: ;
		(*c).Inloop -= 1;
	}
	break;
	case ((NU8) 98):
	case ((NU8) 79):
	case ((NU8) 81):
	case ((NU8) 80):
	case ((NU8) 84):
	case ((NU8) 82):
	case ((NU8) 83):
	case ((NU8) 101):
	case ((NU8) 90):
	{
	}
	break;
	default:
	{
		analysesons_483517(c, n);
	}
	break;
	}
}

N_NIMCALL(void, overlap_482899)(tnodeseq224810* m, tnode224816* x, tnode224816* y, tnode224816* c, tnode224816* d) {
	NU8 LOC1;
	LOC1 = 0;
	LOC1 = provele_372995(m, x, d);
	switch (LOC1) {
	case ((NU8) 0):
	{
		TY482908 LOC3;
		NimStringDesc* LOC4;
		memset((void*)LOC3, 0, sizeof(LOC3));
		LOC3[0] = rendertree_249058(x, 0);
		LOC3[1] = rendertree_249058(d, 0);
		LOC3[2] = rendertree_249058(x, 0);
		LOC3[3] = rendertree_249058(y, 0);
		LOC3[4] = rendertree_249058(c, 0);
		LOC3[5] = rendertree_249058(d, 0);
		LOC4 = 0;
		LOC4 = nsuFormatOpenArray(((NimStringDesc*) &TMP3882), LOC3, 6);
		localerror_196966((*x).Info, LOC4);
	}
	break;
	case ((NU8) 2):
	{
		NU8 LOC6;
		LOC6 = 0;
		LOC6 = provele_372995(m, c, y);
		switch (LOC6) {
		case ((NU8) 0):
		{
			TY482908 LOC8;
			NimStringDesc* LOC9;
			memset((void*)LOC8, 0, sizeof(LOC8));
			LOC8[0] = rendertree_249058(c, 0);
			LOC8[1] = rendertree_249058(y, 0);
			LOC8[2] = rendertree_249058(x, 0);
			LOC8[3] = rendertree_249058(y, 0);
			LOC8[4] = rendertree_249058(c, 0);
			LOC8[5] = rendertree_249058(d, 0);
			LOC9 = 0;
			LOC9 = nsuFormatOpenArray(((NimStringDesc*) &TMP3882), LOC8, 6);
			localerror_196966((*x).Info, LOC9);
		}
		break;
		case ((NU8) 2):
		{
			TY196620 LOC11;
			NimStringDesc* LOC12;
			memset((void*)LOC11, 0, sizeof(LOC11));
			LOC11[0] = rendertree_249058(x, 0);
			LOC11[1] = rendertree_249058(y, 0);
			LOC11[2] = rendertree_249058(c, 0);
			LOC11[3] = rendertree_249058(d, 0);
			LOC12 = 0;
			LOC12 = nsuFormatOpenArray(((NimStringDesc*) &TMP3883), LOC11, 4);
			localerror_196966((*x).Info, LOC12);
		}
		break;
		case ((NU8) 1):
		{
		}
		break;
		}
	}
	break;
	case ((NU8) 1):
	{
	}
	break;
	}
}

N_NIMCALL(tnode224816*, substride_483044)(analysisctx482026* c, tnode224816* n) {
	tnode224816* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		NI s;
		LOC3 = 0;
		LOC3 = islocal_482501(n);
		if (!LOC3) goto LA4;
		s = lookupslot_482148(c, (*n).kindU.S4.Sym);
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = (0 <= s);
			if (!(LOC8)) goto LA9;
			LOC8 = !(((*c).Locals->data[s].Stride == NIM_NIL));
			LA9: ;
			if (!LOC8) goto LA10;
			result = HEX2BHEX40_368779(n, (*(*c).Locals->data[s].Stride).kindU.S1.Intval);
		}
		goto LA6;
		LA10: ;
		{
			result = n;
		}
		LA6: ;
	}
	goto LA1;
	LA4: ;
	{
		NI LOC14;
		LOC14 = 0;
		LOC14 = safelen_225424(n);
		if (!(0 < LOC14)) goto LA15;
		result = shallowcopy_230347(n);
		{
			NI i_483118;
			NI HEX3Atmp_483148;
			NI LOC18;
			NI res_483151;
			i_483118 = 0;
			HEX3Atmp_483148 = 0;
			LOC18 = 0;
			LOC18 = len_225364(n);
			HEX3Atmp_483148 = (LOC18 - 1);
			res_483151 = 0;
			{
				while (1) {
					if (!(res_483151 <= HEX3Atmp_483148)) goto LA20;
					i_483118 = res_483151;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.Sons->data[i_483118]), substride_483044(c, (*n).kindU.S6.Sons->data[i_483118]));
					res_483151 += 1;
				} LA20: ;
			}
		}
	}
	goto LA1;
	LA15: ;
	{
		result = n;
	}
	LA1: ;
	return result;
}

N_NIMCALL(NI64, stride_482924)(analysisctx482026* c, tnode224816* n) {
	NI64 result;
	result = 0;
	{
		NIM_BOOL LOC3;
		NI s;
		LOC3 = 0;
		LOC3 = islocal_482501(n);
		if (!LOC3) goto LA4;
		s = lookupslot_482148(c, (*n).kindU.S4.Sym);
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = (0 <= s);
			if (!(LOC8)) goto LA9;
			LOC8 = !(((*c).Locals->data[s].Stride == NIM_NIL));
			LA9: ;
			if (!LOC8) goto LA10;
			result = (*(*c).Locals->data[s].Stride).kindU.S1.Intval;
		}
		LA10: ;
	}
	goto LA1;
	LA4: ;
	{
		{
			NI i_482996;
			NI HEX3Atmp_483024;
			NI LOC14;
			NI res_483027;
			i_482996 = 0;
			HEX3Atmp_483024 = 0;
			LOC14 = 0;
			LOC14 = safelen_225424(n);
			HEX3Atmp_483024 = (LOC14 - 1);
			res_483027 = 0;
			{
				while (1) {
					NI64 LOC17;
					if (!(res_483027 <= HEX3Atmp_483024)) goto LA16;
					i_482996 = res_483027;
					LOC17 = 0;
					LOC17 = stride_482924(c, (*n).kindU.S6.Sons->data[i_482996]);
					result += LOC17;
					res_483027 += 1;
				} LA16: ;
			}
		}
	}
	LA1: ;
	return result;
}

N_NIMCALL(void, checkslicesaredisjoint_483168)(analysisctx482026* c) {
	addlowerboundasfacts_482708(c);
	{
		tnode224816* x_483411;
		tnode224816* a_483412;
		tnode224816* b_483413;
		NI id_483414;
		NIM_BOOL inloop_483415;
		TY482038* HEX3Atmp_483457;
		NI i_483460;
		NI l_483462;
		x_483411 = 0;
		a_483412 = 0;
		b_483413 = 0;
		id_483414 = 0;
		inloop_483415 = 0;
		HEX3Atmp_483457 = 0;
		HEX3Atmp_483457 = (*c).Slices;
		i_483460 = 0;
		l_483462 = HEX3Atmp_483457->Sup.len;
		{
			while (1) {
				if (!(i_483460 < l_483462)) goto LA3;
				x_483411 = HEX3Atmp_483457->data[i_483460].Field0;
				a_483412 = HEX3Atmp_483457->data[i_483460].Field1;
				b_483413 = HEX3Atmp_483457->data[i_483460].Field2;
				id_483414 = HEX3Atmp_483457->data[i_483460].Field3;
				inloop_483415 = HEX3Atmp_483457->data[i_483460].Field4;
				{
					tnode224816* LOC8;
					tnode224816* LOC9;
					if (!inloop_483415) goto LA6;
					LOC8 = 0;
					LOC8 = substride_483044((&(*c)), a_483412);
					LOC9 = 0;
					LOC9 = substride_483044((&(*c)), b_483413);
					overlap_482899((*c).Guards, a_483412, b_483413, LOC8, LOC9);
				}
				LA6: ;
				i_483460 += 1;
			} LA3: ;
		}
	}
	{
		NI i_483426;
		NI HEX3Atmp_483471;
		NI res_483474;
		i_483426 = 0;
		HEX3Atmp_483471 = 0;
		HEX3Atmp_483471 = ((*c).Slices->Sup.len-1);
		res_483474 = 0;
		{
			while (1) {
				if (!(res_483474 <= HEX3Atmp_483471)) goto LA12;
				i_483426 = res_483474;
				{
					NI j_483437;
					NI HEX3Atmp_483465;
					NI HEX3Atmp_483466;
					NI res_483469;
					j_483437 = 0;
					HEX3Atmp_483465 = 0;
					HEX3Atmp_483466 = 0;
					HEX3Atmp_483465 = (NI64)(i_483426 + 1);
					HEX3Atmp_483466 = ((*c).Slices->Sup.len-1);
					res_483469 = HEX3Atmp_483465;
					{
						while (1) {
							TY482039 x;
							TY482039 y;
							if (!(res_483469 <= HEX3Atmp_483466)) goto LA15;
							j_483437 = res_483469;
							memset((void*)(&x), 0, sizeof(x));
							memcpy((void*)(&x), (NIM_CONST void*)(&(*c).Slices->data[i_483426]), sizeof(x));
							memset((void*)(&y), 0, sizeof(y));
							memcpy((void*)(&y), (NIM_CONST void*)(&(*c).Slices->data[j_483437]), sizeof(y));
							{
								NIM_BOOL LOC18;
								LOC18 = 0;
								LOC18 = !((x.Field3 == y.Field3));
								if (!(LOC18)) goto LA19;
								LOC18 = sametree_369425(x.Field0, y.Field0);
								LA19: ;
								if (!LOC18) goto LA20;
								{
									NIM_BOOL LOC24;
									LOC24 = 0;
									LOC24 = !(x.Field4);
									if (LOC24) goto LA25;
									LOC24 = !(y.Field4);
									LA25: ;
									if (!LOC24) goto LA26;
									overlap_482899((*c).Guards, x.Field1, x.Field2, y.Field1, y.Field2);
								}
								goto LA22;
								LA26: ;
								{
									NI64 k;
									NI64 m;
									NIM_BOOL LOC29;
									NI64 stride;
									NI64 LOC33;
									NI64 LOC34;
									k = simpleslice_372066(x.Field1, x.Field2);
									m = simpleslice_372066(y.Field1, y.Field2);
									LOC29 = 0;
									LOC29 = (IL64(0) <= k);
									if (!(LOC29)) goto LA30;
									LOC29 = (IL64(0) <= m);
									LA30: ;
									if (!LOC29) goto LA31;
									overlap_482899((*c).Guards, x.Field1, x.Field2, y.Field1, y.Field2);
									LOC33 = 0;
									LOC33 = stride_482924((&(*c)), x.Field1);
									LOC34 = 0;
									LOC34 = stride_482924((&(*c)), y.Field1);
									stride = ((LOC33 <= LOC34) ? LOC33 : LOC34);
									{
										NIM_BOOL LOC37;
										LOC37 = 0;
										LOC37 = (k < stride);
										if (!(LOC37)) goto LA38;
										LOC37 = (m < stride);
										LA38: ;
										if (!LOC37) goto LA39;
									}
									goto LA35;
									LA39: ;
									{
										TY196620 LOC42;
										NimStringDesc* LOC43;
										memset((void*)LOC42, 0, sizeof(LOC42));
										LOC42[0] = rendertree_249058(x.Field1, 0);
										LOC42[1] = rendertree_249058(x.Field2, 0);
										LOC42[2] = rendertree_249058(y.Field1, 0);
										LOC42[3] = rendertree_249058(y.Field2, 0);
										LOC43 = 0;
										LOC43 = nsuFormatOpenArray(((NimStringDesc*) &TMP3884), LOC42, 4);
										localerror_196966((*x.Field0).Info, LOC43);
									}
									LA35: ;
								}
								goto LA22;
								LA31: ;
								{
									TY196620 LOC45;
									NimStringDesc* LOC46;
									memset((void*)LOC45, 0, sizeof(LOC45));
									LOC45[0] = rendertree_249058(x.Field1, 0);
									LOC45[1] = rendertree_249058(x.Field2, 0);
									LOC45[2] = rendertree_249058(y.Field1, 0);
									LOC45[3] = rendertree_249058(y.Field2, 0);
									LOC46 = 0;
									LOC46 = nsuFormatOpenArray(((NimStringDesc*) &TMP3884), LOC45, 4);
									localerror_196966((*x.Field0).Info, LOC46);
								}
								LA22: ;
							}
							LA20: ;
							res_483469 += 1;
						} LA15: ;
					}
				}
				res_483474 += 1;
			} LA12: ;
		}
	}
}

N_NIMCALL(void, checkargs_484951)(analysisctx482026* a, tnode224816* n) {
}

N_NIMCALL(void, generatealiaschecks_484962)(analysisctx482026* a, tnode224816* result) {
}

N_NIMCALL(tnode224816*, transformslices_484615)(tnode224816* n) {
	tnode224816* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		tnode224816* LOC5;
		tsym224846* op;
		tnode224816* LOC8;
		LOC3 = 0;
		LOC3 = ((*n).Kind == ((NU8) 27) || (*n).Kind == ((NU8) 29) || (*n).Kind == ((NU8) 30) || (*n).Kind == ((NU8) 31) || (*n).Kind == ((NU8) 26) || (*n).Kind == ((NU8) 28) || (*n).Kind == ((NU8) 32));
		if (!(LOC3)) goto LA4;
		LOC5 = 0;
		LOC5 = HEX5BHEX5D_225698(n, 0);
		LOC3 = ((*LOC5).Kind == ((NU8) 3));
		LA4: ;
		if (!LOC3) goto LA6;
		LOC8 = 0;
		LOC8 = HEX5BHEX5D_225698(n, 0);
		op = (*LOC8).kindU.S4.Sym;
		{
			NIM_BOOL LOC11;
			tnode224816* LOC15;
			tnode224816* LOC16;
			tnode224816* LOC17;
			tnode224816* LOC18;
			tnode224816* LOC19;
			tnode224816* LOC20;
			LOC11 = 0;
			LOC11 = eqStrings((*(*op).Name).S, ((NimStringDesc*) &TMP3868));
			if (!(LOC11)) goto LA12;
			LOC11 = fromsystem_483616(op);
			LA12: ;
			if (!LOC11) goto LA13;
			result = copynode_225323(n);
			LOC15 = 0;
			LOC15 = newsymnode_225132(opslice_482055);
			add_225498(result, LOC15);
			LOC16 = 0;
			LOC16 = HEX5BHEX5D_225698(n, 1);
			add_225498(result, LOC16);
			LOC17 = 0;
			LOC17 = HEX5BHEX5D_225698(n, 2);
			LOC18 = 0;
			LOC18 = HEX5BHEX5D_225698(LOC17, 1);
			add_225498(result, LOC18);
			LOC19 = 0;
			LOC19 = HEX5BHEX5D_225698(n, 2);
			LOC20 = 0;
			LOC20 = HEX5BHEX5D_225698(LOC19, 2);
			add_225498(result, LOC20);
			goto BeforeRet;
		}
		LA13: ;
	}
	LA6: ;
	{
		NI LOC23;
		LOC23 = 0;
		LOC23 = safelen_225424(n);
		if (!(0 < LOC23)) goto LA24;
		result = shallowcopy_230347(n);
		{
			NI i_484679;
			NI HEX3Atmp_484709;
			NI LOC27;
			NI res_484712;
			i_484679 = 0;
			HEX3Atmp_484709 = 0;
			LOC27 = 0;
			LOC27 = len_225364(n);
			HEX3Atmp_484709 = (LOC27 - 1);
			res_484712 = 0;
			{
				while (1) {
					if (!(res_484712 <= HEX3Atmp_484709)) goto LA29;
					i_484679 = res_484712;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.Sons->data[i_484679]), transformslices_484615((*n).kindU.S6.Sons->data[i_484679]));
					res_484712 += 1;
				} LA29: ;
			}
		}
	}
	goto LA21;
	LA24: ;
	{
		result = n;
	}
	LA21: ;
	BeforeRet: ;
	return result;
}

N_NIMCALL(tnode224816*, transformspawnsons_484737)(tsym224846* owner, tnode224816* n, tnode224816* barrier) {
	tnode224816* result;
	result = 0;
	result = shallowcopy_230347(n);
	{
		NI i_484765;
		NI HEX3Atmp_484795;
		NI LOC2;
		NI res_484798;
		i_484765 = 0;
		HEX3Atmp_484795 = 0;
		LOC2 = 0;
		LOC2 = len_225364(n);
		HEX3Atmp_484795 = (LOC2 - 1);
		res_484798 = 0;
		{
			while (1) {
				if (!(res_484798 <= HEX3Atmp_484795)) goto LA4;
				i_484765 = res_484798;
				asgnRefNoCycle((void**) (&(*result).kindU.S6.Sons->data[i_484765]), transformspawn_484729(owner, (*n).kindU.S6.Sons->data[i_484765], barrier));
				res_484798 += 1;
			} LA4: ;
		}
	}
	return result;
}

N_NIMCALL(tnode224816*, transformspawn_484729)(tsym224846* owner, tnode224816* n, tnode224816* barrier) {
	tnode224816* result;
	result = 0;
	switch ((*n).Kind) {
	case ((NU8) 99):
	case ((NU8) 100):
	{
		result = NIM_NIL;
		{
			tnode224816* it_484821;
			it_484821 = 0;
			{
				NI i_484928;
				NI HEX3Atmp_484930;
				NI LOC4;
				NI res_484932;
				i_484928 = 0;
				HEX3Atmp_484930 = 0;
				LOC4 = 0;
				LOC4 = len_225364(n);
				HEX3Atmp_484930 = (LOC4 - 1);
				res_484932 = 0;
				{
					while (1) {
						tnode224816* b;
						if (!(res_484932 <= HEX3Atmp_484930)) goto LA6;
						i_484928 = res_484932;
						it_484821 = (*n).kindU.S6.Sons->data[i_484928];
						b = lastson_225261(it_484821);
						{
							NU16 LOC9;
							tnode224816* m;
							ttype224852* t;
							tnode224816* LOC21;
							tnode224816* LOC22;
							LOC9 = 0;
							LOC9 = getmagic_260845(b);
							if (!(LOC9 == ((NU16) 213))) goto LA10;
							{
								NI LOC14;
								LOC14 = 0;
								LOC14 = len_225364(it_484821);
								if (!!((LOC14 == 3))) goto LA15;
								localerror_196966((*it_484821).Info, ((NimStringDesc*) &TMP3888));
							}
							LA15: ;
							m = transformslices_484615(b);
							{
								if (!result == 0) goto LA19;
								result = newnodei_225138(((NU8) 115), (*n).Info);
								add_225498(result, n);
							}
							LA19: ;
							LOC21 = 0;
							LOC21 = HEX5BHEX5D_225698(b, 1);
							LOC22 = 0;
							LOC22 = HEX5BHEX5D_225698(LOC21, 0);
							t = (*(*LOC22).Typ).Sons->data[0];
							{
								NU8 LOC25;
								tnode224816* LOC28;
								tnode224816* LOC29;
								NI LOC30;
								LOC25 = 0;
								LOC25 = spawnresult_424994(t, NIM_TRUE);
								if (!(LOC25 == ((NU8) 2))) goto LA26;
								LOC28 = 0;
								LOC28 = HEX5BHEX5D_225698(it_484821, 0);
								LOC29 = 0;
								LOC29 = wrapprocforspawn_425897(owner, m, (*b).Typ, barrier, LOC28);
								add_225498(result, LOC29);
								LOC30 = 0;
								LOC30 = len_225364(it_484821);
								asgnRefNoCycle((void**) (&(*it_484821).kindU.S6.Sons->data[(NI64)(LOC30 - 1)]), emptynode_225738);
							}
							goto LA23;
							LA26: ;
							{
								NI LOC32;
								LOC32 = 0;
								LOC32 = len_225364(it_484821);
								asgnRefNoCycle((void**) (&(*it_484821).kindU.S6.Sons->data[(NI64)(LOC32 - 1)]), wrapprocforspawn_425897(owner, m, (*b).Typ, barrier, NIM_NIL));
							}
							LA23: ;
						}
						LA10: ;
						res_484932 += 1;
					} LA6: ;
				}
			}
		}
		{
			if (!result == 0) goto LA35;
			result = n;
		}
		LA35: ;
	}
	break;
	case ((NU8) 73):
	case ((NU8) 74):
	{
		tnode224816* b;
		b = HEX5BHEX5D_225698(n, 1);
		{
			NIM_BOOL LOC40;
			NU16 LOC41;
			ttype224852* t;
			tnode224816* LOC43;
			tnode224816* LOC44;
			NU8 LOC45;
			tnode224816* m;
			tnode224816* LOC48;
			LOC40 = 0;
			LOC41 = 0;
			LOC41 = getmagic_260845(b);
			LOC40 = (LOC41 == ((NU16) 213));
			if (!(LOC40)) goto LA42;
			LOC43 = 0;
			LOC43 = HEX5BHEX5D_225698(b, 1);
			LOC44 = 0;
			LOC44 = HEX5BHEX5D_225698(LOC43, 0);
			t = (*(*LOC44).Typ).Sons->data[0];
			LOC45 = 0;
			LOC45 = spawnresult_424994(t, NIM_TRUE);
			LOC40 = (LOC45 == ((NU8) 2));
			LA42: ;
			if (!LOC40) goto LA46;
			m = transformslices_484615(b);
			LOC48 = 0;
			LOC48 = HEX5BHEX5D_225698(n, 0);
			result = wrapprocforspawn_425897(owner, m, (*b).Typ, barrier, LOC48);
			goto BeforeRet;
		}
		LA46: ;
		result = transformspawnsons_484737(owner, n, barrier);
	}
	break;
	case ((NU8) 27):
	case ((NU8) 29):
	case ((NU8) 30):
	case ((NU8) 31):
	case ((NU8) 26):
	case ((NU8) 28):
	case ((NU8) 32):
	{
		{
			NU16 LOC52;
			LOC52 = 0;
			LOC52 = getmagic_260845(n);
			if (!(LOC52 == ((NU16) 213))) goto LA53;
			result = transformslices_484615(n);
			result = wrapprocforspawn_425897(owner, result, (*n).Typ, barrier, NIM_NIL);
			goto BeforeRet;
		}
		LA53: ;
		result = transformspawnsons_484737(owner, n, barrier);
	}
	break;
	default:
	{
		{
			NI LOC58;
			LOC58 = 0;
			LOC58 = safelen_225424(n);
			if (!(0 < LOC58)) goto LA59;
			result = transformspawnsons_484737(owner, n, barrier);
		}
		goto LA56;
		LA59: ;
		{
			result = n;
		}
		LA56: ;
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tnode224816*, liftparallel_484972)(tsym224846* owner, tnode224816* n) {
	tnode224816* result;
	analysisctx482026 a;
	tnode224816* body;
	tnode224816* varsection;
	tsym224846* temp;
	tident199021* LOC5;
	tsym224846* LOC6;
	tnode224816* tempnode;
	tnode224816* barrier;
	tnode224816* LOC7;
	tnode224816* LOC8;
	tnode224816* LOC9;
	result = 0;
	memset((void*)(&a), 0, sizeof(a));
	chckNil((void*)(&a));
	memset((void*)(&a), 0, sizeof(a));
	initanalysisctx_482059((&a));
	body = lastson_225261(n);
	analyse_483509((&a), body);
	{
		if (!(a.Spawns == 0)) goto LA3;
		localerror_196966((*n).Info, ((NimStringDesc*) &TMP3881));
	}
	LA3: ;
	checkslicesaredisjoint_483168((&a));
	checkargs_484951((&a), body);
	varsection = newnodei_225138(((NU8) 99), (*n).Info);
	LOC5 = 0;
	LOC5 = getident_199472(((NimStringDesc*) &TMP3885));
	temp = newsym_225074(((NU8) 5), LOC5, owner, (*n).Info);
	LOC6 = 0;
	LOC6 = getcompilerproc_281036(((NimStringDesc*) &TMP3886));
	asgnRefNoCycle((void**) (&(*temp).Typ), (*LOC6).Typ);
	(*temp).Flags |= ((NI32)1)<<((((NU8) 2))%(sizeof(NI32)*8));
	tempnode = newsymnode_225132(temp);
	addvar_423053(varsection, tempnode);
	barrier = genaddrof_424872(tempnode);
	result = newnodei_225138(((NU8) 115), (*n).Info);
	generatealiaschecks_484962((&a), result);
	add_225498(result, varsection);
	LOC7 = 0;
	LOC7 = callcodegenproc_424906(((NimStringDesc*) &TMP3887), barrier, NIM_NIL, NIM_NIL);
	add_225498(result, LOC7);
	LOC8 = 0;
	LOC8 = transformspawn_484729(owner, body, barrier);
	add_225498(result, LOC8);
	LOC9 = 0;
	LOC9 = callcodegenproc_424906(((NimStringDesc*) &TMP3889), barrier, NIM_NIL, NIM_NIL);
	add_225498(result, LOC9);
	return result;
}
NIM_EXTERNC N_NOINLINE(void, HEX00_semparallelInit)(void) {
	asgnRefNoCycle((void**) (&opslice_482055), createmagic_367405(((NimStringDesc*) &TMP952), ((NU16) 151)));
}

NIM_EXTERNC N_NOINLINE(void, HEX00_semparallelDatInit)(void) {
static TNimNode* TMP3860[7];
static TNimNode* TMP3861[2];
NI TMP3863;
static char* NIM_CONST TMP3862[2] = {
"ascending", 
"descending"};
static TNimNode* TMP3865[5];
static TNimNode TMP950[17];
NTI482024.size = sizeof(monotonicvar482024);
NTI482024.kind = 18;
NTI482024.base = 0;
NTI482024.flags = 2;
TMP3860[0] = &TMP950[1];
TMP950[1].kind = 1;
TMP950[1].offset = offsetof(monotonicvar482024, V);
TMP950[1].typ = (&NTI224814);
TMP950[1].name = "v";
TMP3860[1] = &TMP950[2];
TMP950[2].kind = 1;
TMP950[2].offset = offsetof(monotonicvar482024, Alias);
TMP950[2].typ = (&NTI224814);
TMP950[2].name = "alias";
TMP3860[2] = &TMP950[3];
TMP950[3].kind = 1;
TMP950[3].offset = offsetof(monotonicvar482024, Lower);
TMP950[3].typ = (&NTI224808);
TMP950[3].name = "lower";
TMP3860[3] = &TMP950[4];
TMP950[4].kind = 1;
TMP950[4].offset = offsetof(monotonicvar482024, Upper);
TMP950[4].typ = (&NTI224808);
TMP950[4].name = "upper";
TMP3860[4] = &TMP950[5];
TMP950[5].kind = 1;
TMP950[5].offset = offsetof(monotonicvar482024, Stride);
TMP950[5].typ = (&NTI224808);
TMP950[5].name = "stride";
TMP3860[5] = &TMP950[6];
NTI482022.size = sizeof(NU8);
NTI482022.kind = 14;
NTI482022.base = 0;
NTI482022.flags = 3;
for (TMP3863 = 0; TMP3863 < 2; TMP3863++) {
TMP950[TMP3863+7].kind = 1;
TMP950[TMP3863+7].offset = TMP3863;
TMP950[TMP3863+7].name = TMP3862[TMP3863];
TMP3861[TMP3863] = &TMP950[TMP3863+7];
}
TMP950[9].len = 2; TMP950[9].kind = 2; TMP950[9].sons = &TMP3861[0];
NTI482022.node = &TMP950[9];
TMP950[6].kind = 1;
TMP950[6].offset = offsetof(monotonicvar482024, Dir);
TMP950[6].typ = (&NTI482022);
TMP950[6].name = "dir";
TMP3860[6] = &TMP950[10];
TMP950[10].kind = 1;
TMP950[10].offset = offsetof(monotonicvar482024, Blacklisted);
TMP950[10].typ = (&NTI138);
TMP950[10].name = "blacklisted";
TMP950[0].len = 7; TMP950[0].kind = 2; TMP950[0].sons = &TMP3860[0];
NTI482024.node = &TMP950[0];
NTI482036.size = sizeof(TY482036*);
NTI482036.kind = 24;
NTI482036.base = (&NTI482024);
NTI482036.flags = 2;
NTI482036.marker = TMP3864;
NTI482039.size = sizeof(TY482039);
NTI482039.kind = 18;
NTI482039.base = 0;
NTI482039.flags = 2;
TMP3865[0] = &TMP950[12];
TMP950[12].kind = 1;
TMP950[12].offset = offsetof(TY482039, Field0);
TMP950[12].typ = (&NTI224808);
TMP950[12].name = "Field0";
TMP3865[1] = &TMP950[13];
TMP950[13].kind = 1;
TMP950[13].offset = offsetof(TY482039, Field1);
TMP950[13].typ = (&NTI224808);
TMP950[13].name = "Field1";
TMP3865[2] = &TMP950[14];
TMP950[14].kind = 1;
TMP950[14].offset = offsetof(TY482039, Field2);
TMP950[14].typ = (&NTI224808);
TMP950[14].name = "Field2";
TMP3865[3] = &TMP950[15];
TMP950[15].kind = 1;
TMP950[15].offset = offsetof(TY482039, Field3);
TMP950[15].typ = (&NTI108);
TMP950[15].name = "Field3";
TMP3865[4] = &TMP950[16];
TMP950[16].kind = 1;
TMP950[16].offset = offsetof(TY482039, Field4);
TMP950[16].typ = (&NTI138);
TMP950[16].name = "Field4";
TMP950[11].len = 5; TMP950[11].kind = 2; TMP950[11].sons = &TMP3865[0];
NTI482039.node = &TMP950[11];
NTI482038.size = sizeof(TY482038*);
NTI482038.kind = 24;
NTI482038.base = (&NTI482039);
NTI482038.flags = 2;
NTI482038.marker = TMP3866;
}

