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

#include <string.h>
typedef struct tsym226846 tsym226846;
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 tnode226816 tnode226816;
typedef struct analysisctx484026 analysisctx484026;
typedef struct TY484036 TY484036;
typedef struct monotonicvar484024 monotonicvar484024;
typedef struct TY484038 TY484038;
typedef struct TY484039 TY484039;
typedef struct tnodeseq226810 tnodeseq226810;
typedef struct tsymseq226818 tsymseq226818;
typedef struct TNimNode TNimNode;
typedef struct ttype226852 ttype226852;
typedef struct tlineinfo196539 tlineinfo196539;
typedef struct tident201021 tident201021;
typedef struct tidobj201015 tidobj201015;
typedef struct TNimObject TNimObject;
typedef struct ttypeseq226848 ttypeseq226848;
typedef struct tscope226840 tscope226840;
typedef struct TY226947 TY226947;
typedef struct tinstantiation226836 tinstantiation226836;
typedef struct tstrtable226820 tstrtable226820;
typedef struct tloc226830 tloc226830;
typedef struct trope178009 trope178009;
typedef struct tlib226834 tlib226834;
typedef struct tbasechunk26438 tbasechunk26438;
typedef struct tfreecell26430 tfreecell26430;
typedef struct TY226936 TY226936;
typedef struct tlistentry127022 tlistentry127022;
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  monotonicvar484024  {
tsym226846* V;
tsym226846* Alias;
tnode226816* Lower;
tnode226816* Upper;
tnode226816* Stride;
NU8 Dir;
NIM_BOOL Blacklisted;
};
struct TY484039 {
tnode226816* Field0;
tnode226816* Field1;
tnode226816* Field2;
NI Field3;
NIM_BOOL Field4;
};
struct  analysisctx484026  {
TY484036* Locals;
TY484038* Slices;
tnodeseq226810* Guards;
tsymseq226818* 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  tlineinfo196539  {
NI16 Line;
NI16 Col;
NI32 Fileindex;
};
struct  tnode226816  {
ttype226852* Typ;
tlineinfo196539 Info;
NU16 Flags;
NU8 Kind;
union {
struct {NI64 Intval;
} S1;
struct {NF Floatval;
} S2;
struct {NimStringDesc* Strval;
} S3;
struct {tsym226846* Sym;
} S4;
struct {tident201021* Ident;
} S5;
struct {tnodeseq226810* Sons;
} S6;
} kindU;
NimStringDesc* Comment;
};
struct  TNimObject  {
TNimType* m_type;
};
struct  tidobj201015  {
  TNimObject Sup;
NI Id;
};
struct  tstrtable226820  {
NI Counter;
tsymseq226818* Data;
};
struct  tloc226830  {
NU8 K;
NU8 S;
NU8 Flags;
ttype226852* T;
trope178009* R;
trope178009* Heaproot;
};
struct  tsym226846  {
  tidobj201015 Sup;
NU8 Kind;
union {
struct {ttypeseq226848* Typeinstcache;
tscope226840* Typscope;
} S1;
struct {TY226947* Procinstcache;
tscope226840* Scope;
} S2;
struct {TY226947* Usedgenerics;
tstrtable226820 Tab;
} S3;
struct {tsym226846* Guard;
} S4;
} kindU;
NU16 Magic;
ttype226852* Typ;
tident201021* Name;
tlineinfo196539 Info;
tsym226846* Owner;
NU32 Flags;
tnode226816* Ast;
NU32 Options;
NI Position;
NI Offset;
tloc226830 Loc;
tlib226834* Annex;
tnode226816* Constraint;
};
struct  tident201021  {
  tidobj201015 Sup;
NimStringDesc* S;
tident201021* Next;
NI H;
};
typedef NimStringDesc* TY484908[6];
typedef NimStringDesc* TY198620[4];
struct  ttype226852  {
  tidobj201015 Sup;
NU8 Kind;
NU8 Callconv;
NU32 Flags;
ttypeseq226848* Sons;
tnode226816* N;
tsym226846* Owner;
tsym226846* Sym;
tsym226846* Destructor;
tsym226846* Deepcopy;
NI64 Size;
NI16 Align;
NI16 Locklevel;
tloc226830 Loc;
};
typedef NI TY26420[16];
struct  tpagedesc44943  {
tpagedesc44943* Next;
NI Key;
TY26420 Bits;
};
struct  tbasechunk26438  {
NI Prevsize;
NI Size;
NIM_BOOL Used;
};
struct  tsmallchunk26440  {
  tbasechunk26438 Sup;
tsmallchunk26440* Next;
tsmallchunk26440* Prev;
tfreecell26430* Freelist;
NI Free;
NI Acc;
NF Data;
};
struct  tllchunk27204  {
NI Size;
NI Acc;
tllchunk27204* Next;
};
struct  tbigchunk26442  {
  tbasechunk26438 Sup;
tbigchunk26442* Next;
tbigchunk26442* Prev;
NI Align;
NF Data;
};
struct  ttrunk26413  {
ttrunk26413* Next;
NI Key;
TY26420 Bits;
};
typedef tavlnode27208* TY27214[2];
struct  tavlnode27208  {
TY27214 Link;
NI Key;
NI Upperbound;
NI Level;
};
struct  tscope226840  {
NI Depthlevel;
tstrtable226820 Symbols;
tnodeseq226810* Usingsyms;
tscope226840* Parent;
};
struct  tinstantiation226836  {
tsym226846* Sym;
ttypeseq226848* Concretetypes;
TY226936* Usedby;
};
struct  trope178009  {
  TNimObject Sup;
trope178009* Left;
trope178009* Right;
NI Length;
NimStringDesc* Data;
};
struct  tlistentry127022  {
  TNimObject Sup;
tlistentry127022* Prev;
tlistentry127022* Next;
};
struct  tlib226834  {
  tlistentry127022 Sup;
NU8 Kind;
NIM_BOOL Generated;
NIM_BOOL Isoverriden;
trope178009* Name;
tnode226816* Path;
};
struct  tfreecell26430  {
tfreecell26430* Next;
NI Zerofield;
};
struct TY484036 {
  TGenericSeq Sup;
  monotonicvar484024 data[SEQ_DECL_SIZE];
};
struct TY484038 {
  TGenericSeq Sup;
  TY484039 data[SEQ_DECL_SIZE];
};
struct tnodeseq226810 {
  TGenericSeq Sup;
  tnode226816* data[SEQ_DECL_SIZE];
};
struct tsymseq226818 {
  TGenericSeq Sup;
  tsym226846* data[SEQ_DECL_SIZE];
};
struct ttypeseq226848 {
  TGenericSeq Sup;
  ttype226852* data[SEQ_DECL_SIZE];
};
struct TY226947 {
  TGenericSeq Sup;
  tinstantiation226836* data[SEQ_DECL_SIZE];
};
struct TY226936 {
  TGenericSeq Sup;
  NI32 data[SEQ_DECL_SIZE];
};
N_NIMCALL(tsym226846*, createmagic_369405)(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_484059)(analysisctx484026* Result);
N_NIMCALL(void, nimGCvisit)(void* d, NI op);
N_NIMCALL(void, TMP3866)(void* p, NI op);
N_NIMCALL(void*, newSeq)(TNimType* typ, NI len);
N_NIMCALL(void, unsureAsgnRef)(void** dest, void* src);
N_NIMCALL(void, TMP3868)(void* p, NI op);
N_NOINLINE(void, chckNil)(void* p);
static N_INLINE(tnode226816*, lastson_227261)(tnode226816* n);
static N_INLINE(NI, sonslen_227249)(tnode226816* n);
N_NIMCALL(void, analyse_485509)(analysisctx484026* c, tnode226816* n);
N_NIMCALL(NIM_BOOL, issingleassignable_484416)(tnode226816* n);
static N_INLINE(tnode226816*, HEX5BHEX5D_227698)(tnode226816* n, NI i);
N_NIMCALL(NIM_BOOL, islocal_484501)(tnode226816* n);
N_NIMCALL(monotonicvar484024*, getslot_484239)(analysisctx484026* c, tsym226846* v);
N_NIMCALL(NI, lookupslot_484148)(analysisctx484026* c, tsym226846* s);
N_NIMCALL(TGenericSeq*, setLengthSeq)(TGenericSeq* seq, NI elemsize, NI newlen);
N_NIMCALL(void, invalidatefacts_371774)(tnodeseq226810** m, tnode226816* n);
N_NIMCALL(NU16, getmagic_262845)(tnode226816* op);
N_NIMCALL(void, gatherargs_484283)(analysisctx484026* c, tnode226816* n);
static N_INLINE(NI, safelen_227424)(tnode226816* n);
N_NIMCALL(tsym226846*, getroot_427533)(tnode226816* n);
N_NIMCALL(TGenericSeq*, incrSeq)(TGenericSeq* seq, NI elemsize);
N_NIMCALL(void, analysesons_485517)(analysisctx484026* c, tnode226816* n);
N_NIMCALL(void, addasgnfact_375618)(tnodeseq226810** m, tnode226816* key, tnode226816* value);
N_NIMCALL(void, analysecall_485647)(analysisctx484026* c, tnode226816* n, tsym226846* op);
static N_INLINE(NIM_BOOL, eqStrings)(NimStringDesc* a, NimStringDesc* b);
N_NIMCALL(NIM_BOOL, fromsystem_485616)(tsym226846* op);
N_NIMCALL(tsym226846*, getmodule_236243)(tsym226846* s);
N_NIMCALL(tnode226816*, skipconv_274732)(tnode226816* n);
N_NIMCALL(tnode226816*, min_485565)(tnode226816* a, tnode226816* b);
N_NIMCALL(void, addslice_484835)(analysisctx484026* c, tnode226816* n, tnode226816* x, tnode226816* le_484841, tnode226816* ri_484842);
N_NIMCALL(void, checklocal_484586)(analysisctx484026* c, tnode226816* n);
N_NIMCALL(void, localerror_198966)(tlineinfo196539 info, NimStringDesc* arg);
N_NIMCALL(tnode226816*, canon_370513)(tnode226816* n);
N_NIMCALL(void, addlowerboundasfacts_484708)(analysisctx484026* c);
N_NIMCALL(void, addfactle_375018)(tnodeseq226810** m, tnode226816* a, tnode226816* b);
N_NIMCALL(tnode226816*, newsymnode_227132)(tsym226846* sym);
N_NIMCALL(void, checkbounds_484697)(analysisctx484026* c, tnode226816* arr, tnode226816* idx);
N_NIMCALL(void, checkle_484686)(analysisctx484026* c, tnode226816* a, tnode226816* b);
N_NIMCALL(NU8, provele_374995)(tnodeseq226810* m, tnode226816* a, tnode226816* b);
static N_INLINE(void, appendString)(NimStringDesc* dest, NimStringDesc* src);
N_NIMCALL(NimStringDesc*, rendertree_251058)(tnode226816* n, NU8 renderflags);
N_NIMCALL(NimStringDesc*, rawNewString)(NI space);
N_NIMCALL(tnode226816*, lowbound_370448)(tnode226816* x);
N_NIMCALL(tnode226816*, highbound_370458)(tnode226816* x);
N_NIMCALL(void, genericAssign)(void* dest, void* src, TNimType* mt);
static N_INLINE(NI, len_227364)(tnode226816* n);
N_NIMCALL(void, internalerror_198987)(tlineinfo196539 info, NimStringDesc* errmsg);
N_NIMCALL(void, analysecase_485738)(analysisctx484026* c, tnode226816* n);
N_NIMCALL(void, addcasebranchfacts_375755)(tnodeseq226810** m, tnode226816* n, NI i);
N_NIMCALL(void, analyseif_485911)(analysisctx484026* c, tnode226816* n);
N_NIMCALL(void, addfact_371349)(tnodeseq226810** m, tnode226816* n_371353);
N_NIMCALL(void, addfactneg_371396)(tnodeseq226810** m, tnode226816* n_371400);
N_NIMCALL(NIM_BOOL, istrue_382730)(tnode226816* n);
N_NIMCALL(NIM_BOOL, hassubnodewith_227308)(tnode226816* n, NU8 kind);
N_NIMCALL(void, checkslicesaredisjoint_485168)(analysisctx484026* c);
N_NIMCALL(void, overlap_484899)(tnodeseq226810* m, tnode226816* x, tnode226816* y, tnode226816* c, tnode226816* d);
N_NIMCALL(NimStringDesc*, nsuFormatOpenArray)(NimStringDesc* formatstr, NimStringDesc** a, NI aLen0);
N_NIMCALL(tnode226816*, substride_485044)(analysisctx484026* c, tnode226816* n);
N_NIMCALL(tnode226816*, HEX2BHEX40_370779)(tnode226816* a, NI64 b);
N_NIMCALL(tnode226816*, shallowcopy_232347)(tnode226816* src);
N_NIMCALL(NIM_BOOL, sametree_371425)(tnode226816* a, tnode226816* b);
N_NIMCALL(NI64, simpleslice_374066)(tnode226816* a, tnode226816* b);
N_NIMCALL(NI64, stride_484924)(analysisctx484026* c, tnode226816* n);
N_NIMCALL(void, checkargs_486951)(analysisctx484026* a, tnode226816* n);
N_NIMCALL(tnode226816*, newnodei_227138)(NU8 kind, tlineinfo196539 info);
N_NIMCALL(tsym226846*, newsym_227074)(NU8 symkind, tident201021* name, tsym226846* owner, tlineinfo196539 info);
N_NIMCALL(tident201021*, getident_201472)(NimStringDesc* identifier);
N_NIMCALL(tsym226846*, getcompilerproc_283036)(NimStringDesc* name);
N_NIMCALL(void, addvar_425053)(tnode226816* father, tnode226816* v);
N_NIMCALL(tnode226816*, genaddrof_426872)(tnode226816* n);
N_NIMCALL(void, generatealiaschecks_486962)(analysisctx484026* a, tnode226816* result);
N_NIMCALL(void, add_227498)(tnode226816* father, tnode226816* son);
N_NIMCALL(tnode226816*, callcodegenproc_426906)(NimStringDesc* name, tnode226816* arg1, tnode226816* arg2, tnode226816* arg3);
N_NIMCALL(tnode226816*, transformspawn_486729)(tsym226846* owner, tnode226816* n, tnode226816* barrier);
N_NIMCALL(tnode226816*, transformslices_486615)(tnode226816* n);
N_NIMCALL(tnode226816*, copynode_227323)(tnode226816* src);
N_NIMCALL(NU8, spawnresult_426994)(ttype226852* t, NIM_BOOL inparallel);
N_NIMCALL(tnode226816*, wrapprocforspawn_427897)(tsym226846* owner, tnode226816* spawnexpr, ttype226852* rettype, tnode226816* barrier, tnode226816* dest);
N_NIMCALL(tnode226816*, transformspawnsons_486737)(tsym226846* owner, tnode226816* n, tnode226816* barrier);
STRING_LITERAL(TMP954, "slice", 5);
STRING_LITERAL(TMP3869, "+=", 2);
STRING_LITERAL(TMP3870, "[]", 2);
STRING_LITERAL(TMP3871, "invalid usage of counter after increment", 40);
STRING_LITERAL(TMP3876, "cannot prove: ", 14);
STRING_LITERAL(TMP3877, " <= ", 4);
STRING_LITERAL(TMP3878, "can prove: ", 11);
STRING_LITERAL(TMP3879, " > ", 3);
STRING_LITERAL(TMP3880, "[]=", 3);
STRING_LITERAL(TMP3881, "invalid control flow for \'parallel\'", 35);
STRING_LITERAL(TMP3882, "slot already has a lower bound", 30);
STRING_LITERAL(TMP3883, "\'parallel\' section without \'spawn\'", 34);
STRING_LITERAL(TMP3884, "cannot prove: $# > $#; required for ($#)..($#) disjoint from ($"
"#)..($#)", 71);
STRING_LITERAL(TMP3885, "($#)..($#) not disjoint from ($#)..($#)", 39);
STRING_LITERAL(TMP3886, "cannot prove ($#)..($#) disjoint from ($#)..($#)", 48);
STRING_LITERAL(TMP3887, "barrier", 7);
STRING_LITERAL(TMP3888, "Barrier", 7);
STRING_LITERAL(TMP3889, "openBarrier", 11);
STRING_LITERAL(TMP3890, "invalid context for \'spawn\'", 27);
STRING_LITERAL(TMP3891, "closeBarrier", 12);
tsym226846* opslice_484055;
extern tgcheap47016 gch_47044;
TNimType NTI484024; /* MonotonicVar */
extern TNimType NTI226814; /* PSym */
extern TNimType NTI226808; /* PNode */
TNimType NTI484022; /* TDirection */
extern TNimType NTI138; /* bool */
TNimType NTI484036; /* seq[MonotonicVar] */
TNimType NTI484039; /* tuple[x: PNode, a: PNode, b: PNode, spawnId: int, inLoop: bool] */
extern TNimType NTI108; /* int */
TNimType NTI484038; /* seq[tuple[x: PNode, a: PNode, b: PNode, spawnId: int, inLoop: bool]] */
extern TNimType NTI226818; /* TSymSeq */
extern TNimType NTI226810; /* TNodeSeq */
extern tnode226816* emptynode_227738;

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

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

static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src) {
	{
		tcell44935* c;
		if (!!((src == NIM_NIL))) goto LA3;
		c = usrtocell_48646(src);
		(*c).Refcount += 8;
	}
	LA3: ;
	{
		tcell44935* c;
		if (!!(((*dest) == NIM_NIL))) goto LA7;
		c = usrtocell_48646((*dest));
		{
			(*c).Refcount -= 8;
			if (!((NU32)((*c).Refcount) < (NU32)(8))) goto LA11;
			rtladdzct_50204(c);
		}
		LA11: ;
	}
	LA7: ;
	(*dest) = src;
}
N_NIMCALL(void, TMP3866)(void* p, NI op) {
	TY484036* a;
	NI LOC1;
	a = (TY484036*)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, TMP3868)(void* p, NI op) {
	TY484038* a;
	NI LOC1;
	a = (TY484038*)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_484059)(analysisctx484026* Result) {
	unsureAsgnRef((void**) (&(*Result).Locals), (TY484036*) newSeq((&NTI484036), 0));
	unsureAsgnRef((void**) (&(*Result).Slices), (TY484038*) newSeq((&NTI484038), 0));
	unsureAsgnRef((void**) (&(*Result).Args), (tsymseq226818*) newSeq((&NTI226818), 0));
	unsureAsgnRef((void**) (&(*Result).Guards), (tnodeseq226810*) newSeq((&NTI226810), 0));
}

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

static N_INLINE(tnode226816*, lastson_227261)(tnode226816* n) {
	tnode226816* result;
	NI LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = sonslen_227249(n);
	result = (*n).kindU.S6.Sons->data[(NI32)(LOC1 - 1)];
	return result;
}

N_NIMCALL(NIM_BOOL, issingleassignable_484416)(tnode226816* n) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	tsym226846* 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(tnode226816*, HEX5BHEX5D_227698)(tnode226816* n, NI i) {
	tnode226816* result;
	result = 0;
	result = (*n).kindU.S6.Sons->data[i];
	return result;
}

N_NIMCALL(NIM_BOOL, islocal_484501)(tnode226816* n) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	tsym226846* 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_484148)(analysisctx484026* c, tsym226846* s) {
	NI result;
	result = 0;
	{
		NI i_484185;
		NI HEX3Atmp_484219;
		NI res_484222;
		i_484185 = 0;
		HEX3Atmp_484219 = 0;
		HEX3Atmp_484219 = ((*c).Locals->Sup.len - 1);
		res_484222 = 0;
		{
			while (1) {
				if (!(res_484222 <= HEX3Atmp_484219)) goto LA3;
				i_484185 = res_484222;
				{
					NIM_BOOL LOC6;
					LOC6 = 0;
					LOC6 = ((*c).Locals->data[i_484185].V == s);
					if (LOC6) goto LA7;
					LOC6 = ((*c).Locals->data[i_484185].Alias == s);
					LA7: ;
					if (!LOC6) goto LA8;
					result = i_484185;
					goto BeforeRet;
				}
				LA8: ;
				res_484222 += 1;
			} LA3: ;
		}
	}
	result = -1;
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

N_NIMCALL(monotonicvar484024*, getslot_484239)(analysisctx484026* c, tsym226846* v) {
	monotonicvar484024* result;
	NI s;
	NI l;
	result = 0;
	s = lookupslot_484148((&(*c)), v);
	{
		if (!(0 <= s)) goto LA3;
		result = (&(*c).Locals->data[s]);
		goto BeforeRet;
	}
	LA3: ;
	l = (*c).Locals->Sup.len;
	(*c).Locals = (TY484036*) setLengthSeq(&((*c).Locals)->Sup, sizeof(monotonicvar484024), (NI32)(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_227424)(tnode226816* 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_484283)(analysisctx484026* c, tnode226816* n) {
	{
		NI i_484309;
		NI HEX3Atmp_484384;
		NI LOC2;
		NI res_484387;
		i_484309 = 0;
		HEX3Atmp_484384 = 0;
		LOC2 = 0;
		LOC2 = safelen_227424(n);
		HEX3Atmp_484384 = (LOC2 - 1);
		res_484387 = 0;
		{
			while (1) {
				tsym226846* root;
				tnode226816* LOC5;
				tnode226816* LOC18;
				if (!(res_484387 <= HEX3Atmp_484384)) goto LA4;
				i_484309 = res_484387;
				LOC5 = 0;
				LOC5 = HEX5BHEX5D_227698(n, i_484309);
				root = getroot_427533(LOC5);
				{
					if (!!((root == NIM_NIL))) goto LA8;
					{
						{
							tsym226846* r_484341;
							tsymseq226818* HEX3Atmp_484378;
							NI i_484381;
							NI l_484383;
							r_484341 = 0;
							HEX3Atmp_484378 = 0;
							HEX3Atmp_484378 = (*c).Args;
							i_484381 = 0;
							l_484383 = HEX3Atmp_484378->Sup.len;
							{
								while (1) {
									if (!(i_484381 < l_484383)) goto LA13;
									r_484341 = HEX3Atmp_484378->data[i_484381];
									{
										if (!(r_484341 == root)) goto LA16;
										goto LA10;
									}
									LA16: ;
									i_484381 += 1;
								} LA13: ;
							}
						}
						(*c).Args = (tsymseq226818*) incrSeq(&((*c).Args)->Sup, sizeof(tsym226846*));
						asgnRefNoCycle((void**) (&(*c).Args->data[(*c).Args->Sup.len-1]), root);
					} LA10: ;
				}
				LA8: ;
				LOC18 = 0;
				LOC18 = HEX5BHEX5D_227698(n, i_484309);
				gatherargs_484283(c, LOC18);
				res_484387 += 1;
			} LA4: ;
		}
	}
}

N_NIMCALL(void, analysesons_485517)(analysisctx484026* c, tnode226816* n) {
	{
		NI i_485543;
		NI HEX3Atmp_485545;
		NI LOC2;
		NI res_485548;
		i_485543 = 0;
		HEX3Atmp_485545 = 0;
		LOC2 = 0;
		LOC2 = safelen_227424(n);
		HEX3Atmp_485545 = (LOC2 - 1);
		res_485548 = 0;
		{
			while (1) {
				tnode226816* LOC5;
				if (!(res_485548 <= HEX3Atmp_485545)) goto LA4;
				i_485543 = res_485548;
				LOC5 = 0;
				LOC5 = HEX5BHEX5D_227698(n, i_485543);
				analyse_485509(c, LOC5);
				res_485548 += 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)), (NI32)((*a).Sup.len * 1));
	LOC11 = (LOC13 == ((NI32) 0));
	LA12: ;
	result = LOC11;
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

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

N_NIMCALL(tnode226816*, min_485565)(tnode226816* a, tnode226816* b) {
	tnode226816* 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_484586)(analysisctx484026* c, tnode226816* n) {
	{
		NIM_BOOL LOC3;
		NI s;
		LOC3 = 0;
		LOC3 = islocal_484501(n);
		if (!LOC3) goto LA4;
		s = lookupslot_484148(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_198966((*n).Info, ((NimStringDesc*) &TMP3871));
		}
		LA10: ;
	}
	goto LA1;
	LA4: ;
	{
		{
			NI i_484643;
			NI HEX3Atmp_484659;
			NI LOC14;
			NI res_484662;
			i_484643 = 0;
			HEX3Atmp_484659 = 0;
			LOC14 = 0;
			LOC14 = safelen_227424(n);
			HEX3Atmp_484659 = (LOC14 - 1);
			res_484662 = 0;
			{
				while (1) {
					if (!(res_484662 <= HEX3Atmp_484659)) goto LA16;
					i_484643 = res_484662;
					checklocal_484586(c, (*n).kindU.S6.Sons->data[i_484643]);
					res_484662 += 1;
				} LA16: ;
			}
		}
	}
	LA1: ;
}

N_NIMCALL(void, addlowerboundasfacts_484708)(analysisctx484026* c) {
	{
		monotonicvar484024 v_484811;
		TY484036* HEX3Atmp_484814;
		NI i_484817;
		NI l_484819;
		memset((void*)(&v_484811), 0, sizeof(v_484811));
		HEX3Atmp_484814 = 0;
		HEX3Atmp_484814 = (*c).Locals;
		i_484817 = 0;
		l_484819 = HEX3Atmp_484814->Sup.len;
		{
			while (1) {
				if (!(i_484817 < l_484819)) goto LA3;
				memcpy((void*)(&v_484811), (NIM_CONST void*)(&HEX3Atmp_484814->data[i_484817]), sizeof(v_484811));
				{
					tnode226816* LOC8;
					if (!!(v_484811.Blacklisted)) goto LA6;
					LOC8 = 0;
					LOC8 = newsymnode_227132(v_484811.V);
					addfactle_375018((&(*c).Guards), v_484811.Lower, LOC8);
				}
				LA6: ;
				i_484817 += 1;
			} LA3: ;
		}
	}
}

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

N_NIMCALL(void, checkle_484686)(analysisctx484026* c, tnode226816* a, tnode226816* b) {
	NU8 LOC1;
	LOC1 = 0;
	LOC1 = provele_374995((*c).Guards, a, b);
	switch (LOC1) {
	case ((NU8) 0):
	{
		NimStringDesc* LOC3;
		NimStringDesc* LOC4;
		NimStringDesc* LOC5;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = rendertree_251058(a, 0);
		LOC5 = 0;
		LOC5 = rendertree_251058(b, 0);
		LOC3 = rawNewString(LOC4->Sup.len + LOC5->Sup.len + 18);
appendString(LOC3, ((NimStringDesc*) &TMP3876));
appendString(LOC3, LOC4);
appendString(LOC3, ((NimStringDesc*) &TMP3877));
appendString(LOC3, LOC5);
		localerror_198966((*a).Info, LOC3);
	}
	break;
	case ((NU8) 2):
	{
	}
	break;
	case ((NU8) 1):
	{
		NimStringDesc* LOC8;
		NimStringDesc* LOC9;
		NimStringDesc* LOC10;
		LOC8 = 0;
		LOC9 = 0;
		LOC9 = rendertree_251058(a, 0);
		LOC10 = 0;
		LOC10 = rendertree_251058(b, 0);
		LOC8 = rawNewString(LOC9->Sup.len + LOC10->Sup.len + 14);
appendString(LOC8, ((NimStringDesc*) &TMP3878));
appendString(LOC8, LOC9);
appendString(LOC8, ((NimStringDesc*) &TMP3879));
appendString(LOC8, LOC10);
		localerror_198966((*a).Info, LOC8);
	}
	break;
	}
}

N_NIMCALL(void, checkbounds_484697)(analysisctx484026* c, tnode226816* arr, tnode226816* idx) {
	tnode226816* LOC1;
	tnode226816* LOC2;
	LOC1 = 0;
	LOC1 = lowbound_370448(arr);
	checkle_484686(c, LOC1, idx);
	LOC2 = 0;
	LOC2 = highbound_370458(arr);
	checkle_484686(c, idx, LOC2);
}

N_NIMCALL(void, addslice_484835)(analysisctx484026* c, tnode226816* n, tnode226816* x, tnode226816* le_484841, tnode226816* ri_484842) {
	tnode226816* le;
	tnode226816* ri;
	NI oldstate;
	TY484039 LOC1;
	checklocal_484586((&(*c)), n);
	le = canon_370513(le_484841);
	ri = canon_370513(ri_484842);
	oldstate = (*c).Guards->Sup.len;
	addlowerboundasfacts_484708(c);
	checkbounds_484697((&(*c)), x, le);
	checkbounds_484697((&(*c)), x, ri);
	(*c).Guards = (tnodeseq226810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode226816*), 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 = (TY484038*) incrSeq(&((*c).Slices)->Sup, sizeof(TY484039));
	genericAssign((void*)(&(*c).Slices->data[(*c).Slices->Sup.len-1]), (void*)(&LOC1), (&NTI484039));
}

N_NIMCALL(void, analysecall_485647)(analysisctx484026* c, tnode226816* n, tsym226846* op) {
	{
		NI oldspawnid;
		tnode226816* LOC5;
		if (!((*op).Magic == ((NU16) 213))) goto LA3;
		(*c).Spawns += 1;
		oldspawnid = (*c).Currentspawnid;
		(*c).Currentspawnid = (*c).Spawns;
		LOC5 = 0;
		LOC5 = HEX5BHEX5D_227698(n, 1);
		gatherargs_484283(c, LOC5);
		analysesons_485517(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*) &TMP3869));
		if (!(LOC9)) goto LA10;
		LOC9 = fromsystem_485616(op);
		LA10: ;
		LOC7 = LOC9;
		LA8: ;
		if (!LOC7) goto LA11;
		{
			tnode226816* LOC15;
			NIM_BOOL LOC16;
			tnode226816* incr;
			tnode226816* LOC19;
			LOC15 = 0;
			LOC15 = HEX5BHEX5D_227698(n, 1);
			LOC16 = 0;
			LOC16 = islocal_484501(LOC15);
			if (!LOC16) goto LA17;
			LOC19 = 0;
			LOC19 = HEX5BHEX5D_227698(n, 2);
			incr = skipconv_274732(LOC19);
			{
				NIM_BOOL LOC22;
				monotonicvar484024* slot;
				tnode226816* 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_227698(n, 1);
				slot = getslot_484239(c, (*LOC26).kindU.S4.Sym);
				unsureAsgnRef((void**) (&(*slot).Stride), min_485565((*slot).Stride, incr));
			}
			LA24: ;
		}
		LA17: ;
		analysesons_485517(c, n);
	}
	goto LA1;
	LA11: ;
	{
		NIM_BOOL LOC28;
		tnode226816* LOC32;
		tnode226816* LOC33;
		tnode226816* LOC34;
		tnode226816* LOC35;
		tnode226816* LOC36;
		LOC28 = 0;
		LOC28 = eqStrings((*(*op).Name).S, ((NimStringDesc*) &TMP3870));
		if (!(LOC28)) goto LA29;
		LOC28 = fromsystem_485616(op);
		LA29: ;
		if (!LOC28) goto LA30;
		LOC32 = 0;
		LOC32 = HEX5BHEX5D_227698(n, 1);
		LOC33 = 0;
		LOC33 = HEX5BHEX5D_227698(n, 2);
		LOC34 = 0;
		LOC34 = HEX5BHEX5D_227698(LOC33, 1);
		LOC35 = 0;
		LOC35 = HEX5BHEX5D_227698(n, 2);
		LOC36 = 0;
		LOC36 = HEX5BHEX5D_227698(LOC35, 2);
		addslice_484835(c, n, LOC32, LOC34, LOC36);
		analysesons_485517(c, n);
	}
	goto LA1;
	LA30: ;
	{
		NIM_BOOL LOC38;
		tnode226816* LOC42;
		tnode226816* LOC43;
		tnode226816* LOC44;
		tnode226816* LOC45;
		tnode226816* LOC46;
		LOC38 = 0;
		LOC38 = eqStrings((*(*op).Name).S, ((NimStringDesc*) &TMP3880));
		if (!(LOC38)) goto LA39;
		LOC38 = fromsystem_485616(op);
		LA39: ;
		if (!LOC38) goto LA40;
		LOC42 = 0;
		LOC42 = HEX5BHEX5D_227698(n, 1);
		LOC43 = 0;
		LOC43 = HEX5BHEX5D_227698(n, 2);
		LOC44 = 0;
		LOC44 = HEX5BHEX5D_227698(LOC43, 1);
		LOC45 = 0;
		LOC45 = HEX5BHEX5D_227698(n, 2);
		LOC46 = 0;
		LOC46 = HEX5BHEX5D_227698(LOC45, 2);
		addslice_484835(c, n, LOC42, LOC44, LOC46);
		analysesons_485517(c, n);
	}
	goto LA1;
	LA40: ;
	{
		analysesons_485517(c, n);
	}
	LA1: ;
}

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

N_NIMCALL(void, analysecase_485738)(analysisctx484026* c, tnode226816* n) {
	NI oldfacts;
	analyse_485509(c, (*n).kindU.S6.Sons->data[0]);
	oldfacts = (*c).Guards->Sup.len;
	{
		NI i_485790;
		NI HEX3Atmp_485882;
		NI LOC2;
		NI res_485885;
		i_485790 = 0;
		HEX3Atmp_485882 = 0;
		LOC2 = 0;
		LOC2 = len_227364(n);
		HEX3Atmp_485882 = (LOC2 - 1);
		res_485885 = 1;
		{
			while (1) {
				tnode226816* branch;
				if (!(res_485885 <= HEX3Atmp_485882)) goto LA4;
				i_485790 = res_485885;
				branch = (*n).kindU.S6.Sons->data[i_485790];
				(*c).Guards = (tnodeseq226810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode226816*), oldfacts);
				addcasebranchfacts_375755((&(*c).Guards), n, i_485790);
				{
					NI i_485844;
					NI HEX3Atmp_485877;
					NI LOC6;
					NI res_485880;
					i_485844 = 0;
					HEX3Atmp_485877 = 0;
					LOC6 = 0;
					LOC6 = len_227364(branch);
					HEX3Atmp_485877 = (LOC6 - 1);
					res_485880 = 0;
					{
						while (1) {
							if (!(res_485880 <= HEX3Atmp_485877)) goto LA8;
							i_485844 = res_485880;
							analyse_485509(c, (*branch).kindU.S6.Sons->data[i_485844]);
							res_485880 += 1;
						} LA8: ;
					}
				}
				res_485885 += 1;
			} LA4: ;
		}
	}
	(*c).Guards = (tnodeseq226810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode226816*), oldfacts);
}

N_NIMCALL(void, analyseif_485911)(analysisctx484026* c, tnode226816* n) {
	NI oldfacts;
	tnode226816* LOC1;
	analyse_485509(c, (*(*n).kindU.S6.Sons->data[0]).kindU.S6.Sons->data[0]);
	oldfacts = (*c).Guards->Sup.len;
	LOC1 = 0;
	LOC1 = canon_370513((*(*n).kindU.S6.Sons->data[0]).kindU.S6.Sons->data[0]);
	addfact_371349((&(*c).Guards), LOC1);
	analyse_485509(c, (*(*n).kindU.S6.Sons->data[0]).kindU.S6.Sons->data[1]);
	{
		NI i_486034;
		NI HEX3Atmp_486187;
		NI LOC3;
		NI res_486190;
		i_486034 = 0;
		HEX3Atmp_486187 = 0;
		LOC3 = 0;
		LOC3 = len_227364(n);
		HEX3Atmp_486187 = (LOC3 - 1);
		res_486190 = 1;
		{
			while (1) {
				tnode226816* branch;
				if (!(res_486190 <= HEX3Atmp_486187)) goto LA5;
				i_486034 = res_486190;
				branch = (*n).kindU.S6.Sons->data[i_486034];
				(*c).Guards = (tnodeseq226810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode226816*), oldfacts);
				{
					NI j_486076;
					NI HEX3Atmp_486176;
					NI res_486179;
					j_486076 = 0;
					HEX3Atmp_486176 = 0;
					HEX3Atmp_486176 = (NI32)(i_486034 - 1);
					res_486179 = 0;
					{
						while (1) {
							tnode226816* LOC9;
							if (!(res_486179 <= HEX3Atmp_486176)) goto LA8;
							j_486076 = res_486179;
							LOC9 = 0;
							LOC9 = canon_370513((*(*n).kindU.S6.Sons->data[j_486076]).kindU.S6.Sons->data[0]);
							addfactneg_371396((&(*c).Guards), LOC9);
							res_486179 += 1;
						} LA8: ;
					}
				}
				{
					NI LOC12;
					tnode226816* LOC15;
					LOC12 = 0;
					LOC12 = len_227364(branch);
					if (!(1 < LOC12)) goto LA13;
					LOC15 = 0;
					LOC15 = canon_370513((*branch).kindU.S6.Sons->data[0]);
					addfact_371349((&(*c).Guards), LOC15);
				}
				LA13: ;
				{
					NI i_486143;
					NI HEX3Atmp_486182;
					NI LOC17;
					NI res_486185;
					i_486143 = 0;
					HEX3Atmp_486182 = 0;
					LOC17 = 0;
					LOC17 = len_227364(branch);
					HEX3Atmp_486182 = (LOC17 - 1);
					res_486185 = 0;
					{
						while (1) {
							if (!(res_486185 <= HEX3Atmp_486182)) goto LA19;
							i_486143 = res_486185;
							analyse_485509(c, (*branch).kindU.S6.Sons->data[i_486143]);
							res_486185 += 1;
						} LA19: ;
					}
				}
				res_486190 += 1;
			} LA5: ;
		}
	}
	(*c).Guards = (tnodeseq226810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode226816*), oldfacts);
}

N_NIMCALL(void, analyse_485509)(analysisctx484026* c, tnode226816* n) {
	switch ((*n).Kind) {
	case ((NU8) 73):
	case ((NU8) 74):
	{
		tnode226816* LOC18;
		tnode226816* value;
		tnode226816* LOC28;
		tnode226816* LOC29;
		{
			NIM_BOOL LOC4;
			tnode226816* LOC5;
			tnode226816* LOC7;
			monotonicvar484024* slot;
			tnode226816* LOC10;
			tnode226816* LOC11;
			LOC4 = 0;
			LOC5 = 0;
			LOC5 = HEX5BHEX5D_227698(n, 0);
			LOC4 = issingleassignable_484416(LOC5);
			if (!(LOC4)) goto LA6;
			LOC7 = 0;
			LOC7 = HEX5BHEX5D_227698(n, 1);
			LOC4 = islocal_484501(LOC7);
			LA6: ;
			if (!LOC4) goto LA8;
			LOC10 = 0;
			LOC10 = HEX5BHEX5D_227698(n, 1);
			slot = getslot_484239(c, (*LOC10).kindU.S4.Sym);
			LOC11 = 0;
			LOC11 = HEX5BHEX5D_227698(n, 0);
			unsureAsgnRef((void**) (&(*slot).Alias), (*LOC11).kindU.S4.Sym);
		}
		goto LA2;
		LA8: ;
		{
			tnode226816* LOC13;
			NIM_BOOL LOC14;
			monotonicvar484024* slot;
			tnode226816* LOC17;
			LOC13 = 0;
			LOC13 = HEX5BHEX5D_227698(n, 0);
			LOC14 = 0;
			LOC14 = islocal_484501(LOC13);
			if (!LOC14) goto LA15;
			LOC17 = 0;
			LOC17 = HEX5BHEX5D_227698(n, 0);
			slot = getslot_484239(c, (*LOC17).kindU.S4.Sym);
			(*slot).Blacklisted = NIM_TRUE;
		}
		goto LA2;
		LA15: ;
		LA2: ;
		LOC18 = 0;
		LOC18 = HEX5BHEX5D_227698(n, 0);
		invalidatefacts_371774((&(*c).Guards), LOC18);
		value = HEX5BHEX5D_227698(n, 1);
		{
			NU16 LOC21;
			NI oldspawnid;
			tnode226816* LOC24;
			tnode226816* LOC25;
			tnode226816* LOC26;
			LOC21 = 0;
			LOC21 = getmagic_262845(value);
			if (!(LOC21 == ((NU16) 213))) goto LA22;
			(*c).Spawns += 1;
			oldspawnid = (*c).Currentspawnid;
			(*c).Currentspawnid = (*c).Spawns;
			LOC24 = 0;
			LOC24 = HEX5BHEX5D_227698(value, 1);
			gatherargs_484283(c, LOC24);
			LOC25 = 0;
			LOC25 = HEX5BHEX5D_227698(value, 1);
			analysesons_485517(c, LOC25);
			LOC26 = 0;
			LOC26 = HEX5BHEX5D_227698(n, 0);
			analyse_485509(c, LOC26);
			(*c).Currentspawnid = oldspawnid;
		}
		goto LA19;
		LA22: ;
		{
			analysesons_485517(c, n);
		}
		LA19: ;
		LOC28 = 0;
		LOC28 = HEX5BHEX5D_227698(n, 0);
		LOC29 = 0;
		LOC29 = HEX5BHEX5D_227698(n, 1);
		addasgnfact_375618((&(*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):
	{
		{
			tnode226816* LOC33;
			tnode226816* LOC36;
			LOC33 = 0;
			LOC33 = HEX5BHEX5D_227698(n, 0);
			if (!((*LOC33).Kind == ((NU8) 3))) goto LA34;
			LOC36 = 0;
			LOC36 = HEX5BHEX5D_227698(n, 0);
			analysecall_485647(c, n, (*LOC36).kindU.S4.Sym);
		}
		goto LA31;
		LA34: ;
		{
			analysesons_485517(c, n);
		}
		LA31: ;
	}
	break;
	case ((NU8) 42):
	{
		tnode226816* LOC39;
		tnode226816* LOC40;
		tnode226816* LOC41;
		LOC39 = 0;
		LOC39 = HEX5BHEX5D_227698(n, 0);
		LOC40 = 0;
		LOC40 = HEX5BHEX5D_227698(n, 1);
		LOC41 = 0;
		LOC41 = HEX5BHEX5D_227698(n, 1);
		addslice_484835(c, n, LOC39, LOC40, LOC41);
		analysesons_485517(c, n);
	}
	break;
	case ((NU8) 109):
	case ((NU8) 108):
	case ((NU8) 106):
	{
		localerror_198966((*n).Info, ((NimStringDesc*) &TMP3881));
	}
	break;
	case ((NU8) 99):
	case ((NU8) 100):
	{
		{
			tnode226816* it_486322;
			it_486322 = 0;
			{
				NI i_486583;
				NI HEX3Atmp_486585;
				NI LOC46;
				NI res_486587;
				i_486583 = 0;
				HEX3Atmp_486585 = 0;
				LOC46 = 0;
				LOC46 = len_227364(n);
				HEX3Atmp_486585 = (LOC46 - 1);
				res_486587 = 0;
				{
					while (1) {
						tnode226816* value;
						NIM_BOOL isspawned;
						NU16 LOC49;
						if (!(res_486587 <= HEX3Atmp_486585)) goto LA48;
						i_486583 = res_486587;
						it_486322 = (*n).kindU.S6.Sons->data[i_486583];
						value = lastson_227261(it_486322);
						LOC49 = 0;
						LOC49 = getmagic_262845(value);
						isspawned = (LOC49 == ((NU16) 213));
						{
							NI oldspawnid;
							tnode226816* LOC54;
							tnode226816* LOC55;
							if (!isspawned) goto LA52;
							(*c).Spawns += 1;
							oldspawnid = (*c).Currentspawnid;
							(*c).Currentspawnid = (*c).Spawns;
							LOC54 = 0;
							LOC54 = HEX5BHEX5D_227698(value, 1);
							gatherargs_484283(c, LOC54);
							LOC55 = 0;
							LOC55 = HEX5BHEX5D_227698(value, 1);
							analysesons_485517(c, LOC55);
							(*c).Currentspawnid = oldspawnid;
						}
						LA52: ;
						{
							if (!!(((*value).Kind == ((NU8) 1)))) goto LA58;
							{
								NI j_486366;
								NI HEX3Atmp_486575;
								NI LOC61;
								NI res_486578;
								j_486366 = 0;
								HEX3Atmp_486575 = 0;
								LOC61 = 0;
								LOC61 = len_227364(it_486322);
								HEX3Atmp_486575 = (NI32)(LOC61 - 3);
								res_486578 = 0;
								{
									while (1) {
										if (!(res_486578 <= HEX3Atmp_486575)) goto LA63;
										j_486366 = res_486578;
										{
											tnode226816* LOC66;
											NIM_BOOL LOC67;
											monotonicvar484024* slot;
											tnode226816* LOC70;
											LOC66 = 0;
											LOC66 = HEX5BHEX5D_227698(it_486322, j_486366);
											LOC67 = 0;
											LOC67 = islocal_484501(LOC66);
											if (!LOC67) goto LA68;
											LOC70 = 0;
											LOC70 = HEX5BHEX5D_227698(it_486322, j_486366);
											slot = getslot_484239(c, (*LOC70).kindU.S4.Sym);
											{
												if (!(*slot).Lower == 0) goto LA73;
												unsureAsgnRef((void**) (&(*slot).Lower), value);
											}
											goto LA71;
											LA73: ;
											{
												internalerror_198987((*it_486322).Info, ((NimStringDesc*) &TMP3882));
											}
											LA71: ;
										}
										LA68: ;
										res_486578 += 1;
									} LA63: ;
								}
							}
							{
								if (!!(isspawned)) goto LA78;
								analyse_485509(c, value);
							}
							LA78: ;
						}
						LA58: ;
						res_486587 += 1;
					} LA48: ;
				}
			}
		}
	}
	break;
	case ((NU8) 97):
	{
		analysecase_485738(c, n);
	}
	break;
	case ((NU8) 92):
	case ((NU8) 48):
	{
		analyseif_485911(c, n);
	}
	break;
	case ((NU8) 96):
	{
		analyse_485509(c, (*n).kindU.S6.Sons->data[0]);
		(*c).Inloop += 1;
		{
			NIM_BOOL LOC85;
			LOC85 = 0;
			LOC85 = istrue_382730((*n).kindU.S6.Sons->data[0]);
			if (!LOC85) goto LA86;
			analysesons_485517(c, (*n).kindU.S6.Sons->data[1]);
		}
		goto LA83;
		LA86: ;
		{
			NI oldstate;
			NI oldfacts;
			tnode226816* LOC89;
			oldstate = (*c).Locals->Sup.len;
			oldfacts = (*c).Guards->Sup.len;
			LOC89 = 0;
			LOC89 = canon_370513((*n).kindU.S6.Sons->data[0]);
			addfact_371349((&(*c).Guards), LOC89);
			analyse_485509(c, (*n).kindU.S6.Sons->data[1]);
			(*c).Locals = (TY484036*) setLengthSeq(&((*c).Locals)->Sup, sizeof(monotonicvar484024), oldstate);
			(*c).Guards = (tnodeseq226810*) setLengthSeq(&((*c).Guards)->Sup, sizeof(tnode226816*), oldfacts);
			{
				NIM_BOOL LOC92;
				tnode226816* LOC95;
				LOC92 = 0;
				LOC92 = hassubnodewith_227308((*n).kindU.S6.Sons->data[1], ((NU8) 110));
				if (!!(LOC92)) goto LA93;
				LOC95 = 0;
				LOC95 = canon_370513((*n).kindU.S6.Sons->data[0]);
				addfactneg_371396((&(*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_485517(c, n);
	}
	break;
	}
}

N_NIMCALL(void, overlap_484899)(tnodeseq226810* m, tnode226816* x, tnode226816* y, tnode226816* c, tnode226816* d) {
	NU8 LOC1;
	LOC1 = 0;
	LOC1 = provele_374995(m, x, d);
	switch (LOC1) {
	case ((NU8) 0):
	{
		TY484908 LOC3;
		NimStringDesc* LOC4;
		memset((void*)LOC3, 0, sizeof(LOC3));
		LOC3[0] = rendertree_251058(x, 0);
		LOC3[1] = rendertree_251058(d, 0);
		LOC3[2] = rendertree_251058(x, 0);
		LOC3[3] = rendertree_251058(y, 0);
		LOC3[4] = rendertree_251058(c, 0);
		LOC3[5] = rendertree_251058(d, 0);
		LOC4 = 0;
		LOC4 = nsuFormatOpenArray(((NimStringDesc*) &TMP3884), LOC3, 6);
		localerror_198966((*x).Info, LOC4);
	}
	break;
	case ((NU8) 2):
	{
		NU8 LOC6;
		LOC6 = 0;
		LOC6 = provele_374995(m, c, y);
		switch (LOC6) {
		case ((NU8) 0):
		{
			TY484908 LOC8;
			NimStringDesc* LOC9;
			memset((void*)LOC8, 0, sizeof(LOC8));
			LOC8[0] = rendertree_251058(c, 0);
			LOC8[1] = rendertree_251058(y, 0);
			LOC8[2] = rendertree_251058(x, 0);
			LOC8[3] = rendertree_251058(y, 0);
			LOC8[4] = rendertree_251058(c, 0);
			LOC8[5] = rendertree_251058(d, 0);
			LOC9 = 0;
			LOC9 = nsuFormatOpenArray(((NimStringDesc*) &TMP3884), LOC8, 6);
			localerror_198966((*x).Info, LOC9);
		}
		break;
		case ((NU8) 2):
		{
			TY198620 LOC11;
			NimStringDesc* LOC12;
			memset((void*)LOC11, 0, sizeof(LOC11));
			LOC11[0] = rendertree_251058(x, 0);
			LOC11[1] = rendertree_251058(y, 0);
			LOC11[2] = rendertree_251058(c, 0);
			LOC11[3] = rendertree_251058(d, 0);
			LOC12 = 0;
			LOC12 = nsuFormatOpenArray(((NimStringDesc*) &TMP3885), LOC11, 4);
			localerror_198966((*x).Info, LOC12);
		}
		break;
		case ((NU8) 1):
		{
		}
		break;
		}
	}
	break;
	case ((NU8) 1):
	{
	}
	break;
	}
}

N_NIMCALL(tnode226816*, substride_485044)(analysisctx484026* c, tnode226816* n) {
	tnode226816* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		NI s;
		LOC3 = 0;
		LOC3 = islocal_484501(n);
		if (!LOC3) goto LA4;
		s = lookupslot_484148(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_370779(n, (*(*c).Locals->data[s].Stride).kindU.S1.Intval);
		}
		goto LA6;
		LA10: ;
		{
			result = n;
		}
		LA6: ;
	}
	goto LA1;
	LA4: ;
	{
		NI LOC14;
		LOC14 = 0;
		LOC14 = safelen_227424(n);
		if (!(0 < LOC14)) goto LA15;
		result = shallowcopy_232347(n);
		{
			NI i_485118;
			NI HEX3Atmp_485148;
			NI LOC18;
			NI res_485151;
			i_485118 = 0;
			HEX3Atmp_485148 = 0;
			LOC18 = 0;
			LOC18 = len_227364(n);
			HEX3Atmp_485148 = (LOC18 - 1);
			res_485151 = 0;
			{
				while (1) {
					if (!(res_485151 <= HEX3Atmp_485148)) goto LA20;
					i_485118 = res_485151;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.Sons->data[i_485118]), substride_485044(c, (*n).kindU.S6.Sons->data[i_485118]));
					res_485151 += 1;
				} LA20: ;
			}
		}
	}
	goto LA1;
	LA15: ;
	{
		result = n;
	}
	LA1: ;
	return result;
}

N_NIMCALL(NI64, stride_484924)(analysisctx484026* c, tnode226816* n) {
	NI64 result;
	result = 0;
	{
		NIM_BOOL LOC3;
		NI s;
		LOC3 = 0;
		LOC3 = islocal_484501(n);
		if (!LOC3) goto LA4;
		s = lookupslot_484148(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_484996;
			NI HEX3Atmp_485024;
			NI LOC14;
			NI res_485027;
			i_484996 = 0;
			HEX3Atmp_485024 = 0;
			LOC14 = 0;
			LOC14 = safelen_227424(n);
			HEX3Atmp_485024 = (LOC14 - 1);
			res_485027 = 0;
			{
				while (1) {
					NI64 LOC17;
					if (!(res_485027 <= HEX3Atmp_485024)) goto LA16;
					i_484996 = res_485027;
					LOC17 = 0;
					LOC17 = stride_484924(c, (*n).kindU.S6.Sons->data[i_484996]);
					result += LOC17;
					res_485027 += 1;
				} LA16: ;
			}
		}
	}
	LA1: ;
	return result;
}

N_NIMCALL(void, checkslicesaredisjoint_485168)(analysisctx484026* c) {
	addlowerboundasfacts_484708(c);
	{
		tnode226816* x_485411;
		tnode226816* a_485412;
		tnode226816* b_485413;
		NI id_485414;
		NIM_BOOL inloop_485415;
		TY484038* HEX3Atmp_485457;
		NI i_485460;
		NI l_485462;
		x_485411 = 0;
		a_485412 = 0;
		b_485413 = 0;
		id_485414 = 0;
		inloop_485415 = 0;
		HEX3Atmp_485457 = 0;
		HEX3Atmp_485457 = (*c).Slices;
		i_485460 = 0;
		l_485462 = HEX3Atmp_485457->Sup.len;
		{
			while (1) {
				if (!(i_485460 < l_485462)) goto LA3;
				x_485411 = HEX3Atmp_485457->data[i_485460].Field0;
				a_485412 = HEX3Atmp_485457->data[i_485460].Field1;
				b_485413 = HEX3Atmp_485457->data[i_485460].Field2;
				id_485414 = HEX3Atmp_485457->data[i_485460].Field3;
				inloop_485415 = HEX3Atmp_485457->data[i_485460].Field4;
				{
					tnode226816* LOC8;
					tnode226816* LOC9;
					if (!inloop_485415) goto LA6;
					LOC8 = 0;
					LOC8 = substride_485044((&(*c)), a_485412);
					LOC9 = 0;
					LOC9 = substride_485044((&(*c)), b_485413);
					overlap_484899((*c).Guards, a_485412, b_485413, LOC8, LOC9);
				}
				LA6: ;
				i_485460 += 1;
			} LA3: ;
		}
	}
	{
		NI i_485426;
		NI HEX3Atmp_485471;
		NI res_485474;
		i_485426 = 0;
		HEX3Atmp_485471 = 0;
		HEX3Atmp_485471 = ((*c).Slices->Sup.len-1);
		res_485474 = 0;
		{
			while (1) {
				if (!(res_485474 <= HEX3Atmp_485471)) goto LA12;
				i_485426 = res_485474;
				{
					NI j_485437;
					NI HEX3Atmp_485465;
					NI HEX3Atmp_485466;
					NI res_485469;
					j_485437 = 0;
					HEX3Atmp_485465 = 0;
					HEX3Atmp_485466 = 0;
					HEX3Atmp_485465 = (NI32)(i_485426 + 1);
					HEX3Atmp_485466 = ((*c).Slices->Sup.len-1);
					res_485469 = HEX3Atmp_485465;
					{
						while (1) {
							TY484039 x;
							TY484039 y;
							if (!(res_485469 <= HEX3Atmp_485466)) goto LA15;
							j_485437 = res_485469;
							memset((void*)(&x), 0, sizeof(x));
							memcpy((void*)(&x), (NIM_CONST void*)(&(*c).Slices->data[i_485426]), sizeof(x));
							memset((void*)(&y), 0, sizeof(y));
							memcpy((void*)(&y), (NIM_CONST void*)(&(*c).Slices->data[j_485437]), sizeof(y));
							{
								NIM_BOOL LOC18;
								LOC18 = 0;
								LOC18 = !((x.Field3 == y.Field3));
								if (!(LOC18)) goto LA19;
								LOC18 = sametree_371425(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_484899((*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_374066(x.Field1, x.Field2);
									m = simpleslice_374066(y.Field1, y.Field2);
									LOC29 = 0;
									LOC29 = (IL64(0) <= k);
									if (!(LOC29)) goto LA30;
									LOC29 = (IL64(0) <= m);
									LA30: ;
									if (!LOC29) goto LA31;
									overlap_484899((*c).Guards, x.Field1, x.Field2, y.Field1, y.Field2);
									LOC33 = 0;
									LOC33 = stride_484924((&(*c)), x.Field1);
									LOC34 = 0;
									LOC34 = stride_484924((&(*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: ;
									{
										TY198620 LOC42;
										NimStringDesc* LOC43;
										memset((void*)LOC42, 0, sizeof(LOC42));
										LOC42[0] = rendertree_251058(x.Field1, 0);
										LOC42[1] = rendertree_251058(x.Field2, 0);
										LOC42[2] = rendertree_251058(y.Field1, 0);
										LOC42[3] = rendertree_251058(y.Field2, 0);
										LOC43 = 0;
										LOC43 = nsuFormatOpenArray(((NimStringDesc*) &TMP3886), LOC42, 4);
										localerror_198966((*x.Field0).Info, LOC43);
									}
									LA35: ;
								}
								goto LA22;
								LA31: ;
								{
									TY198620 LOC45;
									NimStringDesc* LOC46;
									memset((void*)LOC45, 0, sizeof(LOC45));
									LOC45[0] = rendertree_251058(x.Field1, 0);
									LOC45[1] = rendertree_251058(x.Field2, 0);
									LOC45[2] = rendertree_251058(y.Field1, 0);
									LOC45[3] = rendertree_251058(y.Field2, 0);
									LOC46 = 0;
									LOC46 = nsuFormatOpenArray(((NimStringDesc*) &TMP3886), LOC45, 4);
									localerror_198966((*x.Field0).Info, LOC46);
								}
								LA22: ;
							}
							LA20: ;
							res_485469 += 1;
						} LA15: ;
					}
				}
				res_485474 += 1;
			} LA12: ;
		}
	}
}

N_NIMCALL(void, checkargs_486951)(analysisctx484026* a, tnode226816* n) {
}

N_NIMCALL(void, generatealiaschecks_486962)(analysisctx484026* a, tnode226816* result) {
}

N_NIMCALL(tnode226816*, transformslices_486615)(tnode226816* n) {
	tnode226816* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		tnode226816* LOC5;
		tsym226846* op;
		tnode226816* 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_227698(n, 0);
		LOC3 = ((*LOC5).Kind == ((NU8) 3));
		LA4: ;
		if (!LOC3) goto LA6;
		LOC8 = 0;
		LOC8 = HEX5BHEX5D_227698(n, 0);
		op = (*LOC8).kindU.S4.Sym;
		{
			NIM_BOOL LOC11;
			tnode226816* LOC15;
			tnode226816* LOC16;
			tnode226816* LOC17;
			tnode226816* LOC18;
			tnode226816* LOC19;
			tnode226816* LOC20;
			LOC11 = 0;
			LOC11 = eqStrings((*(*op).Name).S, ((NimStringDesc*) &TMP3870));
			if (!(LOC11)) goto LA12;
			LOC11 = fromsystem_485616(op);
			LA12: ;
			if (!LOC11) goto LA13;
			result = copynode_227323(n);
			LOC15 = 0;
			LOC15 = newsymnode_227132(opslice_484055);
			add_227498(result, LOC15);
			LOC16 = 0;
			LOC16 = HEX5BHEX5D_227698(n, 1);
			add_227498(result, LOC16);
			LOC17 = 0;
			LOC17 = HEX5BHEX5D_227698(n, 2);
			LOC18 = 0;
			LOC18 = HEX5BHEX5D_227698(LOC17, 1);
			add_227498(result, LOC18);
			LOC19 = 0;
			LOC19 = HEX5BHEX5D_227698(n, 2);
			LOC20 = 0;
			LOC20 = HEX5BHEX5D_227698(LOC19, 2);
			add_227498(result, LOC20);
			goto BeforeRet;
		}
		LA13: ;
	}
	LA6: ;
	{
		NI LOC23;
		LOC23 = 0;
		LOC23 = safelen_227424(n);
		if (!(0 < LOC23)) goto LA24;
		result = shallowcopy_232347(n);
		{
			NI i_486679;
			NI HEX3Atmp_486709;
			NI LOC27;
			NI res_486712;
			i_486679 = 0;
			HEX3Atmp_486709 = 0;
			LOC27 = 0;
			LOC27 = len_227364(n);
			HEX3Atmp_486709 = (LOC27 - 1);
			res_486712 = 0;
			{
				while (1) {
					if (!(res_486712 <= HEX3Atmp_486709)) goto LA29;
					i_486679 = res_486712;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.Sons->data[i_486679]), transformslices_486615((*n).kindU.S6.Sons->data[i_486679]));
					res_486712 += 1;
				} LA29: ;
			}
		}
	}
	goto LA21;
	LA24: ;
	{
		result = n;
	}
	LA21: ;
	BeforeRet: ;
	return result;
}

N_NIMCALL(tnode226816*, transformspawnsons_486737)(tsym226846* owner, tnode226816* n, tnode226816* barrier) {
	tnode226816* result;
	result = 0;
	result = shallowcopy_232347(n);
	{
		NI i_486765;
		NI HEX3Atmp_486795;
		NI LOC2;
		NI res_486798;
		i_486765 = 0;
		HEX3Atmp_486795 = 0;
		LOC2 = 0;
		LOC2 = len_227364(n);
		HEX3Atmp_486795 = (LOC2 - 1);
		res_486798 = 0;
		{
			while (1) {
				if (!(res_486798 <= HEX3Atmp_486795)) goto LA4;
				i_486765 = res_486798;
				asgnRefNoCycle((void**) (&(*result).kindU.S6.Sons->data[i_486765]), transformspawn_486729(owner, (*n).kindU.S6.Sons->data[i_486765], barrier));
				res_486798 += 1;
			} LA4: ;
		}
	}
	return result;
}

N_NIMCALL(tnode226816*, transformspawn_486729)(tsym226846* owner, tnode226816* n, tnode226816* barrier) {
	tnode226816* result;
	result = 0;
	switch ((*n).Kind) {
	case ((NU8) 99):
	case ((NU8) 100):
	{
		result = NIM_NIL;
		{
			tnode226816* it_486821;
			it_486821 = 0;
			{
				NI i_486928;
				NI HEX3Atmp_486930;
				NI LOC4;
				NI res_486932;
				i_486928 = 0;
				HEX3Atmp_486930 = 0;
				LOC4 = 0;
				LOC4 = len_227364(n);
				HEX3Atmp_486930 = (LOC4 - 1);
				res_486932 = 0;
				{
					while (1) {
						tnode226816* b;
						if (!(res_486932 <= HEX3Atmp_486930)) goto LA6;
						i_486928 = res_486932;
						it_486821 = (*n).kindU.S6.Sons->data[i_486928];
						b = lastson_227261(it_486821);
						{
							NU16 LOC9;
							tnode226816* m;
							ttype226852* t;
							tnode226816* LOC21;
							tnode226816* LOC22;
							LOC9 = 0;
							LOC9 = getmagic_262845(b);
							if (!(LOC9 == ((NU16) 213))) goto LA10;
							{
								NI LOC14;
								LOC14 = 0;
								LOC14 = len_227364(it_486821);
								if (!!((LOC14 == 3))) goto LA15;
								localerror_198966((*it_486821).Info, ((NimStringDesc*) &TMP3890));
							}
							LA15: ;
							m = transformslices_486615(b);
							{
								if (!result == 0) goto LA19;
								result = newnodei_227138(((NU8) 115), (*n).Info);
								add_227498(result, n);
							}
							LA19: ;
							LOC21 = 0;
							LOC21 = HEX5BHEX5D_227698(b, 1);
							LOC22 = 0;
							LOC22 = HEX5BHEX5D_227698(LOC21, 0);
							t = (*(*LOC22).Typ).Sons->data[0];
							{
								NU8 LOC25;
								tnode226816* LOC28;
								tnode226816* LOC29;
								NI LOC30;
								LOC25 = 0;
								LOC25 = spawnresult_426994(t, NIM_TRUE);
								if (!(LOC25 == ((NU8) 2))) goto LA26;
								LOC28 = 0;
								LOC28 = HEX5BHEX5D_227698(it_486821, 0);
								LOC29 = 0;
								LOC29 = wrapprocforspawn_427897(owner, m, (*b).Typ, barrier, LOC28);
								add_227498(result, LOC29);
								LOC30 = 0;
								LOC30 = len_227364(it_486821);
								asgnRefNoCycle((void**) (&(*it_486821).kindU.S6.Sons->data[(NI32)(LOC30 - 1)]), emptynode_227738);
							}
							goto LA23;
							LA26: ;
							{
								NI LOC32;
								LOC32 = 0;
								LOC32 = len_227364(it_486821);
								asgnRefNoCycle((void**) (&(*it_486821).kindU.S6.Sons->data[(NI32)(LOC32 - 1)]), wrapprocforspawn_427897(owner, m, (*b).Typ, barrier, NIM_NIL));
							}
							LA23: ;
						}
						LA10: ;
						res_486932 += 1;
					} LA6: ;
				}
			}
		}
		{
			if (!result == 0) goto LA35;
			result = n;
		}
		LA35: ;
	}
	break;
	case ((NU8) 73):
	case ((NU8) 74):
	{
		tnode226816* b;
		b = HEX5BHEX5D_227698(n, 1);
		{
			NIM_BOOL LOC40;
			NU16 LOC41;
			ttype226852* t;
			tnode226816* LOC43;
			tnode226816* LOC44;
			NU8 LOC45;
			tnode226816* m;
			tnode226816* LOC48;
			LOC40 = 0;
			LOC41 = 0;
			LOC41 = getmagic_262845(b);
			LOC40 = (LOC41 == ((NU16) 213));
			if (!(LOC40)) goto LA42;
			LOC43 = 0;
			LOC43 = HEX5BHEX5D_227698(b, 1);
			LOC44 = 0;
			LOC44 = HEX5BHEX5D_227698(LOC43, 0);
			t = (*(*LOC44).Typ).Sons->data[0];
			LOC45 = 0;
			LOC45 = spawnresult_426994(t, NIM_TRUE);
			LOC40 = (LOC45 == ((NU8) 2));
			LA42: ;
			if (!LOC40) goto LA46;
			m = transformslices_486615(b);
			LOC48 = 0;
			LOC48 = HEX5BHEX5D_227698(n, 0);
			result = wrapprocforspawn_427897(owner, m, (*b).Typ, barrier, LOC48);
			goto BeforeRet;
		}
		LA46: ;
		result = transformspawnsons_486737(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_262845(n);
			if (!(LOC52 == ((NU16) 213))) goto LA53;
			result = transformslices_486615(n);
			result = wrapprocforspawn_427897(owner, result, (*n).Typ, barrier, NIM_NIL);
			goto BeforeRet;
		}
		LA53: ;
		result = transformspawnsons_486737(owner, n, barrier);
	}
	break;
	default:
	{
		{
			NI LOC58;
			LOC58 = 0;
			LOC58 = safelen_227424(n);
			if (!(0 < LOC58)) goto LA59;
			result = transformspawnsons_486737(owner, n, barrier);
		}
		goto LA56;
		LA59: ;
		{
			result = n;
		}
		LA56: ;
	}
	break;
	}
	BeforeRet: ;
	return result;
}

N_NIMCALL(tnode226816*, liftparallel_486972)(tsym226846* owner, tnode226816* n) {
	tnode226816* result;
	analysisctx484026 a;
	tnode226816* body;
	tnode226816* varsection;
	tsym226846* temp;
	tident201021* LOC5;
	tsym226846* LOC6;
	tnode226816* tempnode;
	tnode226816* barrier;
	tnode226816* LOC7;
	tnode226816* LOC8;
	tnode226816* LOC9;
	result = 0;
	memset((void*)(&a), 0, sizeof(a));
	chckNil((void*)(&a));
	memset((void*)(&a), 0, sizeof(a));
	initanalysisctx_484059((&a));
	body = lastson_227261(n);
	analyse_485509((&a), body);
	{
		if (!(a.Spawns == 0)) goto LA3;
		localerror_198966((*n).Info, ((NimStringDesc*) &TMP3883));
	}
	LA3: ;
	checkslicesaredisjoint_485168((&a));
	checkargs_486951((&a), body);
	varsection = newnodei_227138(((NU8) 99), (*n).Info);
	LOC5 = 0;
	LOC5 = getident_201472(((NimStringDesc*) &TMP3887));
	temp = newsym_227074(((NU8) 5), LOC5, owner, (*n).Info);
	LOC6 = 0;
	LOC6 = getcompilerproc_283036(((NimStringDesc*) &TMP3888));
	asgnRefNoCycle((void**) (&(*temp).Typ), (*LOC6).Typ);
	(*temp).Flags |= ((NI32)1)<<((((NU8) 2))%(sizeof(NI32)*8));
	tempnode = newsymnode_227132(temp);
	addvar_425053(varsection, tempnode);
	barrier = genaddrof_426872(tempnode);
	result = newnodei_227138(((NU8) 115), (*n).Info);
	generatealiaschecks_486962((&a), result);
	add_227498(result, varsection);
	LOC7 = 0;
	LOC7 = callcodegenproc_426906(((NimStringDesc*) &TMP3889), barrier, NIM_NIL, NIM_NIL);
	add_227498(result, LOC7);
	LOC8 = 0;
	LOC8 = transformspawn_486729(owner, body, barrier);
	add_227498(result, LOC8);
	LOC9 = 0;
	LOC9 = callcodegenproc_426906(((NimStringDesc*) &TMP3891), barrier, NIM_NIL, NIM_NIL);
	add_227498(result, LOC9);
	return result;
}
NIM_EXTERNC N_NOINLINE(void, HEX00_semparallelInit)(void) {
	asgnRefNoCycle((void**) (&opslice_484055), createmagic_369405(((NimStringDesc*) &TMP954), ((NU16) 151)));
}

NIM_EXTERNC N_NOINLINE(void, HEX00_semparallelDatInit)(void) {
static TNimNode* TMP3862[7];
static TNimNode* TMP3863[2];
NI TMP3865;
static char* NIM_CONST TMP3864[2] = {
"ascending", 
"descending"};
static TNimNode* TMP3867[5];
static TNimNode TMP952[17];
NTI484024.size = sizeof(monotonicvar484024);
NTI484024.kind = 18;
NTI484024.base = 0;
NTI484024.flags = 2;
TMP3862[0] = &TMP952[1];
TMP952[1].kind = 1;
TMP952[1].offset = offsetof(monotonicvar484024, V);
TMP952[1].typ = (&NTI226814);
TMP952[1].name = "v";
TMP3862[1] = &TMP952[2];
TMP952[2].kind = 1;
TMP952[2].offset = offsetof(monotonicvar484024, Alias);
TMP952[2].typ = (&NTI226814);
TMP952[2].name = "alias";
TMP3862[2] = &TMP952[3];
TMP952[3].kind = 1;
TMP952[3].offset = offsetof(monotonicvar484024, Lower);
TMP952[3].typ = (&NTI226808);
TMP952[3].name = "lower";
TMP3862[3] = &TMP952[4];
TMP952[4].kind = 1;
TMP952[4].offset = offsetof(monotonicvar484024, Upper);
TMP952[4].typ = (&NTI226808);
TMP952[4].name = "upper";
TMP3862[4] = &TMP952[5];
TMP952[5].kind = 1;
TMP952[5].offset = offsetof(monotonicvar484024, Stride);
TMP952[5].typ = (&NTI226808);
TMP952[5].name = "stride";
TMP3862[5] = &TMP952[6];
NTI484022.size = sizeof(NU8);
NTI484022.kind = 14;
NTI484022.base = 0;
NTI484022.flags = 3;
for (TMP3865 = 0; TMP3865 < 2; TMP3865++) {
TMP952[TMP3865+7].kind = 1;
TMP952[TMP3865+7].offset = TMP3865;
TMP952[TMP3865+7].name = TMP3864[TMP3865];
TMP3863[TMP3865] = &TMP952[TMP3865+7];
}
TMP952[9].len = 2; TMP952[9].kind = 2; TMP952[9].sons = &TMP3863[0];
NTI484022.node = &TMP952[9];
TMP952[6].kind = 1;
TMP952[6].offset = offsetof(monotonicvar484024, Dir);
TMP952[6].typ = (&NTI484022);
TMP952[6].name = "dir";
TMP3862[6] = &TMP952[10];
TMP952[10].kind = 1;
TMP952[10].offset = offsetof(monotonicvar484024, Blacklisted);
TMP952[10].typ = (&NTI138);
TMP952[10].name = "blacklisted";
TMP952[0].len = 7; TMP952[0].kind = 2; TMP952[0].sons = &TMP3862[0];
NTI484024.node = &TMP952[0];
NTI484036.size = sizeof(TY484036*);
NTI484036.kind = 24;
NTI484036.base = (&NTI484024);
NTI484036.flags = 2;
NTI484036.marker = TMP3866;
NTI484039.size = sizeof(TY484039);
NTI484039.kind = 18;
NTI484039.base = 0;
NTI484039.flags = 2;
TMP3867[0] = &TMP952[12];
TMP952[12].kind = 1;
TMP952[12].offset = offsetof(TY484039, Field0);
TMP952[12].typ = (&NTI226808);
TMP952[12].name = "Field0";
TMP3867[1] = &TMP952[13];
TMP952[13].kind = 1;
TMP952[13].offset = offsetof(TY484039, Field1);
TMP952[13].typ = (&NTI226808);
TMP952[13].name = "Field1";
TMP3867[2] = &TMP952[14];
TMP952[14].kind = 1;
TMP952[14].offset = offsetof(TY484039, Field2);
TMP952[14].typ = (&NTI226808);
TMP952[14].name = "Field2";
TMP3867[3] = &TMP952[15];
TMP952[15].kind = 1;
TMP952[15].offset = offsetof(TY484039, Field3);
TMP952[15].typ = (&NTI108);
TMP952[15].name = "Field3";
TMP3867[4] = &TMP952[16];
TMP952[16].kind = 1;
TMP952[16].offset = offsetof(TY484039, Field4);
TMP952[16].typ = (&NTI138);
TMP952[16].name = "Field4";
TMP952[11].len = 5; TMP952[11].kind = 2; TMP952[11].sons = &TMP3867[0];
NTI484039.node = &TMP952[11];
NTI484038.size = sizeof(TY484038*);
NTI484038.kind = 24;
NTI484038.base = (&NTI484039);
NTI484038.flags = 2;
NTI484038.marker = TMP3868;
}

