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

#include <string.h>
typedef struct Tsym191843 Tsym191843;
typedef struct NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
typedef struct Tcell46346 Tcell46346;
typedef struct TNimType TNimType;
typedef struct Tcellseq46362 Tcellseq46362;
typedef struct Tgcheap48216 Tgcheap48216;
typedef struct Tcellset46358 Tcellset46358;
typedef struct Tpagedesc46354 Tpagedesc46354;
typedef struct Tmemregion28210 Tmemregion28210;
typedef struct Tsmallchunk27440 Tsmallchunk27440;
typedef struct Tllchunk28204 Tllchunk28204;
typedef struct Tbigchunk27442 Tbigchunk27442;
typedef struct Tintset27417 Tintset27417;
typedef struct Ttrunk27413 Ttrunk27413;
typedef struct Tavlnode28208 Tavlnode28208;
typedef struct Tgcstat48214 Tgcstat48214;
typedef struct Tnode191813 Tnode191813;
typedef struct Analysisctx404026 Analysisctx404026;
typedef struct TY404036 TY404036;
typedef struct TY404038 TY404038;
typedef struct Tnodeseq191807 Tnodeseq191807;
typedef struct Tsymseq191815 Tsymseq191815;
typedef struct Monotonicvar404024 Monotonicvar404024;
typedef struct TNimNode TNimNode;
typedef struct TY404039 TY404039;
typedef struct Ttype191849 Ttype191849;
typedef struct Tlineinfo164338 Tlineinfo164338;
typedef struct Tident168021 Tident168021;
typedef struct Tidobj168015 Tidobj168015;
typedef struct TNimObject TNimObject;
typedef struct Ttypeseq191845 Ttypeseq191845;
typedef struct Tscope191837 Tscope191837;
typedef struct TY191944 TY191944;
typedef struct Tstrtable191817 Tstrtable191817;
typedef struct Tloc191827 Tloc191827;
typedef struct Ropeobj162009 Ropeobj162009;
typedef struct Tlib191831 Tlib191831;
typedef struct Tbasechunk27438 Tbasechunk27438;
typedef struct Tfreecell27430 Tfreecell27430;
typedef struct Tinstantiation191833 Tinstantiation191833;
typedef struct Tlistentry130022 Tlistentry130022;
typedef struct TY191933 TY191933;
struct  TGenericSeq  {
NI len;
NI reserved;
};
struct  NimStringDesc  {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
struct  Tcell46346  {
NI refcount;
TNimType* typ;
};
struct  Tcellseq46362  {
NI len;
NI cap;
Tcell46346** d;
};
struct  Tcellset46358  {
NI counter;
NI max;
Tpagedesc46354* head;
Tpagedesc46354** data;
};
typedef Tsmallchunk27440* TY28222[512];
typedef Ttrunk27413* Ttrunkbuckets27415[256];
struct  Tintset27417  {
Ttrunkbuckets27415 data;
};
struct  Tmemregion28210  {
NI minlargeobj;
NI maxlargeobj;
TY28222 freesmallchunks;
Tllchunk28204* llmem;
NI currmem;
NI maxmem;
NI freemem;
NI lastsize;
Tbigchunk27442* freechunkslist;
Tintset27417 chunkstarts;
Tavlnode28208* root;
Tavlnode28208* deleted;
Tavlnode28208* last;
Tavlnode28208* freeavlnodes;
};
struct  Tgcstat48214  {
NI stackscans;
NI cyclecollections;
NI maxthreshold;
NI maxstacksize;
NI maxstackcells;
NI cycletablesize;
NI64 maxpause;
};
struct  Tgcheap48216  {
void* stackbottom;
NI cyclethreshold;
Tcellseq46362 zct;
Tcellseq46362 decstack;
Tcellset46358 cycleroots;
Tcellseq46362 tempstack;
NI recgclock;
Tmemregion28210 region;
Tgcstat48214 stat;
};
struct  Analysisctx404026  {
TY404036* locals;
TY404038* slices;
Tnodeseq191807* guards;
Tsymseq191815* args;
NI spawns;
NI currentspawnid;
NI inloop;
};
struct  Monotonicvar404024  {
Tsym191843* v;
Tsym191843* alias;
Tnode191813* lower;
Tnode191813* upper;
Tnode191813* stride;
NU8 dir;
NIM_BOOL blacklisted;
};
typedef N_NIMCALL_PTR(void, TY3289) (void* p, NI op);
typedef N_NIMCALL_PTR(void*, TY3294) (void* p);
struct  TNimType  {
NI size;
NU8 kind;
NU8 flags;
TNimType* base;
TNimNode* node;
void* finalizer;
TY3289 marker;
TY3294 deepcopy;
};
struct  TNimNode  {
NU8 kind;
NI offset;
TNimType* typ;
NCSTRING name;
NI len;
TNimNode** sons;
};
struct TY404039 {
Tnode191813* Field0;
Tnode191813* Field1;
Tnode191813* Field2;
NI Field3;
NIM_BOOL Field4;
};
struct  Tlineinfo164338  {
NI16 line;
NI16 col;
NI32 fileindex;
};
struct  Tnode191813  {
Ttype191849* typ;
Tlineinfo164338 info;
NU16 flags;
NU8 kind;
union{
struct {NI64 intval;
} S1;
struct {NF floatval;
} S2;
struct {NimStringDesc* strval;
} S3;
struct {Tsym191843* sym;
} S4;
struct {Tident168021* ident;
} S5;
struct {Tnodeseq191807* sons;
} S6;
} kindU;
NimStringDesc* comment;
};
struct  TNimObject  {
TNimType* m_type;
};
struct  Tidobj168015  {
  TNimObject Sup;
NI id;
};
struct  Tstrtable191817  {
NI counter;
Tsymseq191815* data;
};
struct  Tloc191827  {
NU8 k;
NU8 s;
NU16 flags;
Ttype191849* t;
Ropeobj162009* r;
Ropeobj162009* heaproot;
};
struct  Tsym191843  {
  Tidobj168015 Sup;
NU8 kind;
union{
struct {Ttypeseq191845* typeinstcache;
Tscope191837* typscope;
} S1;
struct {TY191944* procinstcache;
Tsym191843* gcunsafetyreason;
} S2;
struct {TY191944* usedgenerics;
Tstrtable191817 tab;
} S3;
struct {Tsym191843* guard;
} S4;
} kindU;
NU16 magic;
Ttype191849* typ;
Tident168021* name;
Tlineinfo164338 info;
Tsym191843* owner;
NU32 flags;
Tnode191813* ast;
NU32 options;
NI position;
NI offset;
Tloc191827 loc;
Tlib191831* annex;
Tnode191813* constraint;
};
struct  Tident168021  {
  Tidobj168015 Sup;
NimStringDesc* s;
Tident168021* next;
NI h;
};
typedef NimStringDesc* TY404890[6];
typedef NimStringDesc* TY165825[4];
struct  Ttype191849  {
  Tidobj168015 Sup;
NU8 kind;
NU8 callconv;
NU32 flags;
Ttypeseq191845* sons;
Tnode191813* n;
Tsym191843* owner;
Tsym191843* sym;
Tsym191843* destructor;
Tsym191843* deepcopy;
Tsym191843* assignment;
NI64 size;
NI16 align;
NI16 locklevel;
Tloc191827 loc;
};
typedef NI TY27420[16];
struct  Tpagedesc46354  {
Tpagedesc46354* next;
NI key;
TY27420 bits;
};
struct  Tbasechunk27438  {
NI prevsize;
NI size;
NIM_BOOL used;
};
struct  Tsmallchunk27440  {
  Tbasechunk27438 Sup;
Tsmallchunk27440* next;
Tsmallchunk27440* prev;
Tfreecell27430* freelist;
NI free;
NI acc;
NF data;
};
struct  Tllchunk28204  {
NI size;
NI acc;
Tllchunk28204* next;
};
struct  Tbigchunk27442  {
  Tbasechunk27438 Sup;
Tbigchunk27442* next;
Tbigchunk27442* prev;
NI align;
NF data;
};
struct  Ttrunk27413  {
Ttrunk27413* next;
NI key;
TY27420 bits;
};
typedef Tavlnode28208* TY28214[2];
struct  Tavlnode28208  {
TY28214 link;
NI key;
NI upperbound;
NI level;
};
struct  Tscope191837  {
NI depthlevel;
Tstrtable191817 symbols;
Tnodeseq191807* usingsyms;
Tscope191837* parent;
};
struct  Ropeobj162009  {
  TNimObject Sup;
Ropeobj162009* left;
Ropeobj162009* right;
NI length;
NimStringDesc* data;
};
struct  Tlistentry130022  {
  TNimObject Sup;
Tlistentry130022* prev;
Tlistentry130022* next;
};
struct  Tlib191831  {
  Tlistentry130022 Sup;
NU8 kind;
NIM_BOOL generated;
NIM_BOOL isoverriden;
Ropeobj162009* name;
Tnode191813* path;
};
struct  Tfreecell27430  {
Tfreecell27430* next;
NI zerofield;
};
struct  Tinstantiation191833  {
Tsym191843* sym;
Ttypeseq191845* concretetypes;
TY191933* usedby;
};
struct TY404036 {
  TGenericSeq Sup;
  Monotonicvar404024 data[SEQ_DECL_SIZE];
};
struct TY404038 {
  TGenericSeq Sup;
  TY404039 data[SEQ_DECL_SIZE];
};
struct Tsymseq191815 {
  TGenericSeq Sup;
  Tsym191843* data[SEQ_DECL_SIZE];
};
struct Tnodeseq191807 {
  TGenericSeq Sup;
  Tnode191813* data[SEQ_DECL_SIZE];
};
struct Ttypeseq191845 {
  TGenericSeq Sup;
  Ttype191849* data[SEQ_DECL_SIZE];
};
struct TY191944 {
  TGenericSeq Sup;
  Tinstantiation191833* data[SEQ_DECL_SIZE];
};
struct TY191933 {
  TGenericSeq Sup;
  NI32 data[SEQ_DECL_SIZE];
};
N_NIMCALL(Tsym191843*, createmagic_196986)(NimStringDesc* name, NU16 m);
static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src);
static N_INLINE(Tcell46346*, usrtocell_49846)(void* usr);
static N_INLINE(void, rtladdzct_51404)(Tcell46346* c);
N_NOINLINE(void, addzct_49817)(Tcellseq46362* s, Tcell46346* c);
N_NIMCALL(void, initanalysisctx_404059)(Analysisctx404026* Result);
N_NIMCALL(void, nimGCvisit)(void* d, NI op);
N_NIMCALL(void, TMP4003)(void* p, NI op);
N_NIMCALL(void*, newSeq)(TNimType* typ, NI len);
N_NIMCALL(void, unsureAsgnRef)(void** dest, void* src);
N_NIMCALL(void, TMP4005)(void* p, NI op);
N_NOINLINE(void, chckNil)(void* p);
N_NIMCALL(Tnode191813*, lastson_194431)(Tnode191813* n);
N_NIMCALL(void, analyse_405316)(Analysisctx404026* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, skipconv_230935)(Tnode191813* n);
static N_INLINE(Tnode191813*, HEX5BHEX5D_192244)(Tnode191813* n, NI i);
N_NIMCALL(NIM_BOOL, issingleassignable_404356)(Tnode191813* n);
N_NIMCALL(NIM_BOOL, islocal_404416)(Tnode191813* n);
N_NIMCALL(Monotonicvar404024*, getslot_404209)(Analysisctx404026* c, Tsym191843* v);
N_NIMCALL(NI, lookupslot_404132)(Analysisctx404026* c, Tsym191843* s);
N_NIMCALL(TGenericSeq*, setLengthSeq)(TGenericSeq* seq, NI elemsize, NI newlen);
N_NIMCALL(void, invalidatefacts_322487)(Tnodeseq191807** m, Tnode191813* n);
N_NIMCALL(NU16, getmagic_220403)(Tnode191813* op);
N_NIMCALL(void, gatherargs_404244)(Analysisctx404026* c, Tnode191813* n);
static N_INLINE(NI, safelen_192125)(Tnode191813* n);
N_NIMCALL(Tsym191843*, getroot_360403)(Tnode191813* n);
N_NIMCALL(TGenericSeq*, incrSeq)(TGenericSeq* seq, NI elemsize);
N_NIMCALL(void, analysesons_405324)(Analysisctx404026* c, Tnode191813* n);
N_NIMCALL(void, addasgnfact_324486)(Tnodeseq191807** m, Tnode191813* key, Tnode191813* value);
N_NIMCALL(void, analysecall_405422)(Analysisctx404026* c, Tnode191813* n, Tsym191843* op);
static N_INLINE(NIM_BOOL, eqStrings)(NimStringDesc* a, NimStringDesc* b);
N_NIMCALL(NIM_BOOL, fromsystem_405393)(Tsym191843* op);
N_NIMCALL(Tsym191843*, getmodule_199243)(Tsym191843* s);
N_NIMCALL(Tnode191813*, min_405371)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(void, addslice_404835)(Analysisctx404026* c, Tnode191813* n, Tnode191813* x, Tnode191813* le_404841, Tnode191813* ri_404842);
N_NIMCALL(void, checklocal_404476)(Analysisctx404026* c, Tnode191813* n);
N_NIMCALL(void, localerror_166166)(Tlineinfo164338 info, NimStringDesc* arg);
N_NIMCALL(Tnode191813*, canon_321735)(Tnode191813* n);
N_NIMCALL(void, addlowerboundasfacts_404573)(Analysisctx404026* c);
N_NIMCALL(void, addfactle_324249)(Tnodeseq191807** m, Tnode191813* a, Tnode191813* b);
N_NIMCALL(Tnode191813*, newsymnode_193325)(Tsym191843* sym);
N_NIMCALL(void, checkbounds_404560)(Analysisctx404026* c, Tnode191813* arr, Tnode191813* idx);
N_NIMCALL(void, checkle_404545)(Analysisctx404026* c, Tnode191813* a, Tnode191813* b);
N_NIMCALL(NU8, provele_324223)(Tnodeseq191807* m, Tnode191813* a, Tnode191813* b);
static N_INLINE(void, appendString)(NimStringDesc* dest, NimStringDesc* src);
N_NIMCALL(NimStringDesc*, rendertree_213058)(Tnode191813* n, NU8 renderflags);
N_NIMCALL(NimStringDesc*, rawNewString)(NI space);
N_NIMCALL(Tnode191813*, lowbound_321597)(Tnode191813* x);
N_NIMCALL(Tnode191813*, highbound_321607)(Tnode191813* x);
N_NIMCALL(void, genericAssign)(void* dest, void* src, TNimType* mt);
static N_INLINE(NI, len_192097)(Tnode191813* n);
N_NIMCALL(void, internalerror_166199)(Tlineinfo164338 info, NimStringDesc* errmsg);
N_NIMCALL(void, analysecase_405491)(Analysisctx404026* c, Tnode191813* n);
N_NIMCALL(void, addcasebranchfacts_324537)(Tnodeseq191807** m, Tnode191813* n, NI i);
N_NIMCALL(void, analyseif_405610)(Analysisctx404026* c, Tnode191813* n);
N_NIMCALL(void, addfact_322220)(Tnodeseq191807** m, Tnode191813* n_322224);
N_NIMCALL(void, addfactneg_322254)(Tnodeseq191807** m, Tnode191813* n_322258);
N_NIMCALL(NIM_BOOL, istrue_329188)(Tnode191813* n);
N_NIMCALL(NIM_BOOL, hassubnodewith_196439)(Tnode191813* n, NU8 kind);
N_NIMCALL(void, checkslicesaredisjoint_405057)(Analysisctx404026* c);
N_NIMCALL(void, overlap_404883)(Tnodeseq191807* m, Tnode191813* x, Tnode191813* y, Tnode191813* c, Tnode191813* d);
N_NIMCALL(NimStringDesc*, nsuFormatOpenArray)(NimStringDesc* formatstr, NimStringDesc** a, NI aLen0);
N_NIMCALL(Tnode191813*, substride_404991)(Analysisctx404026* c, Tnode191813* n);
N_NIMCALL(Tnode191813*, HEX2BHEX40_322010)(Tnode191813* a, NI64 b);
N_NIMCALL(Tnode191813*, shallowcopy_195817)(Tnode191813* src);
N_NIMCALL(NIM_BOOL, sametree_322290)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(NI64, simpleslice_323264)(Tnode191813* a, Tnode191813* b);
N_NIMCALL(NI64, stride_404918)(Analysisctx404026* c, Tnode191813* n);
N_NIMCALL(void, checkargs_406233)(Analysisctx404026* a, Tnode191813* n);
N_NIMCALL(Tnode191813*, newnodei_193351)(NU8 kind, Tlineinfo164338 info);
N_NIMCALL(Tsym191843*, newsym_192656)(NU8 symkind, Tident168021* name, Tsym191843* owner, Tlineinfo164338 info);
N_NIMCALL(Tident168021*, getident_168463)(NimStringDesc* identifier);
N_NIMCALL(Tsym191843*, getcompilerproc_239036)(NimStringDesc* name);
N_NIMCALL(void, addvar_358047)(Tnode191813* father, Tnode191813* v);
N_NIMCALL(Tnode191813*, genaddrof_359864)(Tnode191813* n);
N_NIMCALL(void, generatealiaschecks_406244)(Analysisctx404026* a, Tnode191813* result);
N_NIMCALL(void, add_192164)(Tnode191813* father, Tnode191813* son);
N_NIMCALL(Tnode191813*, callcodegenproc_359886)(NimStringDesc* name, Tnode191813* arg1, Tnode191813* arg2, Tnode191813* arg3);
N_NIMCALL(Tnode191813*, transformspawn_406060)(Tsym191843* owner, Tnode191813* n, Tnode191813* barrier);
N_NIMCALL(Tnode191813*, transformslices_405982)(Tnode191813* n);
N_NIMCALL(Tnode191813*, copynode_195640)(Tnode191813* src);
N_NIMCALL(NU8, spawnresult_359965)(Ttype191849* t, NIM_BOOL inparallel);
N_NIMCALL(Tnode191813*, wrapprocforspawn_360607)(Tsym191843* owner, Tnode191813* spawnexpr, Ttype191849* rettype, Tnode191813* barrier, Tnode191813* dest);
N_NIMCALL(Tnode191813*, transformspawnsons_406068)(Tsym191843* owner, Tnode191813* n, Tnode191813* barrier);
STRING_LITERAL(TMP954, "slice", 5);
STRING_LITERAL(TMP4006, "+=", 2);
STRING_LITERAL(TMP4007, "[]", 2);
STRING_LITERAL(TMP4008, "invalid usage of counter after increment", 40);
STRING_LITERAL(TMP4014, "cannot prove: ", 14);
STRING_LITERAL(TMP4015, " <= ", 4);
STRING_LITERAL(TMP4016, "can prove: ", 11);
STRING_LITERAL(TMP4017, " > ", 3);
STRING_LITERAL(TMP4018, "[]=", 3);
STRING_LITERAL(TMP4019, "invalid control flow for \'parallel\'", 35);
STRING_LITERAL(TMP4020, "slot already has a lower bound", 30);
STRING_LITERAL(TMP4021, "\'parallel\' section without \'spawn\'", 34);
STRING_LITERAL(TMP4022, "cannot prove: $# > $#; required for ($#)..($#) disjoint from ($"
"#)..($#)", 71);
STRING_LITERAL(TMP4023, "($#)..($#) not disjoint from ($#)..($#)", 39);
STRING_LITERAL(TMP4024, "cannot prove ($#)..($#) disjoint from ($#)..($#)", 48);
STRING_LITERAL(TMP4025, "barrier", 7);
STRING_LITERAL(TMP4026, "Barrier", 7);
STRING_LITERAL(TMP4027, "openBarrier", 11);
STRING_LITERAL(TMP4028, "invalid context for \'spawn\'", 27);
STRING_LITERAL(TMP4029, "closeBarrier", 12);
Tsym191843* opslice_404055;
extern Tgcheap48216 gch_48244;
TNimType NTI404024; /* MonotonicVar */
extern TNimType NTI191811; /* PSym */
extern TNimType NTI191805; /* PNode */
TNimType NTI404022; /* TDirection */
extern TNimType NTI138; /* bool */
TNimType NTI404036; /* seq[MonotonicVar] */
TNimType NTI404039; /* tuple[x: PNode, a: PNode, b: PNode, spawnId: int, inLoop: bool] */
extern TNimType NTI108; /* int */
TNimType NTI404038; /* seq[tuple[x: PNode, a: PNode, b: PNode, spawnId: int, inLoop: bool]] */
extern TNimType NTI191815; /* TSymSeq */
extern TNimType NTI191807; /* TNodeSeq */
extern Tnode191813* emptynode_192807;

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

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

static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src) {
	{
		Tcell46346* c;
		if (!!((src == NIM_NIL))) goto LA3;
		c = usrtocell_49846(src);
		(*c).refcount += ((NI) 8);
	}
	LA3: ;
	{
		Tcell46346* c;
		if (!!(((*dest) == NIM_NIL))) goto LA7;
		c = usrtocell_49846((*dest));
		{
			(*c).refcount -= ((NI) 8);
			if (!((NU32)((*c).refcount) < (NU32)(((NI) 8)))) goto LA11;
			rtladdzct_51404(c);
		}
		LA11: ;
	}
	LA7: ;
	(*dest) = src;
}
N_NIMCALL(void, TMP4003)(void* p, NI op) {
	TY404036* a;
	NI LOC1;
	a = (TY404036*)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, TMP4005)(void* p, NI op) {
	TY404038* a;
	NI LOC1;
	a = (TY404038*)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_404059)(Analysisctx404026* Result) {
	unsureAsgnRef((void**) (&(*Result).locals), (TY404036*) newSeq((&NTI404036), 0));
	unsureAsgnRef((void**) (&(*Result).slices), (TY404038*) newSeq((&NTI404038), 0));
	unsureAsgnRef((void**) (&(*Result).args), (Tsymseq191815*) newSeq((&NTI191815), 0));
	unsureAsgnRef((void**) (&(*Result).guards), (Tnodeseq191807*) newSeq((&NTI191807), 0));
}

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

N_NIMCALL(NIM_BOOL, issingleassignable_404356)(Tnode191813* n) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	Tsym191843* 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;
}

N_NIMCALL(NIM_BOOL, islocal_404416)(Tnode191813* n) {
	NIM_BOOL result;
	NIM_BOOL LOC1;
	Tsym191843* 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_404132)(Analysisctx404026* c, Tsym191843* s) {
	NI result;
{	result = 0;
	{
		NI i_404163;
		NI HEX3Atmp_404187;
		NI res_404190;
		i_404163 = 0;
		HEX3Atmp_404187 = 0;
		HEX3Atmp_404187 = (((*c).locals ? (*c).locals->Sup.len : 0) - 1);
		res_404190 = ((NI) 0);
		{
			while (1) {
				if (!(res_404190 <= HEX3Atmp_404187)) goto LA3;
				i_404163 = res_404190;
				{
					NIM_BOOL LOC6;
					LOC6 = 0;
					LOC6 = ((*c).locals->data[i_404163].v == s);
					if (LOC6) goto LA7;
					LOC6 = ((*c).locals->data[i_404163].alias == s);
					LA7: ;
					if (!LOC6) goto LA8;
					result = i_404163;
					goto BeforeRet;
				}
				LA8: ;
				res_404190 += ((NI) 1);
			} LA3: ;
		}
	}
	result = ((NI) -1);
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Monotonicvar404024*, getslot_404209)(Analysisctx404026* c, Tsym191843* v) {
	Monotonicvar404024* result;
	NI s;
	NI L;
{	result = 0;
	s = lookupslot_404132((&(*c)), v);
	{
		if (!(((NI) 0) <= s)) goto LA3;
		result = (&(*c).locals->data[s]);
		goto BeforeRet;
	}
	LA3: ;
	L = ((*c).locals ? (*c).locals->Sup.len : 0);
	(*c).locals = (TY404036*) setLengthSeq(&((*c).locals)->Sup, sizeof(Monotonicvar404024), ((NI) ((NI)(L + ((NI) 1)))));
	asgnRefNoCycle((void**) (&(*c).locals->data[L].v), v);
	result = (&(*c).locals->data[L]);
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

static N_INLINE(NI, safelen_192125)(Tnode191813* 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 = ((NI) 0);
	}
	goto LA1;
	LA5: ;
	{
		result = ((*n).kindU.S6.sons ? (*n).kindU.S6.sons->Sup.len : 0);
	}
	LA1: ;
	return result;
}

N_NIMCALL(void, gatherargs_404244)(Analysisctx404026* c, Tnode191813* n) {
	{
		NI i_404268;
		NI HEX3Atmp_404322;
		NI LOC2;
		NI res_404325;
		i_404268 = 0;
		HEX3Atmp_404322 = 0;
		LOC2 = 0;
		LOC2 = safelen_192125(n);
		HEX3Atmp_404322 = (LOC2 - 1);
		res_404325 = ((NI) 0);
		{
			while (1) {
				Tsym191843* root;
				Tnode191813* LOC5;
				Tnode191813* LOC18;
				if (!(res_404325 <= HEX3Atmp_404322)) goto LA4;
				i_404268 = res_404325;
				LOC5 = 0;
				LOC5 = HEX5BHEX5D_192244(n, i_404268);
				root = getroot_360403(LOC5);
				{
					if (!!((root == NIM_NIL))) goto LA8;
					{
						{
							Tsym191843* r_404292;
							Tsymseq191815* HEX3Atmp_404316;
							NI i_404319;
							NI L_404321;
							r_404292 = 0;
							HEX3Atmp_404316 = 0;
							HEX3Atmp_404316 = (*c).args;
							i_404319 = ((NI) 0);
							L_404321 = (HEX3Atmp_404316 ? HEX3Atmp_404316->Sup.len : 0);
							{
								while (1) {
									if (!(i_404319 < L_404321)) goto LA13;
									r_404292 = HEX3Atmp_404316->data[i_404319];
									{
										if (!(r_404292 == root)) goto LA16;
										goto LA10;
									}
									LA16: ;
									i_404319 += ((NI) 1);
								} LA13: ;
							}
						}
						(*c).args = (Tsymseq191815*) incrSeq(&((*c).args)->Sup, sizeof(Tsym191843*));
						asgnRefNoCycle((void**) (&(*c).args->data[(*c).args->Sup.len-1]), root);
					} LA10: ;
				}
				LA8: ;
				LOC18 = 0;
				LOC18 = HEX5BHEX5D_192244(n, i_404268);
				gatherargs_404244(c, LOC18);
				res_404325 += ((NI) 1);
			} LA4: ;
		}
	}
}

N_NIMCALL(void, analysesons_405324)(Analysisctx404026* c, Tnode191813* n) {
	{
		NI i_405347;
		NI HEX3Atmp_405349;
		NI LOC2;
		NI res_405352;
		i_405347 = 0;
		HEX3Atmp_405349 = 0;
		LOC2 = 0;
		LOC2 = safelen_192125(n);
		HEX3Atmp_405349 = (LOC2 - 1);
		res_405352 = ((NI) 0);
		{
			while (1) {
				Tnode191813* LOC5;
				if (!(res_405352 <= HEX3Atmp_405349)) goto LA4;
				i_405347 = res_405352;
				LOC5 = 0;
				LOC5 = HEX5BHEX5D_192244(n, i_405347);
				analyse_405316(c, LOC5);
				res_405352 += ((NI) 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)), (*a).Sup.len);
	LOC11 = (LOC13 == ((NI32) 0));
	LA12: ;
	result = LOC11;
	goto BeforeRet;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, fromsystem_405393)(Tsym191843* op) {
	NIM_BOOL result;
	Tsym191843* LOC1;
	result = 0;
	LOC1 = 0;
	LOC1 = getmodule_199243(op);
	result = (((*LOC1).flags &(1<<((((NU8) 13))&31)))!=0);
	return result;
}

N_NIMCALL(Tnode191813*, min_405371)(Tnode191813* a, Tnode191813* b) {
	Tnode191813* 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_404476)(Analysisctx404026* c, Tnode191813* n) {
	{
		NIM_BOOL LOC3;
		NI s;
		LOC3 = 0;
		LOC3 = islocal_404416(n);
		if (!LOC3) goto LA4;
		s = lookupslot_404132(c, (*n).kindU.S4.sym);
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = (((NI) 0) <= s);
			if (!(LOC8)) goto LA9;
			LOC8 = !(((*c).locals->data[s].stride == NIM_NIL));
			LA9: ;
			if (!LOC8) goto LA10;
			localerror_166166((*n).info, ((NimStringDesc*) &TMP4008));
		}
		LA10: ;
	}
	goto LA1;
	LA4: ;
	{
		{
			NI i_404513;
			NI HEX3Atmp_404516;
			NI LOC14;
			NI res_404519;
			i_404513 = 0;
			HEX3Atmp_404516 = 0;
			LOC14 = 0;
			LOC14 = safelen_192125(n);
			HEX3Atmp_404516 = (LOC14 - 1);
			res_404519 = ((NI) 0);
			{
				while (1) {
					if (!(res_404519 <= HEX3Atmp_404516)) goto LA16;
					i_404513 = res_404519;
					checklocal_404476(c, (*n).kindU.S6.sons->data[i_404513]);
					res_404519 += ((NI) 1);
				} LA16: ;
			}
		}
	}
	LA1: ;
}

N_NIMCALL(void, addlowerboundasfacts_404573)(Analysisctx404026* c) {
	{
		Monotonicvar404024 v_404811;
		TY404036* HEX3Atmp_404814;
		NI i_404817;
		NI L_404819;
		memset((void*)(&v_404811), 0, sizeof(v_404811));
		HEX3Atmp_404814 = 0;
		HEX3Atmp_404814 = (*c).locals;
		i_404817 = ((NI) 0);
		L_404819 = (HEX3Atmp_404814 ? HEX3Atmp_404814->Sup.len : 0);
		{
			while (1) {
				if (!(i_404817 < L_404819)) goto LA3;
				memcpy((void*)(&v_404811), (NIM_CONST void*)(&HEX3Atmp_404814->data[i_404817]), sizeof(v_404811));
				{
					Tnode191813* LOC8;
					if (!!(v_404811.blacklisted)) goto LA6;
					LOC8 = 0;
					LOC8 = newsymnode_193325(v_404811.v);
					addfactle_324249((&(*c).guards), v_404811.lower, LOC8);
				}
				LA6: ;
				i_404817 += ((NI) 1);
			} LA3: ;
		}
	}
}

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

N_NIMCALL(void, checkle_404545)(Analysisctx404026* c, Tnode191813* a, Tnode191813* b) {
	NU8 LOC1;
	LOC1 = 0;
	LOC1 = provele_324223((*c).guards, a, b);
	switch (LOC1) {
	case ((NU8) 0):
	{
		NimStringDesc* LOC3;
		NimStringDesc* LOC4;
		NimStringDesc* LOC5;
		LOC3 = 0;
		LOC4 = 0;
		LOC4 = rendertree_213058(a, 0);
		LOC5 = 0;
		LOC5 = rendertree_213058(b, 0);
		LOC3 = rawNewString(LOC4->Sup.len + LOC5->Sup.len + 18);
appendString(LOC3, ((NimStringDesc*) &TMP4014));
appendString(LOC3, LOC4);
appendString(LOC3, ((NimStringDesc*) &TMP4015));
appendString(LOC3, LOC5);
		localerror_166166((*a).info, LOC3);
	}
	break;
	case ((NU8) 2):
	{
	}
	break;
	case ((NU8) 1):
	{
		NimStringDesc* LOC8;
		NimStringDesc* LOC9;
		NimStringDesc* LOC10;
		LOC8 = 0;
		LOC9 = 0;
		LOC9 = rendertree_213058(a, 0);
		LOC10 = 0;
		LOC10 = rendertree_213058(b, 0);
		LOC8 = rawNewString(LOC9->Sup.len + LOC10->Sup.len + 14);
appendString(LOC8, ((NimStringDesc*) &TMP4016));
appendString(LOC8, LOC9);
appendString(LOC8, ((NimStringDesc*) &TMP4017));
appendString(LOC8, LOC10);
		localerror_166166((*a).info, LOC8);
	}
	break;
	}
}

N_NIMCALL(void, checkbounds_404560)(Analysisctx404026* c, Tnode191813* arr, Tnode191813* idx) {
	Tnode191813* LOC1;
	Tnode191813* LOC2;
	LOC1 = 0;
	LOC1 = lowbound_321597(arr);
	checkle_404545(c, LOC1, idx);
	LOC2 = 0;
	LOC2 = highbound_321607(arr);
	checkle_404545(c, idx, LOC2);
}

N_NIMCALL(void, addslice_404835)(Analysisctx404026* c, Tnode191813* n, Tnode191813* x, Tnode191813* le_404841, Tnode191813* ri_404842) {
	Tnode191813* le;
	Tnode191813* ri;
	NI oldstate;
	TY404039 LOC1;
	checklocal_404476((&(*c)), n);
	le = canon_321735(le_404841);
	ri = canon_321735(ri_404842);
	oldstate = ((*c).guards ? (*c).guards->Sup.len : 0);
	addlowerboundasfacts_404573(c);
	checkbounds_404560((&(*c)), x, le);
	checkbounds_404560((&(*c)), x, ri);
	(*c).guards = (Tnodeseq191807*) setLengthSeq(&((*c).guards)->Sup, sizeof(Tnode191813*), ((NI) (oldstate)));
	memset((void*)(&LOC1), 0, sizeof(LOC1));
	LOC1.Field0 = x;
	LOC1.Field1 = le;
	LOC1.Field2 = ri;
	LOC1.Field3 = (*c).currentspawnid;
	LOC1.Field4 = (((NI) 0) < (*c).inloop);
	(*c).slices = (TY404038*) incrSeq(&((*c).slices)->Sup, sizeof(TY404039));
	genericAssign((void*)(&(*c).slices->data[(*c).slices->Sup.len-1]), (void*)(&LOC1), (&NTI404039));
}

N_NIMCALL(void, analysecall_405422)(Analysisctx404026* c, Tnode191813* n, Tsym191843* op) {
	{
		NI oldspawnid;
		Tnode191813* LOC5;
		if (!((*op).magic == ((NU16) 213))) goto LA3;
		(*c).spawns += ((NI) 1);
		oldspawnid = (*c).currentspawnid;
		(*c).currentspawnid = (*c).spawns;
		LOC5 = 0;
		LOC5 = HEX5BHEX5D_192244(n, ((NI) 1));
		gatherargs_404244(c, LOC5);
		analysesons_405324(c, n);
		(*c).currentspawnid = oldspawnid;
	}
	goto LA1;
	LA3: ;
	{
		NIM_BOOL LOC7;
		NIM_BOOL LOC9;
		LOC7 = 0;
		LOC7 = ((*op).magic == ((NU16) 23));
		if (LOC7) goto LA8;
		LOC9 = 0;
		LOC9 = eqStrings((*(*op).name).s, ((NimStringDesc*) &TMP4006));
		if (!(LOC9)) goto LA10;
		LOC9 = fromsystem_405393(op);
		LA10: ;
		LOC7 = LOC9;
		LA8: ;
		if (!LOC7) goto LA11;
		{
			Tnode191813* LOC15;
			NIM_BOOL LOC16;
			Tnode191813* incr;
			Tnode191813* LOC19;
			LOC15 = 0;
			LOC15 = HEX5BHEX5D_192244(n, ((NI) 1));
			LOC16 = 0;
			LOC16 = islocal_404416(LOC15);
			if (!LOC16) goto LA17;
			LOC19 = 0;
			LOC19 = HEX5BHEX5D_192244(n, ((NI) 2));
			incr = skipconv_230935(LOC19);
			{
				NIM_BOOL LOC22;
				Monotonicvar404024* slot;
				Tnode191813* 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_192244(n, ((NI) 1));
				slot = getslot_404209(c, (*LOC26).kindU.S4.sym);
				unsureAsgnRef((void**) (&(*slot).stride), min_405371((*slot).stride, incr));
			}
			LA24: ;
		}
		LA17: ;
		analysesons_405324(c, n);
	}
	goto LA1;
	LA11: ;
	{
		NIM_BOOL LOC28;
		Tnode191813* LOC32;
		Tnode191813* LOC33;
		Tnode191813* LOC34;
		Tnode191813* LOC35;
		Tnode191813* LOC36;
		LOC28 = 0;
		LOC28 = eqStrings((*(*op).name).s, ((NimStringDesc*) &TMP4007));
		if (!(LOC28)) goto LA29;
		LOC28 = fromsystem_405393(op);
		LA29: ;
		if (!LOC28) goto LA30;
		LOC32 = 0;
		LOC32 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC33 = 0;
		LOC33 = HEX5BHEX5D_192244(n, ((NI) 2));
		LOC34 = 0;
		LOC34 = HEX5BHEX5D_192244(LOC33, ((NI) 1));
		LOC35 = 0;
		LOC35 = HEX5BHEX5D_192244(n, ((NI) 2));
		LOC36 = 0;
		LOC36 = HEX5BHEX5D_192244(LOC35, ((NI) 2));
		addslice_404835(c, n, LOC32, LOC34, LOC36);
		analysesons_405324(c, n);
	}
	goto LA1;
	LA30: ;
	{
		NIM_BOOL LOC38;
		Tnode191813* LOC42;
		Tnode191813* LOC43;
		Tnode191813* LOC44;
		Tnode191813* LOC45;
		Tnode191813* LOC46;
		LOC38 = 0;
		LOC38 = eqStrings((*(*op).name).s, ((NimStringDesc*) &TMP4018));
		if (!(LOC38)) goto LA39;
		LOC38 = fromsystem_405393(op);
		LA39: ;
		if (!LOC38) goto LA40;
		LOC42 = 0;
		LOC42 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC43 = 0;
		LOC43 = HEX5BHEX5D_192244(n, ((NI) 2));
		LOC44 = 0;
		LOC44 = HEX5BHEX5D_192244(LOC43, ((NI) 1));
		LOC45 = 0;
		LOC45 = HEX5BHEX5D_192244(n, ((NI) 2));
		LOC46 = 0;
		LOC46 = HEX5BHEX5D_192244(LOC45, ((NI) 2));
		addslice_404835(c, n, LOC42, LOC44, LOC46);
		analysesons_405324(c, n);
	}
	goto LA1;
	LA40: ;
	{
		analysesons_405324(c, n);
	}
	LA1: ;
}

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

N_NIMCALL(void, analysecase_405491)(Analysisctx404026* c, Tnode191813* n) {
	NI oldfacts;
	analyse_405316(c, (*n).kindU.S6.sons->data[((NI) 0)]);
	oldfacts = ((*c).guards ? (*c).guards->Sup.len : 0);
	{
		NI i_405525;
		NI HEX3Atmp_405579;
		NI LOC2;
		NI res_405582;
		i_405525 = 0;
		HEX3Atmp_405579 = 0;
		LOC2 = 0;
		LOC2 = len_192097(n);
		HEX3Atmp_405579 = (LOC2 - 1);
		res_405582 = ((NI) 1);
		{
			while (1) {
				Tnode191813* branch;
				if (!(res_405582 <= HEX3Atmp_405579)) goto LA4;
				i_405525 = res_405582;
				branch = (*n).kindU.S6.sons->data[i_405525];
				(*c).guards = (Tnodeseq191807*) setLengthSeq(&((*c).guards)->Sup, sizeof(Tnode191813*), ((NI) (oldfacts)));
				addcasebranchfacts_324537((&(*c).guards), n, i_405525);
				{
					NI i_405558;
					NI HEX3Atmp_405572;
					NI LOC6;
					NI res_405575;
					i_405558 = 0;
					HEX3Atmp_405572 = 0;
					LOC6 = 0;
					LOC6 = len_192097(branch);
					HEX3Atmp_405572 = (LOC6 - 1);
					res_405575 = ((NI) 0);
					{
						while (1) {
							if (!(res_405575 <= HEX3Atmp_405572)) goto LA8;
							i_405558 = res_405575;
							analyse_405316(c, (*branch).kindU.S6.sons->data[i_405558]);
							res_405575 += ((NI) 1);
						} LA8: ;
					}
				}
				res_405582 += ((NI) 1);
			} LA4: ;
		}
	}
	(*c).guards = (Tnodeseq191807*) setLengthSeq(&((*c).guards)->Sup, sizeof(Tnode191813*), ((NI) (oldfacts)));
}

N_NIMCALL(void, analyseif_405610)(Analysisctx404026* c, Tnode191813* n) {
	NI oldfacts;
	Tnode191813* LOC1;
	analyse_405316(c, (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data[((NI) 0)]);
	oldfacts = ((*c).guards ? (*c).guards->Sup.len : 0);
	LOC1 = 0;
	LOC1 = canon_321735((*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data[((NI) 0)]);
	addfact_322220((&(*c).guards), LOC1);
	analyse_405316(c, (*(*n).kindU.S6.sons->data[((NI) 0)]).kindU.S6.sons->data[((NI) 1)]);
	{
		NI i_405650;
		NI HEX3Atmp_405728;
		NI LOC3;
		NI res_405731;
		i_405650 = 0;
		HEX3Atmp_405728 = 0;
		LOC3 = 0;
		LOC3 = len_192097(n);
		HEX3Atmp_405728 = (LOC3 - 1);
		res_405731 = ((NI) 1);
		{
			while (1) {
				Tnode191813* branch;
				if (!(res_405731 <= HEX3Atmp_405728)) goto LA5;
				i_405650 = res_405731;
				branch = (*n).kindU.S6.sons->data[i_405650];
				(*c).guards = (Tnodeseq191807*) setLengthSeq(&((*c).guards)->Sup, sizeof(Tnode191813*), ((NI) (oldfacts)));
				{
					NI j_405673;
					NI HEX3Atmp_405713;
					NI res_405716;
					j_405673 = 0;
					HEX3Atmp_405713 = 0;
					HEX3Atmp_405713 = (NI)(i_405650 - ((NI) 1));
					res_405716 = ((NI) 0);
					{
						while (1) {
							Tnode191813* LOC9;
							if (!(res_405716 <= HEX3Atmp_405713)) goto LA8;
							j_405673 = res_405716;
							LOC9 = 0;
							LOC9 = canon_321735((*(*n).kindU.S6.sons->data[j_405673]).kindU.S6.sons->data[((NI) 0)]);
							addfactneg_322254((&(*c).guards), LOC9);
							res_405716 += ((NI) 1);
						} LA8: ;
					}
				}
				{
					NI LOC12;
					Tnode191813* LOC15;
					LOC12 = 0;
					LOC12 = len_192097(branch);
					if (!(((NI) 1) < LOC12)) goto LA13;
					LOC15 = 0;
					LOC15 = canon_321735((*branch).kindU.S6.sons->data[((NI) 0)]);
					addfact_322220((&(*c).guards), LOC15);
				}
				LA13: ;
				{
					NI i_405699;
					NI HEX3Atmp_405721;
					NI LOC17;
					NI res_405724;
					i_405699 = 0;
					HEX3Atmp_405721 = 0;
					LOC17 = 0;
					LOC17 = len_192097(branch);
					HEX3Atmp_405721 = (LOC17 - 1);
					res_405724 = ((NI) 0);
					{
						while (1) {
							if (!(res_405724 <= HEX3Atmp_405721)) goto LA19;
							i_405699 = res_405724;
							analyse_405316(c, (*branch).kindU.S6.sons->data[i_405699]);
							res_405724 += ((NI) 1);
						} LA19: ;
					}
				}
				res_405731 += ((NI) 1);
			} LA5: ;
		}
	}
	(*c).guards = (Tnodeseq191807*) setLengthSeq(&((*c).guards)->Sup, sizeof(Tnode191813*), ((NI) (oldfacts)));
}

N_NIMCALL(void, analyse_405316)(Analysisctx404026* c, Tnode191813* n) {
	switch ((*n).kind) {
	case ((NU8) 73):
	case ((NU8) 74):
	{
		Tnode191813* y;
		Tnode191813* LOC2;
		Tnode191813* LOC17;
		Tnode191813* value;
		Tnode191813* LOC27;
		LOC2 = 0;
		LOC2 = HEX5BHEX5D_192244(n, ((NI) 1));
		y = skipconv_230935(LOC2);
		{
			NIM_BOOL LOC5;
			Tnode191813* LOC6;
			Monotonicvar404024* slot;
			Tnode191813* LOC10;
			LOC5 = 0;
			LOC6 = 0;
			LOC6 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC5 = issingleassignable_404356(LOC6);
			if (!(LOC5)) goto LA7;
			LOC5 = islocal_404416(y);
			LA7: ;
			if (!LOC5) goto LA8;
			slot = getslot_404209(c, (*y).kindU.S4.sym);
			LOC10 = 0;
			LOC10 = HEX5BHEX5D_192244(n, ((NI) 0));
			unsureAsgnRef((void**) (&(*slot).alias), (*LOC10).kindU.S4.sym);
		}
		goto LA3;
		LA8: ;
		{
			Tnode191813* LOC12;
			NIM_BOOL LOC13;
			Monotonicvar404024* slot;
			Tnode191813* LOC16;
			LOC12 = 0;
			LOC12 = HEX5BHEX5D_192244(n, ((NI) 0));
			LOC13 = 0;
			LOC13 = islocal_404416(LOC12);
			if (!LOC13) goto LA14;
			LOC16 = 0;
			LOC16 = HEX5BHEX5D_192244(n, ((NI) 0));
			slot = getslot_404209(c, (*LOC16).kindU.S4.sym);
			(*slot).blacklisted = NIM_TRUE;
		}
		goto LA3;
		LA14: ;
		LA3: ;
		LOC17 = 0;
		LOC17 = HEX5BHEX5D_192244(n, ((NI) 0));
		invalidatefacts_322487((&(*c).guards), LOC17);
		value = HEX5BHEX5D_192244(n, ((NI) 1));
		{
			NU16 LOC20;
			NI oldspawnid;
			Tnode191813* LOC23;
			Tnode191813* LOC24;
			Tnode191813* LOC25;
			LOC20 = 0;
			LOC20 = getmagic_220403(value);
			if (!(LOC20 == ((NU16) 213))) goto LA21;
			(*c).spawns += ((NI) 1);
			oldspawnid = (*c).currentspawnid;
			(*c).currentspawnid = (*c).spawns;
			LOC23 = 0;
			LOC23 = HEX5BHEX5D_192244(value, ((NI) 1));
			gatherargs_404244(c, LOC23);
			LOC24 = 0;
			LOC24 = HEX5BHEX5D_192244(value, ((NI) 1));
			analysesons_405324(c, LOC24);
			LOC25 = 0;
			LOC25 = HEX5BHEX5D_192244(n, ((NI) 0));
			analyse_405316(c, LOC25);
			(*c).currentspawnid = oldspawnid;
		}
		goto LA18;
		LA21: ;
		{
			analysesons_405324(c, n);
		}
		LA18: ;
		LOC27 = 0;
		LOC27 = HEX5BHEX5D_192244(n, ((NI) 0));
		addasgnfact_324486((&(*c).guards), LOC27, y);
	}
	break;
	case ((NU8) 27):
	case ((NU8) 29):
	case ((NU8) 30):
	case ((NU8) 31):
	case ((NU8) 26):
	case ((NU8) 28):
	case ((NU8) 32):
	{
		{
			Tnode191813* LOC31;
			Tnode191813* LOC34;
			LOC31 = 0;
			LOC31 = HEX5BHEX5D_192244(n, ((NI) 0));
			if (!((*LOC31).kind == ((NU8) 3))) goto LA32;
			LOC34 = 0;
			LOC34 = HEX5BHEX5D_192244(n, ((NI) 0));
			analysecall_405422(c, n, (*LOC34).kindU.S4.sym);
		}
		goto LA29;
		LA32: ;
		{
			analysesons_405324(c, n);
		}
		LA29: ;
	}
	break;
	case ((NU8) 42):
	{
		Tnode191813* LOC37;
		Tnode191813* LOC38;
		Tnode191813* LOC39;
		LOC37 = 0;
		LOC37 = HEX5BHEX5D_192244(n, ((NI) 0));
		LOC38 = 0;
		LOC38 = HEX5BHEX5D_192244(n, ((NI) 1));
		LOC39 = 0;
		LOC39 = HEX5BHEX5D_192244(n, ((NI) 1));
		addslice_404835(c, n, LOC37, LOC38, LOC39);
		analysesons_405324(c, n);
	}
	break;
	case ((NU8) 109):
	case ((NU8) 108):
	case ((NU8) 106):
	{
		localerror_166166((*n).info, ((NimStringDesc*) &TMP4019));
	}
	break;
	case ((NU8) 99):
	case ((NU8) 100):
	{
		{
			Tnode191813* it_405815;
			it_405815 = 0;
			{
				NI i_405948;
				NI HEX3Atmp_405950;
				NI LOC44;
				NI res_405952;
				i_405948 = 0;
				HEX3Atmp_405950 = 0;
				LOC44 = 0;
				LOC44 = len_192097(n);
				HEX3Atmp_405950 = (LOC44 - 1);
				res_405952 = ((NI) 0);
				{
					while (1) {
						Tnode191813* value;
						NIM_BOOL isspawned;
						NU16 LOC47;
						if (!(res_405952 <= HEX3Atmp_405950)) goto LA46;
						i_405948 = res_405952;
						it_405815 = (*n).kindU.S6.sons->data[i_405948];
						value = lastson_194431(it_405815);
						LOC47 = 0;
						LOC47 = getmagic_220403(value);
						isspawned = (LOC47 == ((NU16) 213));
						{
							NI oldspawnid;
							Tnode191813* LOC52;
							Tnode191813* LOC53;
							if (!isspawned) goto LA50;
							(*c).spawns += ((NI) 1);
							oldspawnid = (*c).currentspawnid;
							(*c).currentspawnid = (*c).spawns;
							LOC52 = 0;
							LOC52 = HEX5BHEX5D_192244(value, ((NI) 1));
							gatherargs_404244(c, LOC52);
							LOC53 = 0;
							LOC53 = HEX5BHEX5D_192244(value, ((NI) 1));
							analysesons_405324(c, LOC53);
							(*c).currentspawnid = oldspawnid;
						}
						LA50: ;
						{
							if (!!(((*value).kind == ((NU8) 1)))) goto LA56;
							{
								NI j_405858;
								NI HEX3Atmp_405938;
								NI LOC59;
								NI res_405941;
								j_405858 = 0;
								HEX3Atmp_405938 = 0;
								LOC59 = 0;
								LOC59 = len_192097(it_405815);
								HEX3Atmp_405938 = (NI)(LOC59 - ((NI) 3));
								res_405941 = ((NI) 0);
								{
									while (1) {
										if (!(res_405941 <= HEX3Atmp_405938)) goto LA61;
										j_405858 = res_405941;
										{
											Tnode191813* LOC64;
											NIM_BOOL LOC65;
											Monotonicvar404024* slot;
											Tnode191813* LOC68;
											LOC64 = 0;
											LOC64 = HEX5BHEX5D_192244(it_405815, j_405858);
											LOC65 = 0;
											LOC65 = islocal_404416(LOC64);
											if (!LOC65) goto LA66;
											LOC68 = 0;
											LOC68 = HEX5BHEX5D_192244(it_405815, j_405858);
											slot = getslot_404209(c, (*LOC68).kindU.S4.sym);
											{
												if (!(*slot).lower == 0) goto LA71;
												unsureAsgnRef((void**) (&(*slot).lower), value);
											}
											goto LA69;
											LA71: ;
											{
												internalerror_166199((*it_405815).info, ((NimStringDesc*) &TMP4020));
											}
											LA69: ;
										}
										LA66: ;
										res_405941 += ((NI) 1);
									} LA61: ;
								}
							}
							{
								if (!!(isspawned)) goto LA76;
								analyse_405316(c, value);
							}
							LA76: ;
						}
						LA56: ;
						res_405952 += ((NI) 1);
					} LA46: ;
				}
			}
		}
	}
	break;
	case ((NU8) 97):
	{
		analysecase_405491(c, n);
	}
	break;
	case ((NU8) 92):
	case ((NU8) 48):
	{
		analyseif_405610(c, n);
	}
	break;
	case ((NU8) 96):
	{
		analyse_405316(c, (*n).kindU.S6.sons->data[((NI) 0)]);
		(*c).inloop += ((NI) 1);
		{
			NIM_BOOL LOC83;
			LOC83 = 0;
			LOC83 = istrue_329188((*n).kindU.S6.sons->data[((NI) 0)]);
			if (!LOC83) goto LA84;
			analysesons_405324(c, (*n).kindU.S6.sons->data[((NI) 1)]);
		}
		goto LA81;
		LA84: ;
		{
			NI oldstate;
			NI oldfacts;
			Tnode191813* LOC87;
			oldstate = ((*c).locals ? (*c).locals->Sup.len : 0);
			oldfacts = ((*c).guards ? (*c).guards->Sup.len : 0);
			LOC87 = 0;
			LOC87 = canon_321735((*n).kindU.S6.sons->data[((NI) 0)]);
			addfact_322220((&(*c).guards), LOC87);
			analyse_405316(c, (*n).kindU.S6.sons->data[((NI) 1)]);
			(*c).locals = (TY404036*) setLengthSeq(&((*c).locals)->Sup, sizeof(Monotonicvar404024), ((NI) (oldstate)));
			(*c).guards = (Tnodeseq191807*) setLengthSeq(&((*c).guards)->Sup, sizeof(Tnode191813*), ((NI) (oldfacts)));
			{
				NIM_BOOL LOC90;
				Tnode191813* LOC93;
				LOC90 = 0;
				LOC90 = hassubnodewith_196439((*n).kindU.S6.sons->data[((NI) 1)], ((NU8) 110));
				if (!!(LOC90)) goto LA91;
				LOC93 = 0;
				LOC93 = canon_321735((*n).kindU.S6.sons->data[((NI) 0)]);
				addfactneg_322254((&(*c).guards), LOC93);
			}
			LA91: ;
		}
		LA81: ;
		(*c).inloop -= ((NI) 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_405324(c, n);
	}
	break;
	}
}

N_NIMCALL(void, overlap_404883)(Tnodeseq191807* m, Tnode191813* x, Tnode191813* y, Tnode191813* c, Tnode191813* d) {
	NU8 LOC1;
	LOC1 = 0;
	LOC1 = provele_324223(m, x, d);
	switch (LOC1) {
	case ((NU8) 0):
	{
		TY404890 LOC3;
		NimStringDesc* LOC4;
		memset((void*)LOC3, 0, sizeof(LOC3));
		LOC3[0] = rendertree_213058(x, 0);
		LOC3[1] = rendertree_213058(d, 0);
		LOC3[2] = rendertree_213058(x, 0);
		LOC3[3] = rendertree_213058(y, 0);
		LOC3[4] = rendertree_213058(c, 0);
		LOC3[5] = rendertree_213058(d, 0);
		LOC4 = 0;
		LOC4 = nsuFormatOpenArray(((NimStringDesc*) &TMP4022), LOC3, 6);
		localerror_166166((*x).info, LOC4);
	}
	break;
	case ((NU8) 2):
	{
		NU8 LOC6;
		LOC6 = 0;
		LOC6 = provele_324223(m, c, y);
		switch (LOC6) {
		case ((NU8) 0):
		{
			TY404890 LOC8;
			NimStringDesc* LOC9;
			memset((void*)LOC8, 0, sizeof(LOC8));
			LOC8[0] = rendertree_213058(c, 0);
			LOC8[1] = rendertree_213058(y, 0);
			LOC8[2] = rendertree_213058(x, 0);
			LOC8[3] = rendertree_213058(y, 0);
			LOC8[4] = rendertree_213058(c, 0);
			LOC8[5] = rendertree_213058(d, 0);
			LOC9 = 0;
			LOC9 = nsuFormatOpenArray(((NimStringDesc*) &TMP4022), LOC8, 6);
			localerror_166166((*x).info, LOC9);
		}
		break;
		case ((NU8) 2):
		{
			TY165825 LOC11;
			NimStringDesc* LOC12;
			memset((void*)LOC11, 0, sizeof(LOC11));
			LOC11[0] = rendertree_213058(x, 0);
			LOC11[1] = rendertree_213058(y, 0);
			LOC11[2] = rendertree_213058(c, 0);
			LOC11[3] = rendertree_213058(d, 0);
			LOC12 = 0;
			LOC12 = nsuFormatOpenArray(((NimStringDesc*) &TMP4023), LOC11, 4);
			localerror_166166((*x).info, LOC12);
		}
		break;
		case ((NU8) 1):
		{
		}
		break;
		}
	}
	break;
	case ((NU8) 1):
	{
	}
	break;
	}
}

N_NIMCALL(Tnode191813*, substride_404991)(Analysisctx404026* c, Tnode191813* n) {
	Tnode191813* result;
	result = 0;
	{
		NIM_BOOL LOC3;
		NI s;
		LOC3 = 0;
		LOC3 = islocal_404416(n);
		if (!LOC3) goto LA4;
		s = lookupslot_404132(c, (*n).kindU.S4.sym);
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = (((NI) 0) <= s);
			if (!(LOC8)) goto LA9;
			LOC8 = !(((*c).locals->data[s].stride == NIM_NIL));
			LA9: ;
			if (!LOC8) goto LA10;
			result = HEX2BHEX40_322010(n, (*(*c).locals->data[s].stride).kindU.S1.intval);
		}
		goto LA6;
		LA10: ;
		{
			result = n;
		}
		LA6: ;
	}
	goto LA1;
	LA4: ;
	{
		NI LOC14;
		LOC14 = 0;
		LOC14 = safelen_192125(n);
		if (!(((NI) 0) < LOC14)) goto LA15;
		result = shallowcopy_195817(n);
		{
			NI i_405031;
			NI HEX3Atmp_405035;
			NI LOC18;
			NI res_405038;
			i_405031 = 0;
			HEX3Atmp_405035 = 0;
			LOC18 = 0;
			LOC18 = len_192097(n);
			HEX3Atmp_405035 = (LOC18 - 1);
			res_405038 = ((NI) 0);
			{
				while (1) {
					if (!(res_405038 <= HEX3Atmp_405035)) goto LA20;
					i_405031 = res_405038;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_405031]), substride_404991(c, (*n).kindU.S6.sons->data[i_405031]));
					res_405038 += ((NI) 1);
				} LA20: ;
			}
		}
	}
	goto LA1;
	LA15: ;
	{
		result = n;
	}
	LA1: ;
	return result;
}

N_NIMCALL(NI64, stride_404918)(Analysisctx404026* c, Tnode191813* n) {
	NI64 result;
	result = 0;
	{
		NIM_BOOL LOC3;
		NI s;
		LOC3 = 0;
		LOC3 = islocal_404416(n);
		if (!LOC3) goto LA4;
		s = lookupslot_404132(c, (*n).kindU.S4.sym);
		{
			NIM_BOOL LOC8;
			LOC8 = 0;
			LOC8 = (((NI) 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_404957;
			NI HEX3Atmp_404969;
			NI LOC14;
			NI res_404972;
			i_404957 = 0;
			HEX3Atmp_404969 = 0;
			LOC14 = 0;
			LOC14 = safelen_192125(n);
			HEX3Atmp_404969 = (LOC14 - 1);
			res_404972 = ((NI) 0);
			{
				while (1) {
					NI64 LOC17;
					if (!(res_404972 <= HEX3Atmp_404969)) goto LA16;
					i_404957 = res_404972;
					LOC17 = 0;
					LOC17 = stride_404918(c, (*n).kindU.S6.sons->data[i_404957]);
					result += LOC17;
					res_404972 += ((NI) 1);
				} LA16: ;
			}
		}
	}
	LA1: ;
	return result;
}

N_NIMCALL(void, checkslicesaredisjoint_405057)(Analysisctx404026* c) {
	addlowerboundasfacts_404573(c);
	{
		Tnode191813* x_405211;
		Tnode191813* a_405212;
		Tnode191813* b_405213;
		NI id_405214;
		NIM_BOOL inloop_405215;
		TY404038* HEX3Atmp_405260;
		NI i_405263;
		NI L_405265;
		x_405211 = 0;
		a_405212 = 0;
		b_405213 = 0;
		id_405214 = 0;
		inloop_405215 = 0;
		HEX3Atmp_405260 = 0;
		HEX3Atmp_405260 = (*c).slices;
		i_405263 = ((NI) 0);
		L_405265 = (HEX3Atmp_405260 ? HEX3Atmp_405260->Sup.len : 0);
		{
			while (1) {
				if (!(i_405263 < L_405265)) goto LA3;
				x_405211 = HEX3Atmp_405260->data[i_405263].Field0;
				a_405212 = HEX3Atmp_405260->data[i_405263].Field1;
				b_405213 = HEX3Atmp_405260->data[i_405263].Field2;
				id_405214 = HEX3Atmp_405260->data[i_405263].Field3;
				inloop_405215 = HEX3Atmp_405260->data[i_405263].Field4;
				{
					Tnode191813* LOC8;
					Tnode191813* LOC9;
					if (!inloop_405215) goto LA6;
					LOC8 = 0;
					LOC8 = substride_404991((&(*c)), a_405212);
					LOC9 = 0;
					LOC9 = substride_404991((&(*c)), b_405213);
					overlap_404883((*c).guards, a_405212, b_405213, LOC8, LOC9);
				}
				LA6: ;
				i_405263 += ((NI) 1);
			} LA3: ;
		}
	}
	{
		NI i_405226;
		NI HEX3Atmp_405276;
		NI res_405279;
		i_405226 = 0;
		HEX3Atmp_405276 = 0;
		HEX3Atmp_405276 = ((*c).slices ? ((*c).slices->Sup.len-1) : -1);
		res_405279 = ((NI) 0);
		{
			while (1) {
				if (!(res_405279 <= HEX3Atmp_405276)) goto LA12;
				i_405226 = res_405279;
				{
					NI j_405237;
					NI HEX3Atmp_405268;
					NI HEX3Atmp_405269;
					NI res_405272;
					j_405237 = 0;
					HEX3Atmp_405268 = 0;
					HEX3Atmp_405269 = 0;
					HEX3Atmp_405268 = (NI)(i_405226 + ((NI) 1));
					HEX3Atmp_405269 = ((*c).slices ? ((*c).slices->Sup.len-1) : -1);
					res_405272 = HEX3Atmp_405268;
					{
						while (1) {
							TY404039 x;
							TY404039 y;
							if (!(res_405272 <= HEX3Atmp_405269)) goto LA15;
							j_405237 = res_405272;
							memset((void*)(&x), 0, sizeof(x));
							memcpy((void*)(&x), (NIM_CONST void*)(&(*c).slices->data[i_405226]), sizeof(x));
							memset((void*)(&y), 0, sizeof(y));
							memcpy((void*)(&y), (NIM_CONST void*)(&(*c).slices->data[j_405237]), sizeof(y));
							{
								NIM_BOOL LOC18;
								LOC18 = 0;
								LOC18 = !((x.Field3 == y.Field3));
								if (!(LOC18)) goto LA19;
								LOC18 = sametree_322290(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_404883((*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_323264(x.Field1, x.Field2);
									m = simpleslice_323264(y.Field1, y.Field2);
									LOC29 = 0;
									LOC29 = (IL64(0) <= k);
									if (!(LOC29)) goto LA30;
									LOC29 = (IL64(0) <= m);
									LA30: ;
									if (!LOC29) goto LA31;
									overlap_404883((*c).guards, x.Field1, x.Field2, y.Field1, y.Field2);
									LOC33 = 0;
									LOC33 = stride_404918((&(*c)), x.Field1);
									LOC34 = 0;
									LOC34 = stride_404918((&(*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: ;
									{
										TY165825 LOC42;
										NimStringDesc* LOC43;
										memset((void*)LOC42, 0, sizeof(LOC42));
										LOC42[0] = rendertree_213058(x.Field1, 0);
										LOC42[1] = rendertree_213058(x.Field2, 0);
										LOC42[2] = rendertree_213058(y.Field1, 0);
										LOC42[3] = rendertree_213058(y.Field2, 0);
										LOC43 = 0;
										LOC43 = nsuFormatOpenArray(((NimStringDesc*) &TMP4024), LOC42, 4);
										localerror_166166((*x.Field0).info, LOC43);
									}
									LA35: ;
								}
								goto LA22;
								LA31: ;
								{
									TY165825 LOC45;
									NimStringDesc* LOC46;
									memset((void*)LOC45, 0, sizeof(LOC45));
									LOC45[0] = rendertree_213058(x.Field1, 0);
									LOC45[1] = rendertree_213058(x.Field2, 0);
									LOC45[2] = rendertree_213058(y.Field1, 0);
									LOC45[3] = rendertree_213058(y.Field2, 0);
									LOC46 = 0;
									LOC46 = nsuFormatOpenArray(((NimStringDesc*) &TMP4024), LOC45, 4);
									localerror_166166((*x.Field0).info, LOC46);
								}
								LA22: ;
							}
							LA20: ;
							res_405272 += ((NI) 1);
						} LA15: ;
					}
				}
				res_405279 += ((NI) 1);
			} LA12: ;
		}
	}
}

N_NIMCALL(void, checkargs_406233)(Analysisctx404026* a, Tnode191813* n) {
}

N_NIMCALL(void, generatealiaschecks_406244)(Analysisctx404026* a, Tnode191813* result) {
}

N_NIMCALL(Tnode191813*, transformslices_405982)(Tnode191813* n) {
	Tnode191813* result;
{	result = 0;
	{
		NIM_BOOL LOC3;
		Tnode191813* LOC5;
		Tsym191843* op;
		Tnode191813* 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_192244(n, ((NI) 0));
		LOC3 = ((*LOC5).kind == ((NU8) 3));
		LA4: ;
		if (!LOC3) goto LA6;
		LOC8 = 0;
		LOC8 = HEX5BHEX5D_192244(n, ((NI) 0));
		op = (*LOC8).kindU.S4.sym;
		{
			NIM_BOOL LOC11;
			Tnode191813* LOC15;
			Tnode191813* LOC16;
			Tnode191813* LOC17;
			Tnode191813* LOC18;
			Tnode191813* LOC19;
			Tnode191813* LOC20;
			LOC11 = 0;
			LOC11 = eqStrings((*(*op).name).s, ((NimStringDesc*) &TMP4007));
			if (!(LOC11)) goto LA12;
			LOC11 = fromsystem_405393(op);
			LA12: ;
			if (!LOC11) goto LA13;
			result = copynode_195640(n);
			LOC15 = 0;
			LOC15 = newsymnode_193325(opslice_404055);
			add_192164(result, LOC15);
			LOC16 = 0;
			LOC16 = HEX5BHEX5D_192244(n, ((NI) 1));
			add_192164(result, LOC16);
			LOC17 = 0;
			LOC17 = HEX5BHEX5D_192244(n, ((NI) 2));
			LOC18 = 0;
			LOC18 = HEX5BHEX5D_192244(LOC17, ((NI) 1));
			add_192164(result, LOC18);
			LOC19 = 0;
			LOC19 = HEX5BHEX5D_192244(n, ((NI) 2));
			LOC20 = 0;
			LOC20 = HEX5BHEX5D_192244(LOC19, ((NI) 2));
			add_192164(result, LOC20);
			goto BeforeRet;
		}
		LA13: ;
	}
	LA6: ;
	{
		NI LOC23;
		LOC23 = 0;
		LOC23 = safelen_192125(n);
		if (!(((NI) 0) < LOC23)) goto LA24;
		result = shallowcopy_195817(n);
		{
			NI i_406034;
			NI HEX3Atmp_406038;
			NI LOC27;
			NI res_406041;
			i_406034 = 0;
			HEX3Atmp_406038 = 0;
			LOC27 = 0;
			LOC27 = len_192097(n);
			HEX3Atmp_406038 = (LOC27 - 1);
			res_406041 = ((NI) 0);
			{
				while (1) {
					if (!(res_406041 <= HEX3Atmp_406038)) goto LA29;
					i_406034 = res_406041;
					asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_406034]), transformslices_405982((*n).kindU.S6.sons->data[i_406034]));
					res_406041 += ((NI) 1);
				} LA29: ;
			}
		}
	}
	goto LA21;
	LA24: ;
	{
		result = n;
	}
	LA21: ;
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, transformspawnsons_406068)(Tsym191843* owner, Tnode191813* n, Tnode191813* barrier) {
	Tnode191813* result;
	result = 0;
	result = shallowcopy_195817(n);
	{
		NI i_406093;
		NI HEX3Atmp_406097;
		NI LOC2;
		NI res_406100;
		i_406093 = 0;
		HEX3Atmp_406097 = 0;
		LOC2 = 0;
		LOC2 = len_192097(n);
		HEX3Atmp_406097 = (LOC2 - 1);
		res_406100 = ((NI) 0);
		{
			while (1) {
				if (!(res_406100 <= HEX3Atmp_406097)) goto LA4;
				i_406093 = res_406100;
				asgnRefNoCycle((void**) (&(*result).kindU.S6.sons->data[i_406093]), transformspawn_406060(owner, (*n).kindU.S6.sons->data[i_406093], barrier));
				res_406100 += ((NI) 1);
			} LA4: ;
		}
	}
	return result;
}

N_NIMCALL(Tnode191813*, transformspawn_406060)(Tsym191843* owner, Tnode191813* n, Tnode191813* barrier) {
	Tnode191813* result;
{	result = 0;
	switch ((*n).kind) {
	case ((NU8) 99):
	case ((NU8) 100):
	{
		result = NIM_NIL;
		{
			Tnode191813* it_406125;
			it_406125 = 0;
			{
				NI i_406208;
				NI HEX3Atmp_406210;
				NI LOC4;
				NI res_406212;
				i_406208 = 0;
				HEX3Atmp_406210 = 0;
				LOC4 = 0;
				LOC4 = len_192097(n);
				HEX3Atmp_406210 = (LOC4 - 1);
				res_406212 = ((NI) 0);
				{
					while (1) {
						Tnode191813* b;
						if (!(res_406212 <= HEX3Atmp_406210)) goto LA6;
						i_406208 = res_406212;
						it_406125 = (*n).kindU.S6.sons->data[i_406208];
						b = lastson_194431(it_406125);
						{
							NU16 LOC9;
							Tnode191813* m;
							Ttype191849* t;
							Tnode191813* LOC21;
							Tnode191813* LOC22;
							LOC9 = 0;
							LOC9 = getmagic_220403(b);
							if (!(LOC9 == ((NU16) 213))) goto LA10;
							{
								NI LOC14;
								LOC14 = 0;
								LOC14 = len_192097(it_406125);
								if (!!((LOC14 == ((NI) 3)))) goto LA15;
								localerror_166166((*it_406125).info, ((NimStringDesc*) &TMP4028));
							}
							LA15: ;
							m = transformslices_405982(b);
							{
								if (!result == 0) goto LA19;
								result = newnodei_193351(((NU8) 115), (*n).info);
								add_192164(result, n);
							}
							LA19: ;
							LOC21 = 0;
							LOC21 = HEX5BHEX5D_192244(b, ((NI) 1));
							LOC22 = 0;
							LOC22 = HEX5BHEX5D_192244(LOC21, ((NI) 0));
							t = (*(*LOC22).typ).sons->data[((NI) 0)];
							{
								NU8 LOC25;
								Tnode191813* LOC28;
								Tnode191813* LOC29;
								NI LOC30;
								LOC25 = 0;
								LOC25 = spawnresult_359965(t, NIM_TRUE);
								if (!(LOC25 == ((NU8) 2))) goto LA26;
								LOC28 = 0;
								LOC28 = HEX5BHEX5D_192244(it_406125, ((NI) 0));
								LOC29 = 0;
								LOC29 = wrapprocforspawn_360607(owner, m, (*b).typ, barrier, LOC28);
								add_192164(result, LOC29);
								LOC30 = 0;
								LOC30 = len_192097(it_406125);
								asgnRefNoCycle((void**) (&(*it_406125).kindU.S6.sons->data[(NI)(LOC30 - ((NI) 1))]), emptynode_192807);
							}
							goto LA23;
							LA26: ;
							{
								NI LOC32;
								LOC32 = 0;
								LOC32 = len_192097(it_406125);
								asgnRefNoCycle((void**) (&(*it_406125).kindU.S6.sons->data[(NI)(LOC32 - ((NI) 1))]), wrapprocforspawn_360607(owner, m, (*b).typ, barrier, NIM_NIL));
							}
							LA23: ;
						}
						LA10: ;
						res_406212 += ((NI) 1);
					} LA6: ;
				}
			}
		}
		{
			if (!result == 0) goto LA35;
			result = n;
		}
		LA35: ;
	}
	break;
	case ((NU8) 73):
	case ((NU8) 74):
	{
		Tnode191813* b;
		b = HEX5BHEX5D_192244(n, ((NI) 1));
		{
			NIM_BOOL LOC40;
			NU16 LOC41;
			Ttype191849* t;
			Tnode191813* LOC43;
			Tnode191813* LOC44;
			NU8 LOC45;
			Tnode191813* m;
			Tnode191813* LOC48;
			LOC40 = 0;
			LOC41 = 0;
			LOC41 = getmagic_220403(b);
			LOC40 = (LOC41 == ((NU16) 213));
			if (!(LOC40)) goto LA42;
			LOC43 = 0;
			LOC43 = HEX5BHEX5D_192244(b, ((NI) 1));
			LOC44 = 0;
			LOC44 = HEX5BHEX5D_192244(LOC43, ((NI) 0));
			t = (*(*LOC44).typ).sons->data[((NI) 0)];
			LOC45 = 0;
			LOC45 = spawnresult_359965(t, NIM_TRUE);
			LOC40 = (LOC45 == ((NU8) 2));
			LA42: ;
			if (!LOC40) goto LA46;
			m = transformslices_405982(b);
			LOC48 = 0;
			LOC48 = HEX5BHEX5D_192244(n, ((NI) 0));
			result = wrapprocforspawn_360607(owner, m, (*b).typ, barrier, LOC48);
			goto BeforeRet;
		}
		LA46: ;
		result = transformspawnsons_406068(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_220403(n);
			if (!(LOC52 == ((NU16) 213))) goto LA53;
			result = transformslices_405982(n);
			result = wrapprocforspawn_360607(owner, result, (*n).typ, barrier, NIM_NIL);
			goto BeforeRet;
		}
		LA53: ;
		result = transformspawnsons_406068(owner, n, barrier);
	}
	break;
	default:
	{
		{
			NI LOC58;
			LOC58 = 0;
			LOC58 = safelen_192125(n);
			if (!(((NI) 0) < LOC58)) goto LA59;
			result = transformspawnsons_406068(owner, n, barrier);
		}
		goto LA56;
		LA59: ;
		{
			result = n;
		}
		LA56: ;
	}
	break;
	}
	}BeforeRet: ;
	return result;
}

N_NIMCALL(Tnode191813*, liftparallel_406254)(Tsym191843* owner, Tnode191813* n) {
	Tnode191813* result;
	Analysisctx404026 a;
	Tnode191813* body;
	Tnode191813* varsection;
	Tsym191843* temp;
	Tident168021* LOC5;
	Tsym191843* LOC6;
	Tnode191813* tempnode;
	Tnode191813* barrier;
	Tnode191813* LOC7;
	Tnode191813* LOC8;
	Tnode191813* LOC9;
	result = 0;
	memset((void*)(&a), 0, sizeof(a));
	chckNil((void*)(&a));
	memset((void*)(&a), 0, sizeof(a));
	initanalysisctx_404059((&a));
	body = lastson_194431(n);
	analyse_405316((&a), body);
	{
		if (!(a.spawns == ((NI) 0))) goto LA3;
		localerror_166166((*n).info, ((NimStringDesc*) &TMP4021));
	}
	LA3: ;
	checkslicesaredisjoint_405057((&a));
	checkargs_406233((&a), body);
	varsection = newnodei_193351(((NU8) 99), (*n).info);
	LOC5 = 0;
	LOC5 = getident_168463(((NimStringDesc*) &TMP4025));
	temp = newsym_192656(((NU8) 5), LOC5, owner, (*n).info);
	LOC6 = 0;
	LOC6 = getcompilerproc_239036(((NimStringDesc*) &TMP4026));
	asgnRefNoCycle((void**) (&(*temp).typ), (*LOC6).typ);
	(*temp).flags |= ((NI32)1)<<((((NU8) 2))%(sizeof(NI32)*8));
	tempnode = newsymnode_193325(temp);
	addvar_358047(varsection, tempnode);
	barrier = genaddrof_359864(tempnode);
	result = newnodei_193351(((NU8) 115), (*n).info);
	generatealiaschecks_406244((&a), result);
	add_192164(result, varsection);
	LOC7 = 0;
	LOC7 = callcodegenproc_359886(((NimStringDesc*) &TMP4027), barrier, NIM_NIL, NIM_NIL);
	add_192164(result, LOC7);
	LOC8 = 0;
	LOC8 = transformspawn_406060(owner, body, barrier);
	add_192164(result, LOC8);
	LOC9 = 0;
	LOC9 = callcodegenproc_359886(((NimStringDesc*) &TMP4029), barrier, NIM_NIL, NIM_NIL);
	add_192164(result, LOC9);
	return result;
}
NIM_EXTERNC N_NOINLINE(void, nimsrc_semparallelInit)(void) {
	asgnRefNoCycle((void**) (&opslice_404055), createmagic_196986(((NimStringDesc*) &TMP954), ((NU16) 150)));
}

NIM_EXTERNC N_NOINLINE(void, nimsrc_semparallelDatInit)(void) {
static TNimNode* TMP3999[7];
static TNimNode* TMP4000[2];
NI TMP4002;
static char* NIM_CONST TMP4001[2] = {
"ascending", 
"descending"};
static TNimNode* TMP4004[5];
static TNimNode TMP952[17];
NTI404024.size = sizeof(Monotonicvar404024);
NTI404024.kind = 18;
NTI404024.base = 0;
NTI404024.flags = 2;
TMP3999[0] = &TMP952[1];
TMP952[1].kind = 1;
TMP952[1].offset = offsetof(Monotonicvar404024, v);
TMP952[1].typ = (&NTI191811);
TMP952[1].name = "v";
TMP3999[1] = &TMP952[2];
TMP952[2].kind = 1;
TMP952[2].offset = offsetof(Monotonicvar404024, alias);
TMP952[2].typ = (&NTI191811);
TMP952[2].name = "alias";
TMP3999[2] = &TMP952[3];
TMP952[3].kind = 1;
TMP952[3].offset = offsetof(Monotonicvar404024, lower);
TMP952[3].typ = (&NTI191805);
TMP952[3].name = "lower";
TMP3999[3] = &TMP952[4];
TMP952[4].kind = 1;
TMP952[4].offset = offsetof(Monotonicvar404024, upper);
TMP952[4].typ = (&NTI191805);
TMP952[4].name = "upper";
TMP3999[4] = &TMP952[5];
TMP952[5].kind = 1;
TMP952[5].offset = offsetof(Monotonicvar404024, stride);
TMP952[5].typ = (&NTI191805);
TMP952[5].name = "stride";
TMP3999[5] = &TMP952[6];
NTI404022.size = sizeof(NU8);
NTI404022.kind = 14;
NTI404022.base = 0;
NTI404022.flags = 3;
for (TMP4002 = 0; TMP4002 < 2; TMP4002++) {
TMP952[TMP4002+7].kind = 1;
TMP952[TMP4002+7].offset = TMP4002;
TMP952[TMP4002+7].name = TMP4001[TMP4002];
TMP4000[TMP4002] = &TMP952[TMP4002+7];
}
TMP952[9].len = 2; TMP952[9].kind = 2; TMP952[9].sons = &TMP4000[0];
NTI404022.node = &TMP952[9];
TMP952[6].kind = 1;
TMP952[6].offset = offsetof(Monotonicvar404024, dir);
TMP952[6].typ = (&NTI404022);
TMP952[6].name = "dir";
TMP3999[6] = &TMP952[10];
TMP952[10].kind = 1;
TMP952[10].offset = offsetof(Monotonicvar404024, blacklisted);
TMP952[10].typ = (&NTI138);
TMP952[10].name = "blacklisted";
TMP952[0].len = 7; TMP952[0].kind = 2; TMP952[0].sons = &TMP3999[0];
NTI404024.node = &TMP952[0];
NTI404036.size = sizeof(TY404036*);
NTI404036.kind = 24;
NTI404036.base = (&NTI404024);
NTI404036.flags = 2;
NTI404036.marker = TMP4003;
NTI404039.size = sizeof(TY404039);
NTI404039.kind = 18;
NTI404039.base = 0;
NTI404039.flags = 2;
TMP4004[0] = &TMP952[12];
TMP952[12].kind = 1;
TMP952[12].offset = offsetof(TY404039, Field0);
TMP952[12].typ = (&NTI191805);
TMP952[12].name = "Field0";
TMP4004[1] = &TMP952[13];
TMP952[13].kind = 1;
TMP952[13].offset = offsetof(TY404039, Field1);
TMP952[13].typ = (&NTI191805);
TMP952[13].name = "Field1";
TMP4004[2] = &TMP952[14];
TMP952[14].kind = 1;
TMP952[14].offset = offsetof(TY404039, Field2);
TMP952[14].typ = (&NTI191805);
TMP952[14].name = "Field2";
TMP4004[3] = &TMP952[15];
TMP952[15].kind = 1;
TMP952[15].offset = offsetof(TY404039, Field3);
TMP952[15].typ = (&NTI108);
TMP952[15].name = "Field3";
TMP4004[4] = &TMP952[16];
TMP952[16].kind = 1;
TMP952[16].offset = offsetof(TY404039, Field4);
TMP952[16].typ = (&NTI138);
TMP952[16].name = "Field4";
TMP952[11].len = 5; TMP952[11].kind = 2; TMP952[11].sons = &TMP4004[0];
NTI404039.node = &TMP952[11];
NTI404038.size = sizeof(TY404038*);
NTI404038.kind = 24;
NTI404038.base = (&NTI404039);
NTI404038.flags = 2;
NTI404038.marker = TMP4005;
}

