// CONSTANT TOP 16777216
#define TOP 16777216
// CONSTANT _UNDEFINED 0
#define _UNDEFINED 0
// CONSTANT _F 1
#define _F 1
// CONSTANT _Y 2
#define _Y 2
// CONSTANT _Q 3
#define _Q 3
// CONSTANT _QQ 4
#define _QQ 4
// CONSTANT _S 5
#define _S 5
// CONSTANT _B 6
#define _B 6
// CONSTANT _C 7
#define _C 7
// CONSTANT _R 8
#define _R 8
// CONSTANT _V 9
#define _V 9
// CONSTANT _T 10
#define _T 10
// CONSTANT _K 11
#define _K 11
// CONSTANT _I 12
#define _I 12
// CONSTANT _CONS 13
#define _CONS 13
// CONSTANT _NUM 14
#define _NUM 14
// CONSTANT _DADD 15
#define _DADD 15
// CONSTANT _DSUB 16
#define _DSUB 16
// CONSTANT _DMUL 17
#define _DMUL 17
// CONSTANT _DDIV 18
#define _DDIV 18
// CONSTANT _DMOD 19
#define _DMOD 19
// CONSTANT _ADD 20
#define _ADD 20
// CONSTANT _SUB 21
#define _SUB 21
// CONSTANT _MUL 22
#define _MUL 22
// CONSTANT _QUOT 23
#define _QUOT 23
// CONSTANT _REM 24
#define _REM 24
// CONSTANT _DIV 25
#define _DIV 25
// CONSTANT _MOD 26
#define _MOD 26
// CONSTANT _EQ 27
#define _EQ 27
// CONSTANT _LE 28
#define _LE 28
// CONSTANT _U_DIV 29
#define _U_DIV 29
// CONSTANT _U_MOD 30
#define _U_MOD 30
// CONSTANT _U_LE 31
#define _U_LE 31
// CONSTANT _REF 32
#define _REF 32
// CONSTANT _READREF 33
#define _READREF 33
// CONSTANT _WRITEREF 34
#define _WRITEREF 34
// CONSTANT _END 35
#define _END 35

void *malloc(unsigned long);

unsigned *prog;
void init_prog() 
{
  prog = malloc(294* sizeof(unsigned));
  prog[0] = 11;
  prog[1] = 12;
  prog[2] = 1;
  prog[3] = 0;
  prog[4] = 10;
  prog[5] = 130;
  prog[6] = 10;
  prog[7] = 12;
  prog[8] = 10;
  prog[9] = 11;
  prog[10] = 10;
  prog[11] = 128;
  prog[12] = 3;
  prog[13] = 27;
  prog[14] = 3;
  prog[15] = 28;
  prog[16] = 3;
  prog[17] = 31;
  prog[18] = 6;
  prog[19] = 7;
  prog[20] = 6;
  prog[21] = 10;
  prog[22] = 148;
  prog[23] = 32;
  prog[24] = 146;
  prog[25] = 150;
  prog[26] = 10;
  prog[27] = 33;
  prog[28] = 8;
  prog[29] = 34;
  prog[30] = 156;
  prog[31] = 6;
  prog[32] = 10;
  prog[33] = 35;
  prog[34] = 7;
  prog[35] = 160;
  prog[36] = 162;
  prog[37] = 11;
  prog[38] = 164;
  prog[39] = 35;
  prog[40] = 4;
  prog[41] = 15;
  prog[42] = 4;
  prog[43] = 16;
  prog[44] = 4;
  prog[45] = 17;
  prog[46] = 4;
  prog[47] = 18;
  prog[48] = 4;
  prog[49] = 19;
  prog[50] = 3;
  prog[51] = 20;
  prog[52] = 3;
  prog[53] = 21;
  prog[54] = 3;
  prog[55] = 22;
  prog[56] = 3;
  prog[57] = 25;
  prog[58] = 3;
  prog[59] = 26;
  prog[60] = 3;
  prog[61] = 23;
  prog[62] = 3;
  prog[63] = 24;
  prog[64] = 3;
  prog[65] = 29;
  prog[66] = 3;
  prog[67] = 30;
  prog[68] = 8;
  prog[69] = 11;
  prog[70] = 6;
  prog[71] = 196;
  prog[72] = 6;
  prog[73] = 6;
  prog[74] = 6;
  prog[75] = 200;
  prog[76] = 202;
  prog[77] = 136;
  prog[78] = 198;
  prog[79] = 204;
  prog[80] = 5;
  prog[81] = 9;
  prog[82] = 6;
  prog[83] = 208;
  prog[84] = 146;
  prog[85] = 200;
  prog[86] = 200;
  prog[87] = 212;
  prog[88] = 5;
  prog[89] = 214;
  prog[90] = 216;
  prog[91] = 220;
  prog[92] = 210;
  prog[93] = 218;
  prog[94] = 200;
  prog[95] = 136;
  prog[96] = 200;
  prog[97] = 222;
  prog[98] = 7;
  prog[99] = 224;
  prog[100] = 6;
  prog[101] = 226;
  prog[102] = 228;
  prog[103] = 134;
  prog[104] = 6;
  prog[105] = 220;
  prog[106] = 6;
  prog[107] = 232;
  prog[108] = 200;
  prog[109] = 206;
  prog[110] = 234;
  prog[111] = 236;
  prog[112] = 146;
  prog[113] = 238;
  prog[114] = 7;
  prog[115] = 240;
  prog[116] = 6;
  prog[117] = 242;
  prog[118] = 8;
  prog[119] = 12;
  prog[120] = 246;
  prog[121] = 138;
  prog[122] = 244;
  prog[123] = 248;
  prog[124] = 250;
  prog[125] = 382;
  prog[126] = 252;
  prog[127] = 420;
  prog[128] = 254;
  prog[129] = 132;
  prog[130] = 14;
  prog[131] = 10;
  prog[132] = 132;
  prog[133] = 258;
  prog[134] = 8;
  prog[135] = 260;
  prog[136] = 206;
  prog[137] = 420;
  prog[138] = 6;
  prog[139] = 264;
  prog[140] = 266;
  prog[141] = 256;
  prog[142] = 262;
  prog[143] = 268;
  prog[144] = 14;
  prog[145] = 104;
  prog[146] = 13;
  prog[147] = 272;
  prog[148] = 14;
  prog[149] = 101;
  prog[150] = 13;
  prog[151] = 276;
  prog[152] = 14;
  prog[153] = 108;
  prog[154] = 13;
  prog[155] = 280;
  prog[156] = 14;
  prog[157] = 111;
  prog[158] = 13;
  prog[159] = 284;
  prog[160] = 14;
  prog[161] = 44;
  prog[162] = 13;
  prog[163] = 288;
  prog[164] = 14;
  prog[165] = 32;
  prog[166] = 13;
  prog[167] = 292;
  prog[168] = 14;
  prog[169] = 119;
  prog[170] = 13;
  prog[171] = 296;
  prog[172] = 14;
  prog[173] = 114;
  prog[174] = 13;
  prog[175] = 300;
  prog[176] = 14;
  prog[177] = 100;
  prog[178] = 13;
  prog[179] = 304;
  prog[180] = 14;
  prog[181] = 33;
  prog[182] = 13;
  prog[183] = 308;
  prog[184] = 310;
  prog[185] = 11;
  prog[186] = 306;
  prog[187] = 312;
  prog[188] = 282;
  prog[189] = 314;
  prog[190] = 302;
  prog[191] = 316;
  prog[192] = 286;
  prog[193] = 318;
  prog[194] = 298;
  prog[195] = 320;
  prog[196] = 294;
  prog[197] = 322;
  prog[198] = 290;
  prog[199] = 324;
  prog[200] = 286;
  prog[201] = 326;
  prog[202] = 282;
  prog[203] = 328;
  prog[204] = 282;
  prog[205] = 330;
  prog[206] = 278;
  prog[207] = 332;
  prog[208] = 274;
  prog[209] = 334;
  prog[210] = 270;
  prog[211] = 336;
  prog[212] = 6;
  prog[213] = 146;
  prog[214] = 6;
  prog[215] = 234;
  prog[216] = 8;
  prog[217] = 13;
  prog[218] = 6;
  prog[219] = 344;
  prog[220] = 7;
  prog[221] = 230;
  prog[222] = 346;
  prog[223] = 348;
  prog[224] = 202;
  prog[225] = 350;
  prog[226] = 342;
  prog[227] = 352;
  prog[228] = 340;
  prog[229] = 354;
  prog[230] = 146;
  prog[231] = 356;
  prog[232] = 5;
  prog[233] = 358;
  prog[234] = 196;
  prog[235] = 138;
  prog[236] = 360;
  prog[237] = 362;
  prog[238] = 8;
  prog[239] = 9;
  prog[240] = 6;
  prog[241] = 9;
  prog[242] = 8;
  prog[243] = 368;
  prog[244] = 200;
  prog[245] = 7;
  prog[246] = 370;
  prog[247] = 372;
  prog[248] = 8;
  prog[249] = 374;
  prog[250] = 376;
  prog[251] = 372;
  prog[252] = 10;
  prog[253] = 378;
  prog[254] = 366;
  prog[255] = 380;
  prog[256] = 10;
  prog[257] = 128;
  prog[258] = 196;
  prog[259] = 384;
  prog[260] = 8;
  prog[261] = 386;
  prog[262] = 6;
  prog[263] = 5;
  prog[264] = 8;
  prog[265] = 128;
  prog[266] = 392;
  prog[267] = 136;
  prog[268] = 8;
  prog[269] = 394;
  prog[270] = 396;
  prog[271] = 6;
  prog[272] = 390;
  prog[273] = 398;
  prog[274] = 388;
  prog[275] = 400;
  prog[276] = 10;
  prog[277] = 402;
  prog[278] = 10;
  prog[279] = 140;
  prog[280] = 10;
  prog[281] = 140;
  prog[282] = 136;
  prog[283] = 382;
  prog[284] = 6;
  prog[285] = 410;
  prog[286] = 412;
  prog[287] = 9;
  prog[288] = 10;
  prog[289] = 414;
  prog[290] = 10;
  prog[291] = 7;
  prog[292] = 366;
  prog[293] = 418;
}
unsigned prog_size=294;
#include<stdio.h>
int env_argc;
int getargcount() { return env_argc; }
char **env_argv;
char getargchar(int n, int k) { return env_argv[n][k]; }
char *buf;
char *bufp;
FILE *fp;
void reset_buffer() { bufp = buf; }
void put_buffer(int n) { bufp[0] = n; bufp = bufp + 1; }
void stdin_load_buffer() { fp = fopen(buf, "r"); }
int getchar_fp(void) { int n = fgetc(fp); if (n < 0) fclose(fp); return n; }
void putchar_cast(char c) { fputc(c,stdout); }
void *malloc(unsigned long);

// CONSTANT FALSE 0
#define FALSE 0
// CONSTANT TRUE 1
#define TRUE 1

// CONSTANT FORWARD 127
#define FORWARD 127
// CONSTANT REDUCING 126
#define REDUCING 126

//CONSTANT CELL_SIZE sizeof(unsigned)
#define CELL_SIZE 1

unsigned* mem;
unsigned* altmem;
unsigned* sp;
unsigned* spTop;
unsigned hp;

unsigned ready = 0;

unsigned isAddr(unsigned n)
{
	return n >= 128;
}

unsigned evac(unsigned n)
{
	if(!isAddr(n))
	{
		return n;
	}

	unsigned x = mem[n];

	while(isAddr(x) && mem[x] == _T)
	{
		mem[n] = mem[n + 1];
		mem[n + 1] = mem[x + 1];
		x = mem[n];
	}

	if(isAddr(x) && mem[x] == 'K')
	{
		mem[n + 1] = mem[x + 1];
		x = mem[n] = 'I';
	}

	unsigned y = mem[n + 1];

	if(FORWARD == x)
	{
		return y;
	}
	else if(REDUCING == x)
	{
		mem[n] = FORWARD;
		mem[n + 1] = hp;
		hp = hp + 2;
		return mem[n + 1];
	}
	else if(_I == x)
	{
		mem[n] = REDUCING;
		y = evac(y);

		if(mem[n] == FORWARD)
		{
			altmem[mem[n + 1]] = 'I';
			altmem[mem[n + 1] + 1] = y;
		}
		else
		{
			mem[n] = FORWARD;
			mem[n + 1] = y;
		}

		return mem[n + 1];
	}

	unsigned z = hp;
	hp = hp + 2;
	mem[n] = FORWARD;
	mem[n + 1] = z;
	altmem[z] = x;
	altmem[z + 1] = y;
	return z;
}

void gc()
{
	/* Reset the heap pointer */
	hp = 128;
	unsigned di = hp;
	/* Set the stack pointer to point to the top of altmem */
	sp = altmem + ((TOP - 1) * CELL_SIZE);

	unsigned i;

	sp[0] = evac(spTop[0]);

	unsigned x;
	while(di < hp)
	{
		altmem[di] = evac(altmem[di]);
		x = altmem[di];
		di = di + 1;

		if(x != _F && x != _NUM)
		{
			altmem[di] = evac(altmem[di]);
		}

		di = di + 1;
	}

	spTop = sp;
	/* Swap the addresses of mem and altmem */
	unsigned *tmp = mem;
	mem = altmem;
	altmem = tmp;
}

unsigned app(unsigned f, unsigned x)
{
	mem[hp] = f;
	mem[hp + 1] = x;
	hp = hp + 2;
	return hp - 2;
}

unsigned arg(unsigned n)
{
	return mem[sp [n] + 1];
}

int num(unsigned n)
{
	return mem[arg(n) + 1];
}

unsigned lazy2(unsigned height, unsigned f, unsigned x)
{
	unsigned* p;
	p = mem + (sp[height] * CELL_SIZE);
	p[0] = f;
	p[1] = x;
	sp = sp + ((height - 1) * CELL_SIZE);
	sp[0] = f;
	return 0;
}

unsigned lazy3(unsigned height, unsigned x1, unsigned x2, unsigned x3)
{
	unsigned* p;
	p = mem + (sp[height] * CELL_SIZE);
	p[0] = app(x1, x2);
	p[1] = x3;
	sp[height - 1] = p[0];
	sp = sp + ((height - 2) * CELL_SIZE;
	sp[0] = x1;
	return 0;
}

void lazyDub(unsigned n) { lazy3(4, _V, app(_NUM, n), app(_NUM, 0)); }
unsigned dub(unsigned lo, unsigned hi) { return num(lo); }
void putchar_cast(char);
void foreign(unsigned n) {
if (FALSE) {}
else if (n == 0) { putchar_cast(num(2));lazy2(4, app(arg(4), _K), arg(3)); }
}

int div(int a, int b) { return a/b; }
int mod(int a, int b) { return a%b; }
void run() {
  unsigned x;
  while(TRUE)
  {
    if (mem + (hp * CELL_SIZE) > sp - (8 * CELL_SIZE))
    {
      gc();
    }
    x = sp[0];
    if (isAddr(x))
    {
      sp = sp - CELL_SIZE;
      sp[0] = mem[x];
    }
  else if (x == _F) { foreign(arg(1)); }
  else if (x == _Y) { lazy2(1,arg(1),sp[1]); }
  else if (x == _Q) { lazy2(3,arg(3),app(arg(2),arg(1))); }
  else if (x == _QQ) { lazy2(5,arg(5),app(arg(4),app(arg(3),app(arg(2),arg(1))))); }
  else if (x == _S) { lazy3(3,arg(1),arg(3),app(arg(2),arg(3))); }
  else if (x == _B) { lazy2(3,arg(1),app(arg(2),arg(3))); }
  else if (x == _C) { lazy3(3,arg(1),arg(3),arg(2)); }
  else if (x == _R) { lazy3(3,arg(2),arg(3),arg(1)); }
  else if (x == _V) { lazy3(3,arg(3),arg(1),arg(2)); }
  else if (x == _T) { lazy2(2,arg(2),arg(1)); }
  else if (x == _K) { lazy2(2,_I,arg(1)); }
  else if (x == _I) { sp[1] = arg(1); sp = sp + CELL_SIZE; }
  else if (x == _CONS) { lazy3(4,arg(4),arg(1),arg(2)); }
  else if (x == _NUM) { lazy2(2,arg(2),sp[1]); }
  else if (x == _DADD) { lazyDub(dub(1,2) + dub(3,4)); }
  else if (x == _DSUB) { lazyDub(dub(1,2) - dub(3,4)); }
  else if (x == _DMUL) { lazyDub(dub(1,2) * dub(3,4)); }
  else if (x == _DDIV) { lazyDub(dub(1,2) / dub(3,4)); }
  else if (x == _DMOD) { lazyDub(dub(1,2) % dub(3,4)); }
  else if (x == _ADD) { lazy2(2,_NUM,num(1) + num(2)); }
  else if (x == _SUB) { lazy2(2,_NUM,num(1) - num(2)); }
  else if (x == _MUL) { lazy2(2,_NUM,num(1) * num(2)); }
  else if (x == _QUOT) { lazy2(2,_NUM,num(1) / num(2)); }
  else if (x == _REM) { lazy2(2,_NUM,num(1) % num(2)); }
  else if (x == _DIV) { lazy2(2,_NUM,div(num(1), num(2))); }
  else if (x == _MOD) { lazy2(2,_NUM,mod(num(1), num(2))); }
  else if (x == _EQ) { if (num(1) == num(2)) lazy2(2, _I, _K); else lazy2(2, _K, _I); }
  else if (x == _LE) { if (num(1) <= num(2)) lazy2(2, _I, _K); else lazy2(2, _K, _I); }
  else if (x == _U_DIV) { lazy2(2,_NUM,num(1) / num(2)); }
  else if (x == _U_MOD) { lazy2(2,_NUM,num(1) % num(2)); }
  else if (x == _U_LE) { if (num(1) <= num(2)) lazy2(2, _I, _K); else lazy2(2, _K, _I); }
  else if (x == _REF) { lazy2(2,arg(2),sp[1]); }
  else if (x == _READREF) { lazy3(3,arg(3),num(1),arg(2)); }
  else if (x == _WRITEREF) { mem[arg(2) + 1] = arg(1); lazy3(4,arg(4),_K,arg(3)); }
  else if (x == _END) { return; }

  }
}

void rts_init() {
  fp = stdin;
  buf = malloc(1024 * sizeof(char));
  bufp = buf;

  mem = malloc(TOP * sizeof(unsigned)); altmem = malloc(TOP * sizeof(unsigned));
  hp = 128;
  unsigned i;
  for (i = 0; i < prog_size; i = i + 1)
  {
    mem[hp] = prog[i];
    hp = hp + 1;
  }
  spTop = mem + ((TOP - 1) * CELL_SIZE);
}

void rts_reduce(unsigned n) {
  if (!ready)
  {
    ready = 1;
    rts_init();
  }
  sp = spTop;
  spTop[0] = app(app(n, _UNDEFINED), _END);
  run();
}
#define EXPORT(f, sym) void f() asm(sym) __attribute__((visibility("default")));
int main(int argc,char**argv){env_argc=argc;env_argv=argv;init_prog();rts_reduce(338);return 0;}