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

#include <time.h>

#include <sys/time.h>

#include <string.h>

#include <sys/select.h>
typedef struct ttimeinterval93005 ttimeinterval93005;
typedef struct ttimeinfo93003 ttimeinfo93003;
typedef struct TNimObject TNimObject;
typedef struct TNimType TNimType;
typedef struct TNimNode TNimNode;
typedef struct NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
typedef struct TY93105 TY93105;
typedef struct tslice79092 tslice79092;
typedef struct einvalidvalue2453 einvalidvalue2453;
typedef struct esynch2429 esynch2429;
typedef struct E_Base E_Base;
typedef struct tcell41290 tcell41290;
typedef struct tcellseq41306 tcellseq41306;
typedef struct tgcheap43216 tgcheap43216;
typedef struct tcellset41302 tcellset41302;
typedef struct tpagedesc41298 tpagedesc41298;
typedef struct tmemregion23610 tmemregion23610;
typedef struct tsmallchunk22838 tsmallchunk22838;
typedef struct tllchunk23604 tllchunk23604;
typedef struct tbigchunk22840 tbigchunk22840;
typedef struct tintset22815 tintset22815;
typedef struct ttrunk22811 ttrunk22811;
typedef struct tavlnode23608 tavlnode23608;
typedef struct tgcstat43214 tgcstat43214;
typedef struct tbasechunk22836 tbasechunk22836;
typedef struct tfreecell22828 tfreecell22828;
struct  ttimeinterval93005  {
NI Miliseconds;
NI Seconds;
NI Minutes;
NI Hours;
NI Days;
NI Months;
NI Years;
};
typedef N_NIMCALL_PTR(void, TY2289) (void* p, NI op);
struct  TNimType  {
NI size;
NU8 kind;
NU8 flags;
TNimType* base;
TNimNode* node;
void* finalizer;
TY2289 marker;
};
struct  TNimObject  {
TNimType* m_type;
};
struct  TGenericSeq  {
NI len;
NI reserved;
};
struct  NimStringDesc  {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
struct  ttimeinfo93003  {
  TNimObject Sup;
NI Second;
NI Minute;
NI Hour;
NI Monthday;
NU8 Month;
NI Year;
NU8 Weekday;
NI Yearday;
NIM_BOOL Isdst;
NimStringDesc* Tzname;
NI Timezone;
};
struct  TNimNode  {
NU8 kind;
NI offset;
TNimType* typ;
NCSTRING name;
NI len;
TNimNode** sons;
};
typedef NU8 TY93650[7];
struct TY93105 {
NimStringDesc* Field0;
NimStringDesc* Field1;
};
typedef NI8 TY93669[7];
typedef NimStringDesc* TY94829[7];
typedef NimStringDesc* TY94841[12];
struct  tslice79092  {
NI A;
NI B;
};
struct  E_Base  {
  TNimObject Sup;
E_Base* parent;
NCSTRING name;
NimStringDesc* message;
NimStringDesc* trace;
};
struct  esynch2429  {
  E_Base Sup;
};
struct  einvalidvalue2453  {
  esynch2429 Sup;
};
struct  tcell41290  {
NI Refcount;
TNimType* Typ;
};
struct  tcellseq41306  {
NI Len;
NI Cap;
tcell41290** D;
};
struct  tcellset41302  {
NI Counter;
NI Max;
tpagedesc41298* Head;
tpagedesc41298** Data;
};
typedef tsmallchunk22838* TY23622[512];
typedef ttrunk22811* ttrunkbuckets22813[256];
struct  tintset22815  {
ttrunkbuckets22813 Data;
};
struct  tmemregion23610  {
NI Minlargeobj;
NI Maxlargeobj;
TY23622 Freesmallchunks;
tllchunk23604* Llmem;
NI Currmem;
NI Maxmem;
NI Freemem;
NI Lastsize;
tbigchunk22840* Freechunkslist;
tintset22815 Chunkstarts;
tavlnode23608* Root;
tavlnode23608* Deleted;
tavlnode23608* Last;
tavlnode23608* Freeavlnodes;
};
struct  tgcstat43214  {
NI Stackscans;
NI Cyclecollections;
NI Maxthreshold;
NI Maxstacksize;
NI Maxstackcells;
NI Cycletablesize;
NI64 Maxpause;
};
struct  tgcheap43216  {
void* Stackbottom;
NI Cyclethreshold;
tcellseq41306 Zct;
tcellseq41306 Decstack;
tcellset41302 Cycleroots;
tcellseq41306 Tempstack;
NI Recgclock;
tmemregion23610 Region;
tgcstat43214 Stat;
};
typedef NI TY22818[16];
struct  tpagedesc41298  {
tpagedesc41298* Next;
NI Key;
TY22818 Bits;
};
struct  tbasechunk22836  {
NI Prevsize;
NI Size;
NIM_BOOL Used;
};
struct  tsmallchunk22838  {
  tbasechunk22836 Sup;
tsmallchunk22838* Next;
tsmallchunk22838* Prev;
tfreecell22828* Freelist;
NI Free;
NI Acc;
NF Data;
};
struct  tllchunk23604  {
NI Size;
NI Acc;
tllchunk23604* Next;
};
struct  tbigchunk22840  {
  tbasechunk22836 Sup;
tbigchunk22840* Next;
tbigchunk22840* Prev;
NI Align;
NF Data;
};
struct  ttrunk22811  {
ttrunk22811* Next;
NI Key;
TY22818 Bits;
};
typedef tavlnode23608* TY23614[2];
struct  tavlnode23608  {
TY23614 Link;
NI Key;
NI Upperbound;
NI Level;
};
struct  tfreecell22828  {
tfreecell22828* Next;
NI Zerofield;
};
N_NIMCALL(time_t, fromseconds_93056)(NI64 since1970);
static N_INLINE(void, nimFrame)(TFrame* s);
static N_INLINE(void, popFrame)(void);
N_NIMCALL(NIM_BOOL, ntLtTime)(time_t a, time_t b);
N_NIMCALL(NIM_BOOL, ntLeTime)(time_t a, time_t b);
N_NIMCALL(NIM_BOOL, ntEqTime)(time_t a, time_t b);
N_NIMCALL(ttimeinterval93005, initinterval_93208)(NI miliseconds, NI seconds, NI minutes, NI hours, NI days, NI months, NI years);
N_NIMCALL(NIM_BOOL, isleapyear_93220)(NI year);
static N_INLINE(NI, modInt)(NI a, NI b);
N_NOINLINE(void, raiseDivByZero)(void);
N_NIMCALL(NI, getdaysinmonth_93231)(NU8 month, NI year);
static N_INLINE(void, HEX2BHEX3D_93275)(NF* x_93281, NF y_93284);
N_NIMCALL(NF, toseconds_93240)(ttimeinfo93003* a, ttimeinterval93005* interval);
N_NIMCALL(void, genericAssign)(void* dest, void* src, TNimType* mt);
N_NIMCALL(NI, mulInt)(NI a, NI b);
static N_INLINE(NI, addInt)(NI a, NI b);
N_NOINLINE(void, raiseOverflow)(void);
static N_INLINE(NF, HEX2F_79038)(NI x, NI y);
N_NIMCALL(void, HEX2B_93407)(ttimeinfo93003* a, ttimeinterval93005* interval, ttimeinfo93003* Result);
static N_INLINE(NIM_BOOL, eqStrings)(NimStringDesc* a, NimStringDesc* b);
N_NOINLINE(void, chckNil)(void* p);
N_NIMCALL(void, genericReset)(void* dest, TNimType* mt);
N_NIMCALL(void, HEX2D_93416)(ttimeinfo93003* a, ttimeinterval93005* interval, ttimeinfo93003* Result);
N_NIMCALL(void, tmtotimeinfo_93644)(struct tm* tm, NIM_BOOL local, ttimeinfo93003* Result);
static N_INLINE(NI, chckRange)(NI i, NI a, NI b);
N_NOINLINE(void, raiseRangeError)(NI64 val);
N_NOINLINE(void, raiseIndexError)(void);
N_NIMCALL(void, gettzname_93103)(TY93105* Result);
N_NIMCALL(NimStringDesc*, cstrToNimstr)(NCSTRING str);
N_NIMCALL(void, unsureAsgnRef)(void** dest, void* src);
N_NIMCALL(NimStringDesc*, copyString)(NimStringDesc* src);
N_NIMCALL(NI, gettimezone_93202)(void);
N_NIMCALL(void, genericShallowAssign)(void* dest, void* src, TNimType* mt);
N_NIMCALL(struct tm, timeinfototm_93664)(ttimeinfo93003* t);
static N_INLINE(NI, subInt)(NI a, NI b);
N_NIMCALL(NI64, ntDiffTime)(time_t a, time_t b);
N_NIMCALL(NI, getstartmilsecs_93205)(void);
static N_INLINE(NI, divInt)(NI a, NI b);
N_NIMCALL(time_t, gettime_93037)(void);
N_NIMCALL(void, getlocaltime_93040)(time_t t, ttimeinfo93003* Result);
N_NIMCALL(void, getgmtime_93044)(time_t t, ttimeinfo93003* Result);
N_NIMCALL(time_t, timeinfototime_93048)(ttimeinfo93003* timeinfo);
N_NIMCALL(NimStringDesc*, tostringtillnl_94227)(NCSTRING p);
N_NIMCALL(NimStringDesc*, addChar)(NimStringDesc* s, NIM_CHAR c);
N_NIMCALL(NimStringDesc*, HEX24_93067)(ttimeinfo93003* timeinfo);
N_NIMCALL(NimStringDesc*, HEX24_93071)(time_t time);
N_NIMCALL(NI64, unixtimetowintime_94265)(time_t t);
N_NIMCALL(NI64, mulInt64)(NI64 a, NI64 b);
static N_INLINE(NI64, addInt64)(NI64 a, NI64 b);
N_NIMCALL(time_t, wintimetounixtime_94271)(NI64 t);
static N_INLINE(NI64, subInt64)(NI64 a, NI64 b);
static N_INLINE(NI64, divInt64)(NI64 a, NI64 b);
N_NIMCALL(NI64, chckRange64)(NI64 i, NI64 a, NI64 b);
N_NIMCALL(time_t, fromseconds_93052)(NF since1970);
N_NIMCALL(NF, toseconds_93063)(time_t time);
N_NIMCALL(NF, ntepochTime)(void);
N_NIMCALL(NF, ntcpuTime)(void);
N_NIMCALL(NimStringDesc*, ntgetDateStr)(void);
N_NIMCALL(NimStringDesc*, nimIntToStr)(NI x);
static N_INLINE(void, appendString)(NimStringDesc* dest, NimStringDesc* src);
static N_INLINE(void, appendChar)(NimStringDesc* dest, NIM_CHAR c);
N_NIMCALL(NimStringDesc*, nsuIntToStr)(NI x, NI minchars);
N_NIMCALL(NimStringDesc*, rawNewString)(NI space);
N_NIMCALL(NimStringDesc*, ntgetClockStr)(void);
N_NIMCALL(NimStringDesc*, HEX24_94824)(NU8 day);
N_NIMCALL(NimStringDesc*, HEX24_94836)(NU8 m);
N_NIMCALL(void, formattoken_94848)(ttimeinfo93003* info, NimStringDesc* token, NimStringDesc** buf);
N_NIMCALL(NI, hashString)(NimStringDesc* s);
N_NIMCALL(NimStringDesc*, resizeString)(NimStringDesc* dest, NI addlen);
static N_INLINE(NimStringDesc*, HEX5BHEX5D_79085)(NimStringDesc* s, tslice79092 x);
N_NIMCALL(NimStringDesc*, copyStrLast)(NimStringDesc* s, NI start_70824, NI last);
N_NIMCALL(NimStringDesc*, copyStrLast)(NimStringDesc* s, NI first, NI last);
static N_INLINE(tslice79092, HEX2EHEX2E_85221)(NI a_85225, NI b_85227);
N_NIMCALL(NimStringDesc*, nsuRepeatChar)(NI count, NIM_CHAR c);
N_NIMCALL(void, insert_80801)(NimStringDesc** x, NimStringDesc* item, NI i);
N_NIMCALL(void*, newObj)(TNimType* typ, NI size);
static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src);
static N_INLINE(tcell41290*, usrtocell_44643)(void* usr);
static N_INLINE(void, rtladdzct_46202)(tcell41290* c);
N_NOINLINE(void, addzct_44618)(tcellseq41306* s, tcell41290* c);
N_NIMCALL(void, raiseException)(E_Base* e, NCSTRING ename);
N_NIMCALL(NimStringDesc*, format_94999)(ttimeinfo93003* info, NimStringDesc* f);
STRING_LITERAL(TMP152, "UTC", 3);
NIM_CONST TY93650 weekdays_93649 = {((NU8) 6),
((NU8) 0),
((NU8) 1),
((NU8) 2),
((NU8) 3),
((NU8) 4),
((NU8) 5)}
;
NIM_CONST TY93669 weekdays_93668 = {((NI8) 1),
((NI8) 2),
((NI8) 3),
((NI8) 4),
((NI8) 5),
((NI8) 6),
((NI8) 0)}
;
STRING_LITERAL(TMP157, "", 0);
STRING_LITERAL(TMP164, "Monday", 6);
STRING_LITERAL(TMP165, "Tuesday", 7);
STRING_LITERAL(TMP166, "Wednesday", 9);
STRING_LITERAL(TMP167, "Thursday", 8);
STRING_LITERAL(TMP168, "Friday", 6);
STRING_LITERAL(TMP169, "Saturday", 8);
STRING_LITERAL(TMP170, "Sunday", 6);
NIM_CONST TY94829 lookup_94828 = {((NimStringDesc*) &TMP164),
((NimStringDesc*) &TMP165),
((NimStringDesc*) &TMP166),
((NimStringDesc*) &TMP167),
((NimStringDesc*) &TMP168),
((NimStringDesc*) &TMP169),
((NimStringDesc*) &TMP170)}
;
STRING_LITERAL(TMP171, "January", 7);
STRING_LITERAL(TMP172, "February", 8);
STRING_LITERAL(TMP173, "March", 5);
STRING_LITERAL(TMP174, "April", 5);
STRING_LITERAL(TMP175, "May", 3);
STRING_LITERAL(TMP176, "June", 4);
STRING_LITERAL(TMP177, "July", 4);
STRING_LITERAL(TMP178, "August", 6);
STRING_LITERAL(TMP179, "September", 9);
STRING_LITERAL(TMP180, "October", 7);
STRING_LITERAL(TMP181, "November", 8);
STRING_LITERAL(TMP182, "December", 8);
NIM_CONST TY94841 lookup_94840 = {((NimStringDesc*) &TMP171),
((NimStringDesc*) &TMP172),
((NimStringDesc*) &TMP173),
((NimStringDesc*) &TMP174),
((NimStringDesc*) &TMP175),
((NimStringDesc*) &TMP176),
((NimStringDesc*) &TMP177),
((NimStringDesc*) &TMP178),
((NimStringDesc*) &TMP179),
((NimStringDesc*) &TMP180),
((NimStringDesc*) &TMP181),
((NimStringDesc*) &TMP182)}
;
STRING_LITERAL(TMP183, "d", 1);
STRING_LITERAL(TMP184, "dd", 2);
STRING_LITERAL(TMP185, "ddd", 3);
STRING_LITERAL(TMP186, "dddd", 4);
STRING_LITERAL(TMP187, "h", 1);
STRING_LITERAL(TMP188, "hh", 2);
STRING_LITERAL(TMP189, "H", 1);
STRING_LITERAL(TMP190, "HH", 2);
STRING_LITERAL(TMP191, "m", 1);
STRING_LITERAL(TMP192, "mm", 2);
STRING_LITERAL(TMP193, "M", 1);
STRING_LITERAL(TMP194, "MM", 2);
STRING_LITERAL(TMP195, "MMM", 3);
STRING_LITERAL(TMP196, "MMMM", 4);
STRING_LITERAL(TMP197, "s", 1);
STRING_LITERAL(TMP198, "ss", 2);
STRING_LITERAL(TMP199, "t", 1);
STRING_LITERAL(TMP200, "tt", 2);
STRING_LITERAL(TMP201, "y", 1);
STRING_LITERAL(TMP202, "yy", 2);
STRING_LITERAL(TMP203, "yyy", 3);
STRING_LITERAL(TMP204, "yyyy", 4);
STRING_LITERAL(TMP205, "yyyyy", 5);
STRING_LITERAL(TMP206, "z", 1);
STRING_LITERAL(TMP207, "zz", 2);
STRING_LITERAL(TMP208, "zzz", 3);
STRING_LITERAL(TMP209, "ZZZ", 3);
STRING_LITERAL(TMP210, "0", 1);
STRING_LITERAL(TMP217, "PM", 2);
STRING_LITERAL(TMP218, "AM", 2);
STRING_LITERAL(TMP242, ":00", 3);
STRING_LITERAL(TMP245, "Invalid format string: ", 23);
extern TFrame* frameptr_13038;
extern TNimType NTI2409; /* TObject */
TNimType NTI93003; /* TTimeInfo */
extern TNimType NTI106; /* int */
TNimType NTI93006; /* range 0..61(int) */
TNimType NTI93009; /* range 0..59(int) */
TNimType NTI93011; /* range 0..23(int) */
TNimType NTI93014; /* range 1..31(int) */
TNimType NTI92804; /* TMonth */
TNimType NTI93017; /* range -10000..10000(int) */
TNimType NTI92806; /* TWeekDay */
TNimType NTI93023; /* range 0..365(int) */
extern TNimType NTI134; /* bool */
extern TNimType NTI143; /* string */
extern TNimType NTI18001; /* ref EInvalidValue */
extern TNimType NTI2453; /* EInvalidValue */
extern tgcheap43216 gch_43244;
TNimType NTI93105; /* tuple[nonDST: string, DST: string] */

static N_INLINE(void, nimFrame)(TFrame* s) {
	(*s).prev = frameptr_13038;
	frameptr_13038 = s;
}

static N_INLINE(void, popFrame)(void) {
	frameptr_13038 = (*frameptr_13038).prev;
}

N_NIMCALL(time_t, fromseconds_93056)(NI64 since1970) {
	time_t result;
	nimfr("fromSeconds", "times.nim")
	result = 0;
	nimln(160, "times.nim");
	nimln(162, "times.nim");
	result = fromseconds_93052(((NF) (since1970)));
	popFrame();
	return result;
}

N_NIMCALL(NIM_BOOL, ntLtTime)(time_t a, time_t b) {
	NIM_BOOL result;
	NI64 LOC1;
	nimfr("<", "times.nim")
	result = 0;
	nimln(179, "times.nim");
	nimln(179, "times.nim");
	nimln(179, "times.nim");
	LOC1 = 0;
	LOC1 = ntDiffTime(a, b);
	result = (LOC1 < 0);
	popFrame();
	return result;
}

N_NIMCALL(NIM_BOOL, ntLeTime)(time_t a, time_t b) {
	NIM_BOOL result;
	NI64 LOC1;
	nimfr("<=", "times.nim")
	result = 0;
	nimln(184, "times.nim");
	nimln(184, "times.nim");
	nimln(184, "times.nim");
	LOC1 = 0;
	LOC1 = ntDiffTime(a, b);
	result = (LOC1 <= 0);
	popFrame();
	return result;
}

N_NIMCALL(NIM_BOOL, ntEqTime)(time_t a, time_t b) {
	NIM_BOOL result;
	NI64 LOC1;
	nimfr("==", "times.nim")
	result = 0;
	nimln(189, "times.nim");
	nimln(189, "times.nim");
	nimln(189, "times.nim");
	LOC1 = 0;
	LOC1 = ntDiffTime(a, b);
	result = (LOC1 == 0);
	popFrame();
	return result;
}

N_NIMCALL(ttimeinterval93005, initinterval_93208)(NI miliseconds, NI seconds, NI minutes, NI hours, NI days, NI months, NI years) {
	ttimeinterval93005 result;
	nimfr("initInterval", "times.nim")
	memset((void*)&result, 0, sizeof(result));
	nimln(207, "times.nim");
	result.Miliseconds = miliseconds;
	nimln(208, "times.nim");
	result.Seconds = seconds;
	nimln(209, "times.nim");
	result.Minutes = minutes;
	nimln(210, "times.nim");
	result.Hours = hours;
	nimln(211, "times.nim");
	result.Days = days;
	nimln(212, "times.nim");
	result.Months = months;
	nimln(213, "times.nim");
	result.Years = years;
	popFrame();
	return result;
}

static N_INLINE(NI, modInt)(NI a, NI b) {
	NI result;
	result = 0;
	{
		if (!(b == 0)) goto LA3;
		raiseDivByZero();
	}
	LA3: ;
	result = (NI32)(a % b);
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

N_NIMCALL(NIM_BOOL, isleapyear_93220)(NI year) {
	NIM_BOOL result;
	nimfr("isLeapYear", "times.nim")
	result = 0;
	nimln(218, "times.nim");
	{
		NI TMP132;
		nimln(218, "times.nim");
		nimln(218, "times.nim");
		TMP132 = modInt(year, 400);
		if (!(((NI) ((NI32)(TMP132))) == 0)) goto LA3;
		nimln(219, "times.nim");
		nimln(219, "times.nim");
		result = NIM_TRUE;
		goto BeforeRet;
	}
	goto LA1;
	LA3: ;
	{
		NI TMP133;
		nimln(220, "times.nim");
		nimln(220, "times.nim");
		TMP133 = modInt(year, 100);
		if (!(((NI) ((NI32)(TMP133))) == 0)) goto LA6;
		nimln(221, "times.nim");
		nimln(221, "times.nim");
		result = NIM_FALSE;
		goto BeforeRet;
	}
	goto LA1;
	LA6: ;
	{
		NI TMP134;
		nimln(222, "times.nim");
		nimln(222, "times.nim");
		TMP134 = modInt(year, 4);
		if (!(((NI) ((NI32)(TMP134))) == 0)) goto LA9;
		nimln(223, "times.nim");
		nimln(223, "times.nim");
		result = NIM_TRUE;
		goto BeforeRet;
	}
	goto LA1;
	LA9: ;
	{
		nimln(225, "times.nim");
		nimln(225, "times.nim");
		result = NIM_FALSE;
		goto BeforeRet;
	}
	LA1: ;
	BeforeRet: ;
	popFrame();
	return result;
}

N_NIMCALL(NI, getdaysinmonth_93231)(NU8 month, NI year) {
	NI result;
	nimfr("getDaysInMonth", "times.nim")
	result = 0;
	nimln(231, "times.nim");
	switch (month) {
	case ((NU8) 1):
	{
		nimln(232, "times.nim");
		nimln(232, "times.nim");
		{
			NIM_BOOL LOC4;
			nimln(232, "times.nim");
			LOC4 = 0;
			LOC4 = isleapyear_93220(year);
			if (!LOC4) goto LA5;
			result = 29;
		}
		goto LA2;
		LA5: ;
		{
			result = 28;
		}
		LA2: ;
	}
	break;
	case ((NU8) 3):
	case ((NU8) 5):
	case ((NU8) 8):
	case ((NU8) 10):
	{
		nimln(233, "times.nim");
		result = 30;
	}
	break;
	default:
	{
		nimln(234, "times.nim");
		result = 31;
	}
	break;
	}
	popFrame();
	return result;
}

static N_INLINE(void, HEX2BHEX3D_93275)(NF* x_93281, NF y_93284) {
	nimfr("+=", "system.nim")
	nimln(2706, "system.nim");
	nimln(2706, "system.nim");
	(*x_93281) = ((NF)((*x_93281)) + (NF)(y_93284));
	popFrame();
}

static N_INLINE(NI, addInt)(NI a, NI b) {
	NI result;
	result = 0;
	result = (NI)((NU32)(a) + (NU32)(b));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = (0 <= (NI)(result ^ a));
		if (LOC3) goto LA4;
		LOC3 = (0 <= (NI)(result ^ b));
		LA4: ;
		if (!LOC3) goto LA5;
		goto BeforeRet;
	}
	LA5: ;
	raiseOverflow();
	BeforeRet: ;
	return result;
}

static N_INLINE(NF, HEX2F_79038)(NI x, NI y) {
	NF result;
	nimfr("/", "system.nim")
	result = 0;
	nimln(2567, "system.nim");
	nimln(2567, "system.nim");
	nimln(2567, "system.nim");
	nimln(2567, "system.nim");
	result = ((NF)(((double) (x))) / (NF)(((double) (y))));
	popFrame();
	return result;
}

N_NIMCALL(NF, toseconds_93240)(ttimeinfo93003* a, ttimeinterval93005* interval) {
	NF result;
	ttimeinfo93003 anew;
	ttimeinterval93005 newinterv;
	NI TMP142;
	NU8 curmonth;
	NI mth_93270;
	NI HEX3Atmp_93396;
	NI res_93398;
	NI TMP146;
	NI TMP147;
	NI TMP148;
	NI TMP149;
	NI TMP150;
	NI TMP151;
	NF LOC8;
	nimfr("toSeconds", "times.nim")
	result = 0;
	nimln(240, "times.nim");
	genericAssign((void*)&anew, (void*)a, (&NTI93003));
	nimln(241, "times.nim");
	newinterv = (*interval);
	nimln(242, "times.nim");
	result = 0.0;
	nimln(244, "times.nim");
	nimln(244, "times.nim");
	TMP142 = mulInt((*interval).Years, 12);
	newinterv.Months = addInt(newinterv.Months, (NI32)(TMP142));
	nimln(245, "times.nim");
	curmonth = anew.Month;
	mth_93270 = 0;
	HEX3Atmp_93396 = 0;
	nimln(246, "times.nim");
	HEX3Atmp_93396 = newinterv.Months;
	nimln(1458, "system.nim");
	res_93398 = 1;
	nimln(1459, "system.nim");
	while (1) {
		NI LOC2;
		NI TMP143;
		NI TMP144;
		NI TMP145;
		nimln(1459, "system.nim");
		if (!(res_93398 <= HEX3Atmp_93396)) goto LA1;
		nimln(1458, "system.nim");
		mth_93270 = res_93398;
		nimln(247, "times.nim");
		nimln(247, "times.nim");
		nimln(247, "times.nim");
		nimln(247, "times.nim");
		nimln(247, "times.nim");
		LOC2 = 0;
		LOC2 = getdaysinmonth_93231(curmonth, ((NI) (anew.Year)));
		TMP143 = mulInt(LOC2, 24);
		TMP144 = mulInt((NI32)(TMP143), 60);
		TMP145 = mulInt((NI32)(TMP144), 60);
		HEX2BHEX3D_93275(&result, ((NF) ((NI32)(TMP145))));
		nimln(248, "times.nim");
		{
			nimln(248, "times.nim");
			if (!(curmonth == ((NU8) 11))) goto LA5;
			nimln(249, "times.nim");
			curmonth = ((NU8) 0);
			nimln(250, "times.nim");
			anew.Year = addInt(anew.Year, 1);
		}
		goto LA3;
		LA5: ;
		{
			nimln(252, "times.nim");
			curmonth = addInt(curmonth, 1);
		}
		LA3: ;
		nimln(1461, "system.nim");
		res_93398 = addInt(res_93398, 1);
	} LA1: ;
	nimln(253, "times.nim");
	nimln(253, "times.nim");
	nimln(253, "times.nim");
	nimln(253, "times.nim");
	TMP146 = mulInt(newinterv.Days, 24);
	TMP147 = mulInt((NI32)(TMP146), 60);
	TMP148 = mulInt((NI32)(TMP147), 60);
	HEX2BHEX3D_93275(&result, ((NF) ((NI32)(TMP148))));
	nimln(254, "times.nim");
	nimln(254, "times.nim");
	nimln(254, "times.nim");
	TMP149 = mulInt(newinterv.Hours, 60);
	TMP150 = mulInt((NI32)(TMP149), 60);
	HEX2BHEX3D_93275(&result, ((NF) ((NI32)(TMP150))));
	nimln(255, "times.nim");
	nimln(255, "times.nim");
	TMP151 = mulInt(newinterv.Minutes, 60);
	HEX2BHEX3D_93275(&result, ((NF) ((NI32)(TMP151))));
	nimln(256, "times.nim");
	HEX2BHEX3D_93275(&result, ((NF) (newinterv.Seconds)));
	nimln(257, "times.nim");
	nimln(257, "times.nim");
	LOC8 = 0;
	LOC8 = HEX2F_79038(newinterv.Miliseconds, 1000);
	HEX2BHEX3D_93275(&result, LOC8);
	popFrame();
	return result;
}

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

N_NIMCALL(void, HEX2B_93407)(ttimeinfo93003* a, ttimeinterval93005* interval, ttimeinfo93003* Result) {
	NF t;
	time_t LOC1;
	NF secs;
	nimfr("+", "times.nim")
	nimln(264, "times.nim");
	nimln(264, "times.nim");
	LOC1 = 0;
	LOC1 = timeinfototime_93048(a);
	t = toseconds_93063(LOC1);
	nimln(265, "times.nim");
	secs = toseconds_93240(a, interval);
	nimln(266, "times.nim");
	{
		time_t LOC6;
		nimln(266, "times.nim");
		if (!eqStrings((*a).Tzname, ((NimStringDesc*) &TMP152))) goto LA4;
		nimln(267, "times.nim");
		nimln(267, "times.nim");
		nimln(267, "times.nim");
		LOC6 = 0;
		LOC6 = fromseconds_93052(((NF)(t) + (NF)(secs)));
		chckNil((void*)Result);
		genericReset((void*)Result, (&NTI93003));
		(*Result).Sup.m_type = (&NTI93003);
		getgmtime_93044(LOC6, Result);
	}
	goto LA2;
	LA4: ;
	{
		time_t LOC8;
		nimln(269, "times.nim");
		nimln(269, "times.nim");
		nimln(269, "times.nim");
		LOC8 = 0;
		LOC8 = fromseconds_93052(((NF)(t) + (NF)(secs)));
		chckNil((void*)Result);
		genericReset((void*)Result, (&NTI93003));
		(*Result).Sup.m_type = (&NTI93003);
		getlocaltime_93040(LOC8, Result);
	}
	LA2: ;
	popFrame();
}

N_NIMCALL(void, HEX2D_93416)(ttimeinfo93003* a, ttimeinterval93005* interval, ttimeinfo93003* Result) {
	NF t;
	time_t LOC1;
	NF secs;
	nimfr("-", "times.nim")
	nimln(276, "times.nim");
	nimln(276, "times.nim");
	LOC1 = 0;
	LOC1 = timeinfototime_93048(a);
	t = toseconds_93063(LOC1);
	nimln(277, "times.nim");
	secs = toseconds_93240(a, interval);
	nimln(278, "times.nim");
	{
		time_t LOC6;
		nimln(278, "times.nim");
		if (!eqStrings((*a).Tzname, ((NimStringDesc*) &TMP152))) goto LA4;
		nimln(279, "times.nim");
		nimln(279, "times.nim");
		nimln(279, "times.nim");
		LOC6 = 0;
		LOC6 = fromseconds_93052(((NF)(t) - (NF)(secs)));
		chckNil((void*)Result);
		genericReset((void*)Result, (&NTI93003));
		(*Result).Sup.m_type = (&NTI93003);
		getgmtime_93044(LOC6, Result);
	}
	goto LA2;
	LA4: ;
	{
		time_t LOC8;
		nimln(281, "times.nim");
		nimln(281, "times.nim");
		nimln(281, "times.nim");
		LOC8 = 0;
		LOC8 = fromseconds_93052(((NF)(t) - (NF)(secs)));
		chckNil((void*)Result);
		genericReset((void*)Result, (&NTI93003));
		(*Result).Sup.m_type = (&NTI93003);
		getlocaltime_93040(LOC8, Result);
	}
	LA2: ;
	popFrame();
}

static N_INLINE(NI, chckRange)(NI i, NI a, NI b) {
	NI result;
	result = 0;
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = (a <= i);
		if (!(LOC3)) goto LA4;
		LOC3 = (i <= b);
		LA4: ;
		if (!LOC3) goto LA5;
		result = i;
		goto BeforeRet;
	}
	goto LA1;
	LA5: ;
	{
		raiseRangeError(((NI64) (i)));
	}
	LA1: ;
	BeforeRet: ;
	return result;
}

N_NIMCALL(void, gettzname_93103)(TY93105* Result) {
	nimfr("getTzname", "times.nim")
	nimln(444, "times.nim");
	nimln(444, "times.nim");
	nimln(444, "times.nim");
	unsureAsgnRef((void**) &(*Result).Field0, cstrToNimstr(tzname[(0)- 0]));
	nimln(444, "times.nim");
	unsureAsgnRef((void**) &(*Result).Field1, cstrToNimstr(tzname[(1)- 0]));
	goto BeforeRet;
	BeforeRet: ;
	popFrame();
}

N_NIMCALL(NI, gettimezone_93202)(void) {
	NI result;
	nimfr("getTimezone", "times.nim")
	result = 0;
	nimln(447, "times.nim");
	nimln(447, "times.nim");
	result = timezone;
	goto BeforeRet;
	BeforeRet: ;
	popFrame();
	return result;
}

N_NIMCALL(void, tmtotimeinfo_93644)(struct tm* tm, NIM_BOOL local, ttimeinfo93003* Result) {
	ttimeinfo93003 LOC1;
	NI32 TMP153;
	nimfr("tmToTimeInfo", "times.nim")
	nimln(344, "times.nim");
	memset((void*)&LOC1, 0, sizeof(LOC1));
	LOC1.Sup.m_type = (&NTI93003);
	memset((void*)&LOC1, 0, sizeof(LOC1));
	LOC1.Sup.m_type = (&NTI93003);
	LOC1.Second = ((NI)chckRange(((NI) ((*tm).tm_sec)), 0, 61));
	LOC1.Minute = ((NI)chckRange(((NI) ((*tm).tm_min)), 0, 59));
	LOC1.Hour = ((NI)chckRange(((NI) ((*tm).tm_hour)), 0, 23));
	LOC1.Monthday = ((NI)chckRange(((NI) ((*tm).tm_mday)), 1, 31));
	LOC1.Month = ((NU8)chckRange((*tm).tm_mon, ((NU8) 0), ((NU8) 11)));
	nimln(352, "times.nim");
	TMP153 = addInt((*tm).tm_year, ((NI32) 1900));
	LOC1.Year = ((NI)chckRange((NI32)(TMP153), -10000, 10000));
	if ((NU)(((NI) ((*tm).tm_wday))) > (NU)(6)) raiseIndexError();
	LOC1.Weekday = weekdays_93649[(((NI) ((*tm).tm_wday)))- 0];
	LOC1.Yearday = ((NI)chckRange(((NI) ((*tm).tm_yday)), 0, 365));
	nimln(355, "times.nim");
	LOC1.Isdst = (((NI32) 0) < (*tm).tm_isdst);
	nimln(356, "times.nim");
	{
		if (!local) goto LA4;
		nimln(357, "times.nim");
		{
			TY93105 LOC10;
			nimln(357, "times.nim");
			if (!(((NI32) 0) < (*tm).tm_isdst)) goto LA8;
			nimln(358, "times.nim");
			memset((void*)&LOC10, 0, sizeof(LOC10));
			gettzname_93103(&LOC10);
			LOC1.Tzname = copyString(LOC10.Field1);
		}
		goto LA6;
		LA8: ;
		{
			TY93105 LOC12;
			nimln(360, "times.nim");
			memset((void*)&LOC12, 0, sizeof(LOC12));
			gettzname_93103(&LOC12);
			LOC1.Tzname = copyString(LOC12.Field0);
		}
		LA6: ;
	}
	goto LA2;
	LA4: ;
	{
		LOC1.Tzname = copyString(((NimStringDesc*) &TMP152));
	}
	LA2: ;
	nimln(363, "times.nim");
	{
		if (!local) goto LA16;
		nimln(363, "times.nim");
		LOC1.Timezone = gettimezone_93202();
	}
	goto LA14;
	LA16: ;
	{
		LOC1.Timezone = 0;
	}
	LA14: ;
	genericShallowAssign((void*)Result, (void*)&LOC1, (&NTI93003));
	popFrame();
}

static N_INLINE(NI, subInt)(NI a, NI b) {
	NI result;
	result = 0;
	result = (NI)((NU32)(a) - (NU32)(b));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = (0 <= (NI)(result ^ a));
		if (LOC3) goto LA4;
		LOC3 = (0 <= (NI)(result ^ (NI)((NU32) ~(b))));
		LA4: ;
		if (!LOC3) goto LA5;
		goto BeforeRet;
	}
	LA5: ;
	raiseOverflow();
	BeforeRet: ;
	return result;
}

N_NIMCALL(struct tm, timeinfototm_93664)(ttimeinfo93003* t) {
	struct tm result;
	NI TMP154;
	NI LOC1;
	nimfr("timeInfoToTM", "times.nim")
	memset((void*)&result, 0, sizeof(result));
	nimln(369, "times.nim");
	result.tm_sec = ((int) ((*t).Second));
	nimln(370, "times.nim");
	result.tm_min = ((int) ((*t).Minute));
	nimln(371, "times.nim");
	result.tm_hour = ((int) ((*t).Hour));
	nimln(372, "times.nim");
	result.tm_mday = ((int) ((*t).Monthday));
	nimln(373, "times.nim");
	nimln(373, "times.nim");
	result.tm_mon = ((int) ((*t).Month));
	nimln(374, "times.nim");
	nimln(374, "times.nim");
	TMP154 = subInt(((NI) ((*t).Year)), 1900);
	result.tm_year = ((int) ((NI32)(TMP154)));
	nimln(375, "times.nim");
	result.tm_wday = ((int) (weekdays_93668[((*t).Weekday)- 0]));
	nimln(376, "times.nim");
	result.tm_yday = ((int) ((*t).Yearday));
	nimln(377, "times.nim");
	LOC1 = 0;
	nimln(377, "times.nim");
	{
		if (!(*t).Isdst) goto LA4;
		LOC1 = 1;
	}
	goto LA2;
	LA4: ;
	{
		LOC1 = 0;
	}
	LA2: ;
	result.tm_isdst = ((int) (LOC1));
	popFrame();
	return result;
}

N_NIMCALL(NI64, ntDiffTime)(time_t a, time_t b) {
	NI64 result;
	NF LOC1;
	nimfr("-", "times.nim")
	result = 0;
	nimln(381, "times.nim");
	nimln(381, "times.nim");
	nimln(381, "times.nim");
	nimln(381, "times.nim");
	LOC1 = 0;
	LOC1 = difftime(a, b);
	result = float64ToInt64(LOC1);
	goto BeforeRet;
	BeforeRet: ;
	popFrame();
	return result;
}

static N_INLINE(NI, divInt)(NI a, NI b) {
	NI result;
	result = 0;
	{
		if (!(b == 0)) goto LA3;
		raiseDivByZero();
	}
	LA3: ;
	{
		NIM_BOOL LOC7;
		LOC7 = 0;
		LOC7 = (a == (-2147483647 -1));
		if (!(LOC7)) goto LA8;
		LOC7 = (b == -1);
		LA8: ;
		if (!LOC7) goto LA9;
		raiseOverflow();
	}
	LA9: ;
	result = (NI32)(a / b);
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

N_NIMCALL(NI, getstartmilsecs_93205)(void) {
	NI result;
	NI LOC1;
	NI TMP155;
	NI TMP156;
	nimfr("getStartMilsecs", "times.nim")
	result = 0;
	nimln(389, "times.nim");
	nimln(389, "times.nim");
	nimln(389, "times.nim");
	LOC1 = 0;
	LOC1 = clock();
	nimln(389, "times.nim");
	TMP155 = divInt(CLOCKS_PER_SEC, 1000);
	TMP156 = divInt(LOC1, (NI32)(TMP155));
	result = (NI32)(TMP156);
	popFrame();
	return result;
}

N_NIMCALL(time_t, gettime_93037)(void) {
	time_t result;
	nimfr("getTime", "times.nim")
	result = 0;
	nimln(396, "times.nim");
	nimln(396, "times.nim");
	result = time(NIM_NIL);
	goto BeforeRet;
	BeforeRet: ;
	popFrame();
	return result;
}

N_NIMCALL(void, getlocaltime_93040)(time_t t, ttimeinfo93003* Result) {
	time_t a;
	struct tm* LOC1;
	nimfr("getLocalTime", "times.nim")
	nimln(398, "times.nim");
	a = t;
	nimln(399, "times.nim");
	nimln(399, "times.nim");
	LOC1 = 0;
	LOC1 = localtime(&a);
	chckNil((void*)Result);
	genericReset((void*)Result, (&NTI93003));
	(*Result).Sup.m_type = (&NTI93003);
	tmtotimeinfo_93644(&(*LOC1), NIM_TRUE, Result);
	popFrame();
}

N_NIMCALL(void, getgmtime_93044)(time_t t, ttimeinfo93003* Result) {
	time_t a;
	struct tm* LOC1;
	nimfr("getGMTime", "times.nim")
	nimln(404, "times.nim");
	a = t;
	nimln(405, "times.nim");
	nimln(405, "times.nim");
	LOC1 = 0;
	LOC1 = gmtime(&a);
	chckNil((void*)Result);
	genericReset((void*)Result, (&NTI93003));
	(*Result).Sup.m_type = (&NTI93003);
	tmtotimeinfo_93644(&(*LOC1), NIM_FALSE, Result);
	popFrame();
}

N_NIMCALL(time_t, timeinfototime_93048)(ttimeinfo93003* timeinfo) {
	time_t result;
	ttimeinfo93003 ctimeinfo;
	struct tm LOC1;
	nimfr("timeInfoToTime", "times.nim")
	result = 0;
	nimln(410, "times.nim");
	genericAssign((void*)&ctimeinfo, (void*)timeinfo, (&NTI93003));
	nimln(412, "times.nim");
	nimln(412, "times.nim");
	nimln(412, "times.nim");
	LOC1 = timeinfototm_93664(&ctimeinfo);
	result = mktime(&LOC1);
	goto BeforeRet;
	BeforeRet: ;
	popFrame();
	return result;
}

N_NIMCALL(NimStringDesc*, tostringtillnl_94227)(NCSTRING p) {
	NimStringDesc* result;
	NI i;
	nimfr("toStringTillNL", "times.nim")
	result = 0;
	nimln(415, "times.nim");
	result = copyString(((NimStringDesc*) &TMP157));
	nimln(416, "times.nim");
	i = 0;
	nimln(417, "times.nim");
	while (1) {
		NIM_BOOL LOC2;
		NIM_BOOL LOC3;
		nimln(417, "times.nim");
		LOC2 = 0;
		nimln(417, "times.nim");
		LOC3 = 0;
		nimln(417, "times.nim");
		nimln(417, "times.nim");
		LOC3 = !(((NU8)(p[i]) == (NU8)(0)));
		if (!(LOC3)) goto LA4;
		nimln(417, "times.nim");
		nimln(417, "times.nim");
		LOC3 = !(((NU8)(p[i]) == (NU8)(10)));
		LA4: ;
		LOC2 = LOC3;
		if (!(LOC2)) goto LA5;
		nimln(417, "times.nim");
		nimln(417, "times.nim");
		LOC2 = !(((NU8)(p[i]) == (NU8)(13)));
		LA5: ;
		if (!LOC2) goto LA1;
		nimln(418, "times.nim");
		result = addChar(result, p[i]);
		nimln(419, "times.nim");
		i = addInt(i, 1);
	} LA1: ;
	popFrame();
	return result;
}

N_NIMCALL(NimStringDesc*, HEX24_93067)(ttimeinfo93003* timeinfo) {
	NimStringDesc* result;
	NCSTRING p;
	struct tm LOC1;
	nimfr("$", "times.nim")
	result = 0;
	nimln(423, "times.nim");
	nimln(423, "times.nim");
	LOC1 = timeinfototm_93664(timeinfo);
	p = asctime(&LOC1);
	nimln(424, "times.nim");
	result = tostringtillnl_94227(p);
	popFrame();
	return result;
}

N_NIMCALL(NimStringDesc*, HEX24_93071)(time_t time) {
	NimStringDesc* result;
	time_t a;
	NCSTRING LOC1;
	nimfr("$", "times.nim")
	result = 0;
	nimln(428, "times.nim");
	a = time;
	nimln(429, "times.nim");
	nimln(429, "times.nim");
	nimln(429, "times.nim");
	LOC1 = 0;
	LOC1 = ctime(&a);
	result = tostringtillnl_94227(LOC1);
	goto BeforeRet;
	BeforeRet: ;
	popFrame();
	return result;
}

static N_INLINE(NI64, addInt64)(NI64 a, NI64 b) {
	NI64 result;
	result = 0;
	result = (NI64)((NU64)(a) + (NU64)(b));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = (0 <= (NI64)(result ^ a));
		if (LOC3) goto LA4;
		LOC3 = (0 <= (NI64)(result ^ b));
		LA4: ;
		if (!LOC3) goto LA5;
		goto BeforeRet;
	}
	LA5: ;
	raiseOverflow();
	BeforeRet: ;
	return result;
}

N_NIMCALL(NI64, unixtimetowintime_94265)(time_t t) {
	NI64 result;
	NI64 TMP158;
	NI64 TMP159;
	nimfr("unixTimeToWinTime", "times.nim")
	result = 0;
	nimln(437, "times.nim");
	nimln(437, "times.nim");
	nimln(437, "times.nim");
	TMP158 = mulInt64(((NI64) (t)), 10000000);
	TMP159 = addInt64((NI64)(TMP158), IL64(116444736000000000));
	result = (NI64)(TMP159);
	popFrame();
	return result;
}

static N_INLINE(NI64, subInt64)(NI64 a, NI64 b) {
	NI64 result;
	result = 0;
	result = (NI64)((NU64)(a) - (NU64)(b));
	{
		NIM_BOOL LOC3;
		LOC3 = 0;
		LOC3 = (0 <= (NI64)(result ^ a));
		if (LOC3) goto LA4;
		LOC3 = (0 <= (NI64)(result ^ (NI64)((NU64) ~(b))));
		LA4: ;
		if (!LOC3) goto LA5;
		goto BeforeRet;
	}
	LA5: ;
	raiseOverflow();
	BeforeRet: ;
	return result;
}

static N_INLINE(NI64, divInt64)(NI64 a, NI64 b) {
	NI64 result;
	result = 0;
	{
		if (!(b == 0)) goto LA3;
		raiseDivByZero();
	}
	LA3: ;
	{
		NIM_BOOL LOC7;
		LOC7 = 0;
		LOC7 = (a == (IL64(-9223372036854775807) - IL64(1)));
		if (!(LOC7)) goto LA8;
		LOC7 = (b == -1);
		LA8: ;
		if (!LOC7) goto LA9;
		raiseOverflow();
	}
	LA9: ;
	result = (NI64)(a / b);
	goto BeforeRet;
	BeforeRet: ;
	return result;
}

N_NIMCALL(time_t, wintimetounixtime_94271)(NI64 t) {
	time_t result;
	NI64 TMP160;
	NI64 TMP161;
	nimfr("winTimeToUnixTime", "times.nim")
	result = 0;
	nimln(441, "times.nim");
	nimln(441, "times.nim");
	nimln(441, "times.nim");
	TMP160 = subInt64(t, IL64(116444736000000000));
	TMP161 = divInt64((NI64)(TMP160), 10000000);
	result = ((time_t)chckRange64((NI64)(TMP161), (-2147483647 -1), 2147483647));
	popFrame();
	return result;
}

N_NIMCALL(time_t, fromseconds_93052)(NF since1970) {
	time_t result;
	nimfr("fromSeconds", "times.nim")
	result = 0;
	nimln(449, "times.nim");
	result = ((time_t) (since1970));
	popFrame();
	return result;
}

N_NIMCALL(NF, toseconds_93063)(time_t time) {
	NF result;
	nimfr("toSeconds", "times.nim")
	result = 0;
	nimln(451, "times.nim");
	result = ((NF) (time));
	popFrame();
	return result;
}

N_NIMCALL(NF, ntepochTime)(void) {
	NF result;
	struct timeval a;
	nimfr("epochTime", "times.nim")
	result = 0;
	memset((void*)&a, 0, sizeof(a));
	nimln(457, "times.nim");
	gettimeofday(&a, NIM_NIL);
	nimln(458, "times.nim");
	nimln(458, "times.nim");
	nimln(458, "times.nim");
	nimln(458, "times.nim");
	nimln(458, "times.nim");
	result = ((NF)(((double) (a.tv_sec))) + (NF)(((NF)(((double) (a.tv_usec))) * (NF)(9.9999999999999995e-07))));
	popFrame();
	return result;
}

N_NIMCALL(NF, ntcpuTime)(void) {
	NF result;
	NI LOC1;
	nimfr("cpuTime", "times.nim")
	result = 0;
	nimln(470, "times.nim");
	nimln(470, "times.nim");
	nimln(470, "times.nim");
	nimln(470, "times.nim");
	LOC1 = 0;
	LOC1 = clock();
	nimln(470, "times.nim");
	result = ((NF)(((double) (LOC1))) / (NF)(((double) (CLOCKS_PER_SEC))));
	popFrame();
	return result;
}

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;
}

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

N_NIMCALL(NimStringDesc*, ntgetDateStr)(void) {
	NimStringDesc* result;
	ttimeinfo93003 ti;
	time_t LOC1;
	NimStringDesc* LOC2;
	NimStringDesc* LOC3;
	NI TMP163;
	NimStringDesc* LOC4;
	NimStringDesc* LOC5;
	nimfr("getDateStr", "times.nim")
	result = 0;
	nimln(538, "times.nim");
	nimln(538, "times.nim");
	LOC1 = 0;
	LOC1 = gettime_93037();
	chckNil((void*)&ti);
	memset((void*)&ti, 0, sizeof(ti));
	ti.Sup.m_type = (&NTI93003);
	getlocaltime_93040(LOC1, &ti);
	nimln(539, "times.nim");
	nimln(540, "times.nim");
	LOC2 = 0;
	nimln(539, "times.nim");
	LOC3 = 0;
	LOC3 = nimIntToStr(((NI) (ti.Year)));
	nimln(539, "times.nim");
	nimln(539, "times.nim");
	nimln(539, "times.nim");
	TMP163 = addInt(((NI) (ti.Month)), 1);
	LOC4 = 0;
	LOC4 = nsuIntToStr(((NI) ((NI32)(TMP163))), 2);
	nimln(540, "times.nim");
	LOC5 = 0;
	LOC5 = nsuIntToStr(((NI) (ti.Monthday)), 2);
	LOC2 = rawNewString(LOC3->Sup.len + LOC4->Sup.len + LOC5->Sup.len + 2);
appendString(LOC2, LOC3);
appendChar(LOC2, 45);
appendString(LOC2, LOC4);
appendChar(LOC2, 45);
appendString(LOC2, LOC5);
	result = LOC2;
	popFrame();
	return result;
}

N_NIMCALL(NimStringDesc*, ntgetClockStr)(void) {
	NimStringDesc* result;
	ttimeinfo93003 ti;
	time_t LOC1;
	NimStringDesc* LOC2;
	NimStringDesc* LOC3;
	NimStringDesc* LOC4;
	NimStringDesc* LOC5;
	nimfr("getClockStr", "times.nim")
	result = 0;
	nimln(544, "times.nim");
	nimln(544, "times.nim");
	LOC1 = 0;
	LOC1 = gettime_93037();
	chckNil((void*)&ti);
	memset((void*)&ti, 0, sizeof(ti));
	ti.Sup.m_type = (&NTI93003);
	getlocaltime_93040(LOC1, &ti);
	nimln(545, "times.nim");
	nimln(546, "times.nim");
	LOC2 = 0;
	nimln(545, "times.nim");
	LOC3 = 0;
	LOC3 = nsuIntToStr(((NI) (ti.Hour)), 2);
	nimln(545, "times.nim");
	LOC4 = 0;
	LOC4 = nsuIntToStr(((NI) (ti.Minute)), 2);
	nimln(546, "times.nim");
	LOC5 = 0;
	LOC5 = nsuIntToStr(((NI) (ti.Second)), 2);
	LOC2 = rawNewString(LOC3->Sup.len + LOC4->Sup.len + LOC5->Sup.len + 2);
appendString(LOC2, LOC3);
appendChar(LOC2, 58);
appendString(LOC2, LOC4);
appendChar(LOC2, 58);
appendString(LOC2, LOC5);
	result = LOC2;
	popFrame();
	return result;
}

N_NIMCALL(NimStringDesc*, HEX24_94824)(NU8 day) {
	NimStringDesc* result;
	nimfr("$", "times.nim")
	result = 0;
	nimln(552, "times.nim");
	nimln(552, "times.nim");
	result = copyString(lookup_94828[(day)- 0]);
	goto BeforeRet;
	BeforeRet: ;
	popFrame();
	return result;
}

N_NIMCALL(NimStringDesc*, HEX24_94836)(NU8 m) {
	NimStringDesc* result;
	nimfr("$", "times.nim")
	result = 0;
	nimln(559, "times.nim");
	nimln(559, "times.nim");
	result = copyString(lookup_94840[(m)- 0]);
	goto BeforeRet;
	BeforeRet: ;
	popFrame();
	return result;
}

static N_INLINE(NimStringDesc*, HEX5BHEX5D_79085)(NimStringDesc* s, tslice79092 x) {
	NimStringDesc* result;
	NI LOC1;
	NI LOC7;
	nimfr("[]", "system.nim")
	result = 0;
	nimln(2591, "system.nim");
	nimln(2591, "system.nim");
	LOC1 = 0;
	nimln(2570, "system.nim");
	{
		nimln(2570, "system.nim");
		if (!(0 <= x.A)) goto LA4;
		LOC1 = x.A;
	}
	goto LA2;
	LA4: ;
	{
		NI TMP211;
		nimln(2570, "system.nim");
		nimln(2570, "system.nim");
		TMP211 = addInt(s->Sup.len, x.A);
		LOC1 = (NI32)(TMP211);
	}
	LA2: ;
	LOC7 = 0;
	nimln(2570, "system.nim");
	{
		nimln(2570, "system.nim");
		if (!(0 <= x.B)) goto LA10;
		LOC7 = x.B;
	}
	goto LA8;
	LA10: ;
	{
		NI TMP212;
		nimln(2570, "system.nim");
		nimln(2570, "system.nim");
		TMP212 = addInt(s->Sup.len, x.B);
		LOC7 = (NI32)(TMP212);
	}
	LA8: ;
	result = copyStrLast(s, LOC1, LOC7);
	popFrame();
	return result;
}

static N_INLINE(tslice79092, HEX2EHEX2E_85221)(NI a_85225, NI b_85227) {
	tslice79092 result;
	nimfr("..", "system.nim")
	memset((void*)&result, 0, sizeof(result));
	nimln(179, "system.nim");
	result.A = a_85225;
	nimln(180, "system.nim");
	result.B = b_85227;
	popFrame();
	return result;
}

static N_INLINE(tcell41290*, usrtocell_44643)(void* usr) {
	tcell41290* result;
	nimfr("usrToCell", "gc.nim")
	result = 0;
	nimln(118, "gc.nim");
	nimln(118, "gc.nim");
	nimln(118, "gc.nim");
	result = ((tcell41290*) ((NI)((NU32)(((NI) (usr))) - (NU32)(((NI)sizeof(tcell41290))))));
	popFrame();
	return result;
}

static N_INLINE(void, rtladdzct_46202)(tcell41290* c) {
	nimfr("rtlAddZCT", "gc.nim")
	nimln(199, "gc.nim");
	addzct_44618(&gch_43244.Zct, c);
	popFrame();
}

static N_INLINE(void, asgnRefNoCycle)(void** dest, void* src) {
	nimfr("asgnRefNoCycle", "gc.nim")
	nimln(251, "gc.nim");
	{
		tcell41290* c;
		nimln(251, "gc.nim");
		nimln(251, "gc.nim");
		if (!!((src == NIM_NIL))) goto LA3;
		nimln(252, "gc.nim");
		c = usrtocell_44643(src);
		nimln(169, "gc.nim");
		(*c).Refcount += 8;
	}
	LA3: ;
	nimln(254, "gc.nim");
	{
		tcell41290* c;
		nimln(254, "gc.nim");
		nimln(254, "gc.nim");
		if (!!(((*dest) == NIM_NIL))) goto LA7;
		nimln(255, "gc.nim");
		c = usrtocell_44643((*dest));
		nimln(256, "gc.nim");
		{
			nimln(167, "gc.nim");
			(*c).Refcount -= 8;
			nimln(168, "gc.nim");
			if (!((NU32)((*c).Refcount) < (NU32)(8))) goto LA11;
			nimln(257, "gc.nim");
			rtladdzct_46202(c);
		}
		LA11: ;
	}
	LA7: ;
	nimln(258, "gc.nim");
	(*dest) = src;
	popFrame();
}

N_NIMCALL(void, formattoken_94848)(ttimeinfo93003* info, NimStringDesc* token, NimStringDesc** buf) {
	nimfr("format_token", "times.nim")
	nimln(567, "times.nim");
	switch (hashString(token) & 31) {
	case 0: 
if (eqStrings(token, ((NimStringDesc*) &TMP157))) goto LA28;
break;
	case 1: 
if (eqStrings(token, ((NimStringDesc*) &TMP192))) goto LA10;
break;
	case 4: 
if (eqStrings(token, ((NimStringDesc*) &TMP205))) goto LA23;
break;
	case 5: 
if (eqStrings(token, ((NimStringDesc*) &TMP183))) goto LA1;
break;
	case 6: 
if (eqStrings(token, ((NimStringDesc*) &TMP200))) goto LA18;
break;
	case 7: 
if (eqStrings(token, ((NimStringDesc*) &TMP209))) goto LA27;
break;
	case 8: 
if (eqStrings(token, ((NimStringDesc*) &TMP201))) goto LA19;
break;
	case 10: 
if (eqStrings(token, ((NimStringDesc*) &TMP187))) goto LA5;
if (eqStrings(token, ((NimStringDesc*) &TMP193))) goto LA11;
if (eqStrings(token, ((NimStringDesc*) &TMP194))) goto LA12;
if (eqStrings(token, ((NimStringDesc*) &TMP198))) goto LA16;
if (eqStrings(token, ((NimStringDesc*) &TMP202))) goto LA20;
break;
	case 12: 
if (eqStrings(token, ((NimStringDesc*) &TMP195))) goto LA13;
break;
	case 14: 
if (eqStrings(token, ((NimStringDesc*) &TMP208))) goto LA26;
break;
	case 15: 
if (eqStrings(token, ((NimStringDesc*) &TMP186))) goto LA4;
if (eqStrings(token, ((NimStringDesc*) &TMP199))) goto LA17;
break;
	case 21: 
if (eqStrings(token, ((NimStringDesc*) &TMP184))) goto LA2;
if (eqStrings(token, ((NimStringDesc*) &TMP191))) goto LA9;
break;
	case 22: 
if (eqStrings(token, ((NimStringDesc*) &TMP197))) goto LA15;
if (eqStrings(token, ((NimStringDesc*) &TMP207))) goto LA25;
break;
	case 24: 
if (eqStrings(token, ((NimStringDesc*) &TMP189))) goto LA7;
break;
	case 25: 
if (eqStrings(token, ((NimStringDesc*) &TMP190))) goto LA8;
break;
	case 28: 
if (eqStrings(token, ((NimStringDesc*) &TMP196))) goto LA14;
break;
	case 29: 
if (eqStrings(token, ((NimStringDesc*) &TMP203))) goto LA21;
break;
	case 30: 
if (eqStrings(token, ((NimStringDesc*) &TMP206))) goto LA24;
break;
	case 31: 
if (eqStrings(token, ((NimStringDesc*) &TMP185))) goto LA3;
if (eqStrings(token, ((NimStringDesc*) &TMP188))) goto LA6;
if (eqStrings(token, ((NimStringDesc*) &TMP204))) goto LA22;
break;
	}
	goto LA29;
	LA1: ;
	{
		NimStringDesc* LOC32;
		nimln(569, "times.nim");
		nimln(569, "times.nim");
		LOC32 = 0;
		LOC32 = nimIntToStr(((NI) ((*info).Monthday)));
		(*buf) = resizeString((*buf), LOC32->Sup.len + 0);
appendString((*buf), LOC32);
	}
	goto LA30;
	LA2: ;
	{
		NimStringDesc* LOC38;
		nimln(571, "times.nim");
		{
			nimln(571, "times.nim");
			if (!(((NI) ((*info).Monthday)) < 10)) goto LA36;
			nimln(572, "times.nim");
			(*buf) = resizeString((*buf), 1);
appendString((*buf), ((NimStringDesc*) &TMP210));
		}
		LA36: ;
		nimln(573, "times.nim");
		nimln(573, "times.nim");
		LOC38 = 0;
		LOC38 = nimIntToStr(((NI) ((*info).Monthday)));
		(*buf) = resizeString((*buf), LOC38->Sup.len + 0);
appendString((*buf), LOC38);
	}
	goto LA30;
	LA3: ;
	{
		NimStringDesc* LOC40;
		tslice79092 LOC41;
		NimStringDesc* LOC42;
		nimln(575, "times.nim");
		nimln(575, "times.nim");
		nimln(575, "times.nim");
		LOC40 = 0;
		LOC40 = HEX24_94824((*info).Weekday);
		nimln(575, "times.nim");
		LOC41 = HEX2EHEX2E_85221(0, 2);
		LOC42 = 0;
		LOC42 = HEX5BHEX5D_79085(LOC40, LOC41);
		(*buf) = resizeString((*buf), LOC42->Sup.len + 0);
appendString((*buf), LOC42);
	}
	goto LA30;
	LA4: ;
	{
		NimStringDesc* LOC44;
		nimln(577, "times.nim");
		nimln(577, "times.nim");
		LOC44 = 0;
		LOC44 = HEX24_94824((*info).Weekday);
		(*buf) = resizeString((*buf), LOC44->Sup.len + 0);
appendString((*buf), LOC44);
	}
	goto LA30;
	LA5: ;
	{
		NI LOC46;
		NimStringDesc* LOC52;
		nimln(579, "times.nim");
		nimln(579, "times.nim");
		LOC46 = 0;
		nimln(579, "times.nim");
		{
			NI TMP213;
			nimln(579, "times.nim");
			if (!(12 < ((NI) ((*info).Hour)))) goto LA49;
			nimln(579, "times.nim");
			TMP213 = subInt(((NI) ((*info).Hour)), 12);
			LOC46 = ((NI) ((NI32)(TMP213)));
		}
		goto LA47;
		LA49: ;
		{
			LOC46 = ((NI) ((*info).Hour));
		}
		LA47: ;
		LOC52 = 0;
		LOC52 = nimIntToStr(LOC46);
		(*buf) = resizeString((*buf), LOC52->Sup.len + 0);
appendString((*buf), LOC52);
	}
	goto LA30;
	LA6: ;
	{
		NI amerhour;
		NimStringDesc* LOC63;
		nimln(581, "times.nim");
		nimln(581, "times.nim");
		{
			NI TMP214;
			nimln(581, "times.nim");
			if (!(12 < ((NI) ((*info).Hour)))) goto LA56;
			nimln(581, "times.nim");
			TMP214 = subInt(((NI) ((*info).Hour)), 12);
			amerhour = ((NI) ((NI32)(TMP214)));
		}
		goto LA54;
		LA56: ;
		{
			amerhour = ((NI) ((*info).Hour));
		}
		LA54: ;
		nimln(582, "times.nim");
		{
			nimln(582, "times.nim");
			if (!(amerhour < 10)) goto LA61;
			nimln(583, "times.nim");
			(*buf) = addChar((*buf), 48);
		}
		LA61: ;
		nimln(584, "times.nim");
		nimln(584, "times.nim");
		LOC63 = 0;
		LOC63 = nimIntToStr(amerhour);
		(*buf) = resizeString((*buf), LOC63->Sup.len + 0);
appendString((*buf), LOC63);
	}
	goto LA30;
	LA7: ;
	{
		NimStringDesc* LOC65;
		nimln(586, "times.nim");
		nimln(586, "times.nim");
		LOC65 = 0;
		LOC65 = nimIntToStr(((NI) ((*info).Hour)));
		(*buf) = resizeString((*buf), LOC65->Sup.len + 0);
appendString((*buf), LOC65);
	}
	goto LA30;
	LA8: ;
	{
		NimStringDesc* LOC71;
		nimln(588, "times.nim");
		{
			nimln(588, "times.nim");
			if (!(((NI) ((*info).Hour)) < 10)) goto LA69;
			nimln(589, "times.nim");
			(*buf) = addChar((*buf), 48);
		}
		LA69: ;
		nimln(590, "times.nim");
		nimln(590, "times.nim");
		LOC71 = 0;
		LOC71 = nimIntToStr(((NI) ((*info).Hour)));
		(*buf) = resizeString((*buf), LOC71->Sup.len + 0);
appendString((*buf), LOC71);
	}
	goto LA30;
	LA9: ;
	{
		NimStringDesc* LOC73;
		nimln(592, "times.nim");
		nimln(592, "times.nim");
		LOC73 = 0;
		LOC73 = nimIntToStr(((NI) ((*info).Minute)));
		(*buf) = resizeString((*buf), LOC73->Sup.len + 0);
appendString((*buf), LOC73);
	}
	goto LA30;
	LA10: ;
	{
		NimStringDesc* LOC79;
		nimln(594, "times.nim");
		{
			nimln(594, "times.nim");
			if (!(((NI) ((*info).Minute)) < 10)) goto LA77;
			nimln(595, "times.nim");
			(*buf) = addChar((*buf), 48);
		}
		LA77: ;
		nimln(596, "times.nim");
		nimln(596, "times.nim");
		LOC79 = 0;
		LOC79 = nimIntToStr(((NI) ((*info).Minute)));
		(*buf) = resizeString((*buf), LOC79->Sup.len + 0);
appendString((*buf), LOC79);
	}
	goto LA30;
	LA11: ;
	{
		NI TMP215;
		NimStringDesc* LOC81;
		nimln(598, "times.nim");
		nimln(598, "times.nim");
		nimln(598, "times.nim");
		TMP215 = addInt(((NI) ((*info).Month)), 1);
		LOC81 = 0;
		LOC81 = nimIntToStr((NI32)(TMP215));
		(*buf) = resizeString((*buf), LOC81->Sup.len + 0);
appendString((*buf), LOC81);
	}
	goto LA30;
	LA12: ;
	{
		NI TMP216;
		NimStringDesc* LOC87;
		nimln(600, "times.nim");
		{
			nimln(600, "times.nim");
			if (!((*info).Month < ((NU8) 9))) goto LA85;
			nimln(601, "times.nim");
			(*buf) = addChar((*buf), 48);
		}
		LA85: ;
		nimln(602, "times.nim");
		nimln(602, "times.nim");
		nimln(602, "times.nim");
		TMP216 = addInt(((NI) ((*info).Month)), 1);
		LOC87 = 0;
		LOC87 = nimIntToStr((NI32)(TMP216));
		(*buf) = resizeString((*buf), LOC87->Sup.len + 0);
appendString((*buf), LOC87);
	}
	goto LA30;
	LA13: ;
	{
		NimStringDesc* LOC89;
		tslice79092 LOC90;
		NimStringDesc* LOC91;
		nimln(604, "times.nim");
		nimln(604, "times.nim");
		nimln(604, "times.nim");
		LOC89 = 0;
		LOC89 = HEX24_94836((*info).Month);
		nimln(604, "times.nim");
		LOC90 = HEX2EHEX2E_85221(0, 2);
		LOC91 = 0;
		LOC91 = HEX5BHEX5D_79085(LOC89, LOC90);
		(*buf) = resizeString((*buf), LOC91->Sup.len + 0);
appendString((*buf), LOC91);
	}
	goto LA30;
	LA14: ;
	{
		NimStringDesc* LOC93;
		nimln(606, "times.nim");
		nimln(606, "times.nim");
		LOC93 = 0;
		LOC93 = HEX24_94836((*info).Month);
		(*buf) = resizeString((*buf), LOC93->Sup.len + 0);
appendString((*buf), LOC93);
	}
	goto LA30;
	LA15: ;
	{
		NimStringDesc* LOC95;
		nimln(608, "times.nim");
		nimln(608, "times.nim");
		LOC95 = 0;
		LOC95 = nimIntToStr(((NI) ((*info).Second)));
		(*buf) = resizeString((*buf), LOC95->Sup.len + 0);
appendString((*buf), LOC95);
	}
	goto LA30;
	LA16: ;
	{
		NimStringDesc* LOC101;
		nimln(610, "times.nim");
		{
			nimln(610, "times.nim");
			if (!(((NI) ((*info).Second)) < 10)) goto LA99;
			nimln(611, "times.nim");
			(*buf) = addChar((*buf), 48);
		}
		LA99: ;
		nimln(612, "times.nim");
		nimln(612, "times.nim");
		LOC101 = 0;
		LOC101 = nimIntToStr(((NI) ((*info).Second)));
		(*buf) = resizeString((*buf), LOC101->Sup.len + 0);
appendString((*buf), LOC101);
	}
	goto LA30;
	LA17: ;
	{
		nimln(614, "times.nim");
		{
			nimln(614, "times.nim");
			if (!(12 <= ((NI) ((*info).Hour)))) goto LA105;
			nimln(615, "times.nim");
			(*buf) = addChar((*buf), 80);
		}
		goto LA103;
		LA105: ;
		{
			nimln(616, "times.nim");
			(*buf) = addChar((*buf), 65);
		}
		LA103: ;
	}
	goto LA30;
	LA18: ;
	{
		nimln(618, "times.nim");
		{
			nimln(618, "times.nim");
			if (!(12 <= ((NI) ((*info).Hour)))) goto LA111;
			nimln(619, "times.nim");
			(*buf) = resizeString((*buf), 2);
appendString((*buf), ((NimStringDesc*) &TMP217));
		}
		goto LA109;
		LA111: ;
		{
			nimln(620, "times.nim");
			(*buf) = resizeString((*buf), 2);
appendString((*buf), ((NimStringDesc*) &TMP218));
		}
		LA109: ;
	}
	goto LA30;
	LA19: ;
	{
		NI fr;
		NimStringDesc* LOC115;
		NI TMP219;
		NimStringDesc* LOC120;
		NimStringDesc* LOC121;
		NI TMP220;
		tslice79092 LOC122;
		NimStringDesc* LOC123;
		nimln(622, "times.nim");
		nimln(622, "times.nim");
		nimln(622, "times.nim");
		nimln(622, "times.nim");
		LOC115 = 0;
		LOC115 = nimIntToStr(((NI) ((*info).Year)));
		TMP219 = subInt(LOC115->Sup.len, 1);
		fr = (NI32)(TMP219);
		nimln(623, "times.nim");
		{
			nimln(623, "times.nim");
			if (!(fr < 0)) goto LA118;
			nimln(623, "times.nim");
			fr = 0;
		}
		LA118: ;
		nimln(624, "times.nim");
		nimln(624, "times.nim");
		nimln(624, "times.nim");
		LOC120 = 0;
		LOC120 = nimIntToStr(((NI) ((*info).Year)));
		nimln(624, "times.nim");
		nimln(624, "times.nim");
		nimln(624, "times.nim");
		nimln(624, "times.nim");
		LOC121 = 0;
		LOC121 = nimIntToStr(((NI) ((*info).Year)));
		TMP220 = subInt(LOC121->Sup.len, 1);
		LOC122 = HEX2EHEX2E_85221(fr, (NI32)(TMP220));
		LOC123 = 0;
		LOC123 = HEX5BHEX5D_79085(LOC120, LOC122);
		(*buf) = resizeString((*buf), LOC123->Sup.len + 0);
appendString((*buf), LOC123);
	}
	goto LA30;
	LA20: ;
	{
		NI fr;
		NimStringDesc* LOC125;
		NI TMP221;
		NimStringDesc* fyear;
		NimStringDesc* LOC130;
		NimStringDesc* LOC131;
		NI TMP222;
		tslice79092 LOC132;
		nimln(626, "times.nim");
		nimln(626, "times.nim");
		nimln(626, "times.nim");
		nimln(626, "times.nim");
		LOC125 = 0;
		LOC125 = nimIntToStr(((NI) ((*info).Year)));
		TMP221 = subInt(LOC125->Sup.len, 2);
		fr = (NI32)(TMP221);
		nimln(627, "times.nim");
		{
			nimln(627, "times.nim");
			if (!(fr < 0)) goto LA128;
			nimln(627, "times.nim");
			fr = 0;
		}
		LA128: ;
		nimln(628, "times.nim");
		nimln(628, "times.nim");
		LOC130 = 0;
		LOC130 = nimIntToStr(((NI) ((*info).Year)));
		nimln(628, "times.nim");
		nimln(628, "times.nim");
		nimln(628, "times.nim");
		nimln(628, "times.nim");
		LOC131 = 0;
		LOC131 = nimIntToStr(((NI) ((*info).Year)));
		TMP222 = subInt(LOC131->Sup.len, 1);
		LOC132 = HEX2EHEX2E_85221(fr, (NI32)(TMP222));
		fyear = HEX5BHEX5D_79085(LOC130, LOC132);
		nimln(629, "times.nim");
		{
			NimStringDesc* LOC137;
			NI TMP224;
			NimStringDesc* LOC138;
			nimln(629, "times.nim");
			nimln(629, "times.nim");
			nimln(629, "times.nim");
			if (!!((fyear->Sup.len == 2))) goto LA135;
			nimln(629, "times.nim");
			nimln(629, "times.nim");
			LOC137 = 0;
			nimln(629, "times.nim");
			nimln(629, "times.nim");
			nimln(629, "times.nim");
			TMP224 = subInt(2, fyear->Sup.len);
			LOC138 = 0;
			LOC138 = nsuRepeatChar((NI32)(TMP224), 48);
			LOC137 = rawNewString(LOC138->Sup.len + fyear->Sup.len + 0);
appendString(LOC137, LOC138);
appendString(LOC137, fyear);
			fyear = LOC137;
		}
		LA135: ;
		nimln(630, "times.nim");
		(*buf) = resizeString((*buf), fyear->Sup.len + 0);
appendString((*buf), fyear);
	}
	goto LA30;
	LA21: ;
	{
		NI fr;
		NimStringDesc* LOC140;
		NI TMP225;
		NimStringDesc* fyear;
		NimStringDesc* LOC145;
		NimStringDesc* LOC146;
		NI TMP226;
		tslice79092 LOC147;
		nimln(632, "times.nim");
		nimln(632, "times.nim");
		nimln(632, "times.nim");
		nimln(632, "times.nim");
		LOC140 = 0;
		LOC140 = nimIntToStr(((NI) ((*info).Year)));
		TMP225 = subInt(LOC140->Sup.len, 3);
		fr = (NI32)(TMP225);
		nimln(633, "times.nim");
		{
			nimln(633, "times.nim");
			if (!(fr < 0)) goto LA143;
			nimln(633, "times.nim");
			fr = 0;
		}
		LA143: ;
		nimln(634, "times.nim");
		nimln(634, "times.nim");
		LOC145 = 0;
		LOC145 = nimIntToStr(((NI) ((*info).Year)));
		nimln(634, "times.nim");
		nimln(634, "times.nim");
		nimln(634, "times.nim");
		nimln(634, "times.nim");
		LOC146 = 0;
		LOC146 = nimIntToStr(((NI) ((*info).Year)));
		TMP226 = subInt(LOC146->Sup.len, 1);
		LOC147 = HEX2EHEX2E_85221(fr, (NI32)(TMP226));
		fyear = HEX5BHEX5D_79085(LOC145, LOC147);
		nimln(635, "times.nim");
		{
			NimStringDesc* LOC152;
			NI TMP227;
			NimStringDesc* LOC153;
			nimln(635, "times.nim");
			nimln(635, "times.nim");
			nimln(635, "times.nim");
			if (!!((fyear->Sup.len == 3))) goto LA150;
			nimln(635, "times.nim");
			nimln(635, "times.nim");
			LOC152 = 0;
			nimln(635, "times.nim");
			nimln(635, "times.nim");
			nimln(635, "times.nim");
			TMP227 = subInt(3, fyear->Sup.len);
			LOC153 = 0;
			LOC153 = nsuRepeatChar((NI32)(TMP227), 48);
			LOC152 = rawNewString(LOC153->Sup.len + fyear->Sup.len + 0);
appendString(LOC152, LOC153);
appendString(LOC152, fyear);
			fyear = LOC152;
		}
		LA150: ;
		nimln(636, "times.nim");
		(*buf) = resizeString((*buf), fyear->Sup.len + 0);
appendString((*buf), fyear);
	}
	goto LA30;
	LA22: ;
	{
		NI fr;
		NimStringDesc* LOC155;
		NI TMP228;
		NimStringDesc* fyear;
		NimStringDesc* LOC160;
		NimStringDesc* LOC161;
		NI TMP229;
		tslice79092 LOC162;
		nimln(638, "times.nim");
		nimln(638, "times.nim");
		nimln(638, "times.nim");
		nimln(638, "times.nim");
		LOC155 = 0;
		LOC155 = nimIntToStr(((NI) ((*info).Year)));
		TMP228 = subInt(LOC155->Sup.len, 4);
		fr = (NI32)(TMP228);
		nimln(639, "times.nim");
		{
			nimln(639, "times.nim");
			if (!(fr < 0)) goto LA158;
			nimln(639, "times.nim");
			fr = 0;
		}
		LA158: ;
		nimln(640, "times.nim");
		nimln(640, "times.nim");
		LOC160 = 0;
		LOC160 = nimIntToStr(((NI) ((*info).Year)));
		nimln(640, "times.nim");
		nimln(640, "times.nim");
		nimln(640, "times.nim");
		nimln(640, "times.nim");
		LOC161 = 0;
		LOC161 = nimIntToStr(((NI) ((*info).Year)));
		TMP229 = subInt(LOC161->Sup.len, 1);
		LOC162 = HEX2EHEX2E_85221(fr, (NI32)(TMP229));
		fyear = HEX5BHEX5D_79085(LOC160, LOC162);
		nimln(641, "times.nim");
		{
			NimStringDesc* LOC167;
			NI TMP230;
			NimStringDesc* LOC168;
			nimln(641, "times.nim");
			nimln(641, "times.nim");
			nimln(641, "times.nim");
			if (!!((fyear->Sup.len == 4))) goto LA165;
			nimln(641, "times.nim");
			nimln(641, "times.nim");
			LOC167 = 0;
			nimln(641, "times.nim");
			nimln(641, "times.nim");
			nimln(641, "times.nim");
			TMP230 = subInt(4, fyear->Sup.len);
			LOC168 = 0;
			LOC168 = nsuRepeatChar((NI32)(TMP230), 48);
			LOC167 = rawNewString(LOC168->Sup.len + fyear->Sup.len + 0);
appendString(LOC167, LOC168);
appendString(LOC167, fyear);
			fyear = LOC167;
		}
		LA165: ;
		nimln(642, "times.nim");
		(*buf) = resizeString((*buf), fyear->Sup.len + 0);
appendString((*buf), fyear);
	}
	goto LA30;
	LA23: ;
	{
		NI fr;
		NimStringDesc* LOC170;
		NI TMP231;
		NimStringDesc* fyear;
		NimStringDesc* LOC175;
		NimStringDesc* LOC176;
		NI TMP232;
		tslice79092 LOC177;
		nimln(644, "times.nim");
		nimln(644, "times.nim");
		nimln(644, "times.nim");
		nimln(644, "times.nim");
		LOC170 = 0;
		LOC170 = nimIntToStr(((NI) ((*info).Year)));
		TMP231 = subInt(LOC170->Sup.len, 5);
		fr = (NI32)(TMP231);
		nimln(645, "times.nim");
		{
			nimln(645, "times.nim");
			if (!(fr < 0)) goto LA173;
			nimln(645, "times.nim");
			fr = 0;
		}
		LA173: ;
		nimln(646, "times.nim");
		nimln(646, "times.nim");
		LOC175 = 0;
		LOC175 = nimIntToStr(((NI) ((*info).Year)));
		nimln(646, "times.nim");
		nimln(646, "times.nim");
		nimln(646, "times.nim");
		nimln(646, "times.nim");
		LOC176 = 0;
		LOC176 = nimIntToStr(((NI) ((*info).Year)));
		TMP232 = subInt(LOC176->Sup.len, 1);
		LOC177 = HEX2EHEX2E_85221(fr, (NI32)(TMP232));
		fyear = HEX5BHEX5D_79085(LOC175, LOC177);
		nimln(647, "times.nim");
		{
			NimStringDesc* LOC182;
			NI TMP233;
			NimStringDesc* LOC183;
			nimln(647, "times.nim");
			nimln(647, "times.nim");
			nimln(647, "times.nim");
			if (!!((fyear->Sup.len == 5))) goto LA180;
			nimln(647, "times.nim");
			nimln(647, "times.nim");
			LOC182 = 0;
			nimln(647, "times.nim");
			nimln(647, "times.nim");
			nimln(647, "times.nim");
			TMP233 = subInt(5, fyear->Sup.len);
			LOC183 = 0;
			LOC183 = nsuRepeatChar((NI32)(TMP233), 48);
			LOC182 = rawNewString(LOC183->Sup.len + fyear->Sup.len + 0);
appendString(LOC182, LOC183);
appendString(LOC182, fyear);
			fyear = LOC182;
		}
		LA180: ;
		nimln(648, "times.nim");
		(*buf) = resizeString((*buf), fyear->Sup.len + 0);
appendString((*buf), fyear);
	}
	goto LA30;
	LA24: ;
	{
		NI hrs;
		NI TMP234;
		NI TMP235;
		NimStringDesc* LOC185;
		nimln(650, "times.nim");
		nimln(650, "times.nim");
		nimln(650, "times.nim");
		TMP234 = divInt((*info).Timezone, 60);
		TMP235 = divInt((NI32)(TMP234), 60);
		hrs = (NI32)(TMP235);
		nimln(651, "times.nim");
		nimln(651, "times.nim");
		LOC185 = 0;
		LOC185 = nimIntToStr(hrs);
		(*buf) = resizeString((*buf), LOC185->Sup.len + 0);
appendString((*buf), LOC185);
	}
	goto LA30;
	LA25: ;
	{
		NI hrs;
		NI TMP236;
		NI TMP237;
		NimStringDesc* LOC187;
		nimln(653, "times.nim");
		nimln(653, "times.nim");
		nimln(653, "times.nim");
		TMP236 = divInt((*info).Timezone, 60);
		TMP237 = divInt((NI32)(TMP236), 60);
		hrs = (NI32)(TMP237);
		nimln(655, "times.nim");
		nimln(655, "times.nim");
		LOC187 = 0;
		LOC187 = nimIntToStr(hrs);
		(*buf) = resizeString((*buf), LOC187->Sup.len + 0);
appendString((*buf), LOC187);
		nimln(656, "times.nim");
		{
			NI atindex;
			NimStringDesc* LOC192;
			NI LOC193;
			NI TMP238;
			NI TMP239;
			nimln(656, "times.nim");
			nimln(656, "times.nim");
			if (hrs == (-2147483647 -1)) raiseOverflow();
			if (!((NI32)abs(hrs) < 10)) goto LA190;
			nimln(657, "times.nim");
			nimln(657, "times.nim");
			nimln(657, "times.nim");
			nimln(657, "times.nim");
			nimln(657, "times.nim");
			nimln(657, "times.nim");
			LOC192 = 0;
			LOC192 = nimIntToStr(hrs);
			LOC193 = 0;
			nimln(657, "times.nim");
			{
				nimln(657, "times.nim");
				if (!(hrs < 0)) goto LA196;
				LOC193 = 1;
			}
			goto LA194;
			LA196: ;
			{
				LOC193 = 0;
			}
			LA194: ;
			TMP238 = subInt(LOC192->Sup.len, LOC193);
			TMP239 = subInt((*buf)->Sup.len, (NI32)(TMP238));
			atindex = (NI32)(TMP239);
			nimln(658, "times.nim");
			insert_80801(buf, ((NimStringDesc*) &TMP210), atindex);
		}
		LA190: ;
	}
	goto LA30;
	LA26: ;
	{
		NI hrs;
		NI TMP240;
		NI TMP241;
		NimStringDesc* LOC200;
		NimStringDesc* LOC201;
		nimln(660, "times.nim");
		nimln(660, "times.nim");
		nimln(660, "times.nim");
		TMP240 = divInt((*info).Timezone, 60);
		TMP241 = divInt((NI32)(TMP240), 60);
		hrs = (NI32)(TMP241);
		nimln(662, "times.nim");
		nimln(662, "times.nim");
		LOC200 = 0;
		nimln(662, "times.nim");
		LOC201 = 0;
		LOC201 = nimIntToStr(hrs);
		LOC200 = rawNewString(LOC201->Sup.len + 3);
appendString(LOC200, LOC201);
appendString(LOC200, ((NimStringDesc*) &TMP242));
		(*buf) = resizeString((*buf), LOC200->Sup.len + 0);
appendString((*buf), LOC200);
		nimln(663, "times.nim");
		{
			NI atindex;
			NimStringDesc* LOC206;
			NimStringDesc* LOC207;
			NI LOC208;
			NI TMP243;
			NI TMP244;
			nimln(663, "times.nim");
			nimln(663, "times.nim");
			if (hrs == (-2147483647 -1)) raiseOverflow();
			if (!((NI32)abs(hrs) < 10)) goto LA204;
			nimln(664, "times.nim");
			nimln(664, "times.nim");
			nimln(664, "times.nim");
			nimln(664, "times.nim");
			nimln(664, "times.nim");
			nimln(664, "times.nim");
			LOC206 = 0;
			nimln(664, "times.nim");
			LOC207 = 0;
			LOC207 = nimIntToStr(hrs);
			LOC206 = rawNewString(LOC207->Sup.len + 3);
appendString(LOC206, LOC207);
appendString(LOC206, ((NimStringDesc*) &TMP242));
			LOC208 = 0;
			nimln(664, "times.nim");
			{
				nimln(664, "times.nim");
				if (!(hrs < 0)) goto LA211;
				LOC208 = 1;
			}
			goto LA209;
			LA211: ;
			{
				LOC208 = 0;
			}
			LA209: ;
			TMP243 = subInt(LOC206->Sup.len, LOC208);
			TMP244 = subInt((*buf)->Sup.len, (NI32)(TMP243));
			atindex = (NI32)(TMP244);
			nimln(665, "times.nim");
			insert_80801(buf, ((NimStringDesc*) &TMP210), atindex);
		}
		LA204: ;
	}
	goto LA30;
	LA27: ;
	{
		nimln(667, "times.nim");
		(*buf) = resizeString((*buf), (*info).Tzname->Sup.len + 0);
appendString((*buf), (*info).Tzname);
	}
	goto LA30;
	LA28: ;
	{
	}
	goto LA30;
	LA29: ;
	{
		einvalidvalue2453* e_94976;
		NimStringDesc* LOC217;
		e_94976 = 0;
		nimln(1992, "system.nim");
		e_94976 = (einvalidvalue2453*) newObj((&NTI18001), sizeof(einvalidvalue2453));
		(*e_94976).Sup.Sup.Sup.m_type = (&NTI2453);
		nimln(1993, "system.nim");
		nimln(671, "times.nim");
		LOC217 = 0;
		LOC217 = rawNewString(token->Sup.len + 23);
appendString(LOC217, ((NimStringDesc*) &TMP245));
appendString(LOC217, token);
		asgnRefNoCycle((void**) &(*e_94976).Sup.Sup.message, LOC217);
		nimln(671, "times.nim");
		raiseException((E_Base*)e_94976, "EInvalidValue");
	}
	LA30: ;
	popFrame();
}

N_NIMCALL(NimStringDesc*, format_94999)(ttimeinfo93003* info, NimStringDesc* f) {
	NimStringDesc* result;
	NI i;
	NimStringDesc* currentf;
	nimfr("format", "times.nim")
	result = 0;
	nimln(714, "times.nim");
	result = copyString(((NimStringDesc*) &TMP157));
	nimln(715, "times.nim");
	i = 0;
	nimln(716, "times.nim");
	currentf = copyString(((NimStringDesc*) &TMP157));
	nimln(717, "times.nim");
	while (1) {
		nimln(718, "times.nim");
		if ((NU)(i) > (NU)(f->Sup.len)) raiseIndexError();
		switch (((NU8)(f->data[i]))) {
		case 32:
		case 45:
		case 47:
		case 58:
		case 39:
		case 0:
		case 40:
		case 41:
		case 91:
		case 93:
		case 44:
		{
			nimln(720, "times.nim");
			formattoken_94848(info, currentf, &result);
			nimln(722, "times.nim");
			currentf = copyString(((NimStringDesc*) &TMP157));
			nimln(723, "times.nim");
			{
				nimln(723, "times.nim");
				if ((NU)(i) > (NU)(f->Sup.len)) raiseIndexError();
				if (!((NU8)(f->data[i]) == (NU8)(0))) goto LA5;
				nimln(723, "times.nim");
				goto LA1;
			}
			LA5: ;
			nimln(725, "times.nim");
			{
				nimln(725, "times.nim");
				if ((NU)(i) > (NU)(f->Sup.len)) raiseIndexError();
				if (!((NU8)(f->data[i]) == (NU8)(39))) goto LA9;
				nimln(726, "times.nim");
				i = addInt(i, 1);
				nimln(727, "times.nim");
				while (1) {
					NIM_BOOL LOC12;
					NI TMP246;
					nimln(727, "times.nim");
					LOC12 = 0;
					nimln(727, "times.nim");
					nimln(727, "times.nim");
					if ((NU)(i) > (NU)(f->Sup.len)) raiseIndexError();
					LOC12 = !(((NU8)(f->data[i]) == (NU8)(39)));
					if (!(LOC12)) goto LA13;
					nimln(727, "times.nim");
					nimln(727, "times.nim");
					nimln(727, "times.nim");
					TMP246 = subInt(f->Sup.len, 1);
					LOC12 = (i < (NI32)(TMP246));
					LA13: ;
					if (!LOC12) goto LA11;
					nimln(728, "times.nim");
					if ((NU)(i) > (NU)(f->Sup.len)) raiseIndexError();
					result = addChar(result, f->data[i]);
					nimln(729, "times.nim");
					i = addInt(i, 1);
				} LA11: ;
			}
			goto LA7;
			LA9: ;
			{
				nimln(730, "times.nim");
				if ((NU)(i) > (NU)(f->Sup.len)) raiseIndexError();
				result = addChar(result, f->data[i]);
			}
			LA7: ;
		}
		break;
		default:
		{
			nimln(734, "times.nim");
			{
				NIM_BOOL LOC18;
				nimln(734, "times.nim");
				LOC18 = 0;
				nimln(734, "times.nim");
				nimln(734, "times.nim");
				LOC18 = (currentf->Sup.len < 1);
				if (LOC18) goto LA19;
				nimln(734, "times.nim");
				nimln(734, "times.nim");
				if ((NU)((currentf->Sup.len-1)) > (NU)(currentf->Sup.len)) raiseIndexError();
				if ((NU)(i) > (NU)(f->Sup.len)) raiseIndexError();
				LOC18 = ((NU8)(currentf->data[(currentf->Sup.len-1)]) == (NU8)(f->data[i]));
				LA19: ;
				if (!LOC18) goto LA20;
				nimln(735, "times.nim");
				if ((NU)(i) > (NU)(f->Sup.len)) raiseIndexError();
				currentf = addChar(currentf, f->data[i]);
			}
			goto LA16;
			LA20: ;
			{
				nimln(737, "times.nim");
				formattoken_94848(info, currentf, &result);
				nimln(738, "times.nim");
				i = subInt(i, 1);
				nimln(739, "times.nim");
				currentf = copyString(((NimStringDesc*) &TMP157));
			}
			LA16: ;
		}
		break;
		}
		nimln(741, "times.nim");
		i = addInt(i, 1);
	} LA1: ;
	popFrame();
	return result;
}
N_NOINLINE(void, stdlibtimesInit)(void) {
	nimfr("times", "times.nim")
	popFrame();
}

N_NOINLINE(void, stdlibtimesDatInit)(void) {
static TNimNode* TMP135[11];
static TNimNode* TMP136[12];
NI TMP138;
static char* NIM_CONST TMP137[12] = {
"mJan", 
"mFeb", 
"mMar", 
"mApr", 
"mMay", 
"mJun", 
"mJul", 
"mAug", 
"mSep", 
"mOct", 
"mNov", 
"mDec"};
static TNimNode* TMP139[7];
NI TMP141;
static char* NIM_CONST TMP140[7] = {
"dMon", 
"dTue", 
"dWed", 
"dThu", 
"dFri", 
"dSat", 
"dSun"};
static TNimNode* TMP286[2];
static TNimNode TMP130[36];
NTI93003.size = sizeof(ttimeinfo93003);
NTI93003.kind = 17;
NTI93003.base = (&NTI2409);
TMP135[0] = &TMP130[1];
NTI93006.size = sizeof(NI);
NTI93006.kind = 20;
NTI93006.base = (&NTI106);
NTI93006.flags = 3;
TMP130[1].kind = 1;
TMP130[1].offset = offsetof(ttimeinfo93003, Second);
TMP130[1].typ = (&NTI93006);
TMP130[1].name = "second";
TMP135[1] = &TMP130[2];
NTI93009.size = sizeof(NI);
NTI93009.kind = 20;
NTI93009.base = (&NTI106);
NTI93009.flags = 3;
TMP130[2].kind = 1;
TMP130[2].offset = offsetof(ttimeinfo93003, Minute);
TMP130[2].typ = (&NTI93009);
TMP130[2].name = "minute";
TMP135[2] = &TMP130[3];
NTI93011.size = sizeof(NI);
NTI93011.kind = 20;
NTI93011.base = (&NTI106);
NTI93011.flags = 3;
TMP130[3].kind = 1;
TMP130[3].offset = offsetof(ttimeinfo93003, Hour);
TMP130[3].typ = (&NTI93011);
TMP130[3].name = "hour";
TMP135[3] = &TMP130[4];
NTI93014.size = sizeof(NI);
NTI93014.kind = 20;
NTI93014.base = (&NTI106);
NTI93014.flags = 3;
TMP130[4].kind = 1;
TMP130[4].offset = offsetof(ttimeinfo93003, Monthday);
TMP130[4].typ = (&NTI93014);
TMP130[4].name = "monthday";
TMP135[4] = &TMP130[5];
NTI92804.size = sizeof(NU8);
NTI92804.kind = 14;
NTI92804.base = 0;
NTI92804.flags = 3;
for (TMP138 = 0; TMP138 < 12; TMP138++) {
TMP130[TMP138+6].kind = 1;
TMP130[TMP138+6].offset = TMP138;
TMP130[TMP138+6].name = TMP137[TMP138];
TMP136[TMP138] = &TMP130[TMP138+6];
}
TMP130[18].len = 12; TMP130[18].kind = 2; TMP130[18].sons = &TMP136[0];
NTI92804.node = &TMP130[18];
TMP130[5].kind = 1;
TMP130[5].offset = offsetof(ttimeinfo93003, Month);
TMP130[5].typ = (&NTI92804);
TMP130[5].name = "month";
TMP135[5] = &TMP130[19];
NTI93017.size = sizeof(NI);
NTI93017.kind = 20;
NTI93017.base = (&NTI106);
NTI93017.flags = 3;
TMP130[19].kind = 1;
TMP130[19].offset = offsetof(ttimeinfo93003, Year);
TMP130[19].typ = (&NTI93017);
TMP130[19].name = "year";
TMP135[6] = &TMP130[20];
NTI92806.size = sizeof(NU8);
NTI92806.kind = 14;
NTI92806.base = 0;
NTI92806.flags = 3;
for (TMP141 = 0; TMP141 < 7; TMP141++) {
TMP130[TMP141+21].kind = 1;
TMP130[TMP141+21].offset = TMP141;
TMP130[TMP141+21].name = TMP140[TMP141];
TMP139[TMP141] = &TMP130[TMP141+21];
}
TMP130[28].len = 7; TMP130[28].kind = 2; TMP130[28].sons = &TMP139[0];
NTI92806.node = &TMP130[28];
TMP130[20].kind = 1;
TMP130[20].offset = offsetof(ttimeinfo93003, Weekday);
TMP130[20].typ = (&NTI92806);
TMP130[20].name = "weekday";
TMP135[7] = &TMP130[29];
NTI93023.size = sizeof(NI);
NTI93023.kind = 20;
NTI93023.base = (&NTI106);
NTI93023.flags = 3;
TMP130[29].kind = 1;
TMP130[29].offset = offsetof(ttimeinfo93003, Yearday);
TMP130[29].typ = (&NTI93023);
TMP130[29].name = "yearday";
TMP135[8] = &TMP130[30];
TMP130[30].kind = 1;
TMP130[30].offset = offsetof(ttimeinfo93003, Isdst);
TMP130[30].typ = (&NTI134);
TMP130[30].name = "isDST";
TMP135[9] = &TMP130[31];
TMP130[31].kind = 1;
TMP130[31].offset = offsetof(ttimeinfo93003, Tzname);
TMP130[31].typ = (&NTI143);
TMP130[31].name = "tzname";
TMP135[10] = &TMP130[32];
TMP130[32].kind = 1;
TMP130[32].offset = offsetof(ttimeinfo93003, Timezone);
TMP130[32].typ = (&NTI106);
TMP130[32].name = "timezone";
TMP130[0].len = 11; TMP130[0].kind = 2; TMP130[0].sons = &TMP135[0];
NTI93003.node = &TMP130[0];
NTI93105.size = sizeof(TY93105);
NTI93105.kind = 18;
NTI93105.base = 0;
NTI93105.flags = 2;
TMP286[0] = &TMP130[34];
TMP130[34].kind = 1;
TMP130[34].offset = offsetof(TY93105, Field0);
TMP130[34].typ = (&NTI143);
TMP130[34].name = "Field0";
TMP286[1] = &TMP130[35];
TMP130[35].kind = 1;
TMP130[35].offset = offsetof(TY93105, Field1);
TMP130[35].typ = (&NTI143);
TMP130[35].name = "Field1";
TMP130[33].len = 2; TMP130[33].kind = 2; TMP130[33].sons = &TMP286[0];
NTI93105.node = &TMP130[33];
}

