/* TEMPO Version 1.191, 03/11/98, Copyright (c) IRISA/INRIA-Universite de Rennes */

#include "prog.H"
typedef char *Universal;
extern "C" int set_specialization_context(Universal,Universal);
extern "C" Universal ML_list_separator;

extern "C" Universal _arg1;
extern "C" Universal _arg2;


extern "C" Universal _global_sstore_start;
extern "C" Universal _local_sstore_start;
extern "C" size_t _global_sstore_size;
extern "C" size_t _local_sstore_size;

extern "C" void EV_98();
extern "C" void EV_97();
extern "C" int EV_96();
extern "C" void EV_95();
extern "C" int EV_94();
extern "C" int EV_93();
extern "C" int EV_92();
extern "C" int EV_91();
extern "C" int EV_90();
extern "C" int EV_89();
extern "C" int EV_88();
extern "C" int EV_87();
extern "C" int EV_86();
extern "C" int EV_85();
extern "C" int EV_84();
extern "C" int EV_83();
extern "C" void EV_82();
extern "C" void EV_81();
extern "C" void EV_80();
extern "C" void EV_79();
extern "C" void EV_78();
extern "C" void EV_77();
extern "C" void EV_76();
extern "C" void EV_75();
extern "C" void EV_74();
extern "C" void EV_73();
extern "C" void EV_72();
extern "C" void EV_71();
extern "C" void EV_70();
extern "C" void EV_69();
extern "C" void EV_68();
extern "C" void EV_67();
extern "C" void EV_66();
extern "C" void EV_65();
extern "C" void EV_64();
extern "C" void EV_63();
extern "C" void EV_62();
extern "C" void EV_61();
extern "C" void EV_60();
extern "C" void EV_59();
extern "C" void EV_58();
extern "C" void EV_57();
extern "C" void EV_56();
extern "C" void EV_55();
extern "C" void EV_54();
extern "C" void EV_53();
extern "C" void EV_52();
extern "C" void EV_51();
extern "C" void EV_50();
extern "C" int EV_49();
extern "C" int EV_48();
extern "C" void EV_47();
extern "C" int EV_46();
extern "C" int EV_45();
extern "C" int EV_44();
extern "C" int EV_43();
extern "C" int EV_42();
extern "C" int EV_41();
extern "C" int EV_40();
extern "C" int EV_39();
extern "C" int EV_38();
extern "C" int EV_37();
extern "C" int EV_36();
extern "C" int EV_35();
extern "C" void EV_34();
extern "C" void EV_33();
extern "C" void EV_32();
extern "C" void EV_31();
extern "C" void EV_30();
extern "C" void EV_29();
extern "C" void EV_28();
extern "C" void EV_27();
extern "C" void EV_26();
extern "C" void EV_25();
extern "C" void EV_24();
extern "C" void EV_23();
extern "C" void EV_22();
extern "C" void EV_21();
extern "C" void EV_20();
extern "C" void EV_19();
extern "C" void EV_18();
extern "C" void EV_17();
extern "C" void EV_16();
extern "C" void EV_15();
extern "C" void EV_14();
extern "C" void EV_13();
extern "C" void EV_12();
extern "C" void EV_11();
extern "C" void EV_10();
extern "C" void EV_9();
extern "C" void EV_8();
extern "C" void EV_7();
extern "C" void EV_6();
extern "C" void EV_5();
extern "C" void EV_4();
extern "C" void EV_3();
extern "C" void EV_2();
extern "C" int EV_1();

ML_ctx global_ctx = "(* TEMPO Version 1.191, 03/11/98, Copyright (c) IRISA/INRIA-Universite de Rennes *)
ABSYN(ENTRY_POINT_SPEC(ROOT(G(\"interpret\")),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[]))),0,[STRUCT_DECL(ROOT(G(\"inst\")),[TYPE_DECL_PARAM(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"opcode\"))), TYPE_DECL_PARAM(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"val\")))])],[VAR_DECL(EXTERN,tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), VAR_DECL(EXTERN,tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\")))],[FUNC_DECL(EXTERN,tFUNC(tINT(NON_CST,NON_VOL,SIGNED,STD),[]),ROOT(E(\"printf\"))), FUNC_DECL(EXTERN,tFUNC(tINT(NON_CST,NON_VOL,SIGNED,STD),[]),ROOT(E(\"exit\")))],[],[%s])";

stmt_ac *extension() {
   extern void init_store(Universal, size_t, Universal, size_t);
   extern void init_prog(cons<fun_ac> *prog_cTree);
   set_specialization_context(_arg1,_arg2);
   init_store(_global_sstore_start, _global_sstore_size, _local_sstore_start, _local_sstore_size);
init_prog(new cons<fun_ac>(
fun_ac("_Ginterpret_1",Block_reb(cons<stmt_ac *>(
   If_red(Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(PLUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Exp_reb(Assign_reb(Exp_id("SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D))"),Exp_ev(Int_spec(SIGNED,STD),(funptr)&EV_1,"CONSTANT(INT(\"%s\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))"),"ASSIGN(%s,tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))"),"EXP(%s,A(U))")
*= Stmt_ev((funptr)&EV_2,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_3)
+= param((funptr)&EV_4)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_5,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_6)
+= param((funptr)&EV_7)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),BINARY(PLUS,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_8,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_9)
+= param((funptr)&EV_10)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),BINARY(MINUS,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_11,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_12)
+= param((funptr)&EV_13)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),BINARY(MULT,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_14,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_15)
+= param((funptr)&EV_16)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"mem\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_17,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_18)
+= param((funptr)&EV_19)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"mem\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"2\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_20,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_21)
+= param((funptr)&EV_22)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_ev((funptr)&EV_23,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_24)
+= param((funptr)&EV_25)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   new If_reb(Exp_id("BINARY(NEQ,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),CONSTANT(INT(\"0\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"),Block_reb(cons<stmt_ac *>(
   Stmt_ev((funptr)&EV_26,"EMPTY(A(U))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_27)
+= param((funptr)&EV_28)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   Stmt_ev((funptr)&EV_29,"EMPTY(A(U))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_30)
+= param((funptr)&EV_31)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),"IF(%s, %s, %s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),BINARY(EQ,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_32,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_33)
+= param((funptr)&EV_34)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   Exp_reb(Ecall_reb(cons<exp_ac *>(
   Exp_id("CONSTANT(STRING(\"\\\\n Unrecognized instruction -> %%d at %%d\\\\n\"),tARRAY(\"43\",tCHAR(NON_CST,NON_VOL,SIGNED)),A(D))")
*= Exp_ev(Int_spec(SIGNED,STD),(funptr)&EV_35,"CONSTANT(INT(\"%s\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))")
*= Exp_ev(Int_spec(SIGNED,STD),(funptr)&EV_36,"CONSTANT(INT(\"%s\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))")
),"ECALL(RESIDUALIZED,ROOT(E(\"printf\")),CALL_SIG([],[],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([],[]),ETA_RETURN_SIG(U,[],[])),[%s],tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))"),"EXP(%s,A(U))")
*= Stmt_id("EXP(ECALL(RESIDUALIZED,ROOT(E(\"exit\")),CALL_SIG([],[],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([],[]),ETA_RETURN_SIG(U,[],[])),[],tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_37,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_38,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_39,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_40,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_41,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_42,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_43,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_44,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_45,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_46,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),Stmt_ev((funptr)&EV_47,"EMPTY(A(U))"),(funptr)&EV_48,"BLOCK([],[%s],A(U))")
*= Stmt_id("RETURN_VOID(A(D))")
),"BLOCK([],[%s],A(U))"),"FUNC_DEF(EXTERN,tVOID(NON_CST,NON_VOL),G(\"%s\"),INTERNAL(UNINIT),[FUNC_DEF_PARAM(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[(FUNC_SIG(CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),RETURN_SIG([VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\")))],ALIAS_RETURN_SIG([],STORE([])),BTA_RETURN_SIG(F([D],U,D),[D, D]),ETA_CALL_SIG([S, S, D],F([D],U,D),[VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\")))],[MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\")))]))), %s)])")
+=
fun_ac("_Ginterpret_2",Block_reb(cons<stmt_ac *>(
   If_red(Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(PLUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Exp_reb(Assign_reb(Exp_id("SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D))"),Exp_ev(Int_spec(SIGNED,STD),(funptr)&EV_49,"CONSTANT(INT(\"%s\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))"),"ASSIGN(%s,tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))"),"EXP(%s,A(U))")
*= Stmt_ev((funptr)&EV_50,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_51)
+= param((funptr)&EV_52)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_53,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_54)
+= param((funptr)&EV_55)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),BINARY(PLUS,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_56,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_57)
+= param((funptr)&EV_58)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),BINARY(MINUS,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_59,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_60)
+= param((funptr)&EV_61)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),BINARY(MULT,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_62,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_63)
+= param((funptr)&EV_64)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"mem\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_65,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_66)
+= param((funptr)&EV_67)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"mem\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"2\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_68,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_69)
+= param((funptr)&EV_70)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_ev((funptr)&EV_71,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_72)
+= param((funptr)&EV_73)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   new If_reb(Exp_id("BINARY(NEQ,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),CONSTANT(INT(\"0\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"),Block_reb(cons<stmt_ac *>(
   Stmt_ev((funptr)&EV_74,"EMPTY(A(U))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_75)
+= param((funptr)&EV_76)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   Stmt_ev((funptr)&EV_77,"EMPTY(A(U))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_78)
+= param((funptr)&EV_79)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),"IF(%s, %s, %s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   new If_red(Block_reb(cons<stmt_ac *>(
   Stmt_id("EXP(ASSIGN(SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),BINARY(EQ,SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),SUBSCRIPT(VAR(ROOT(E(\"stack\")),tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),[],A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_id("EXP(ASSIGN(VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),BINARY(MINUS,VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),CONSTANT(INT(\"1\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(S)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
*= Stmt_ev((funptr)&EV_80,"EMPTY(A(U))")
*= Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_81)
+= param((funptr)&EV_82)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"),"EXP(%s,A(U))")
),"BLOCK([],[%s],A(U))"),Block_reb(cons<stmt_ac *>(
   Exp_reb(Ecall_reb(cons<exp_ac *>(
   Exp_id("CONSTANT(STRING(\"\\\\n Unrecognized instruction -> %%d at %%d\\\\n\"),tARRAY(\"43\",tCHAR(NON_CST,NON_VOL,SIGNED)),A(D))")
*= Exp_ev(Int_spec(SIGNED,STD),(funptr)&EV_83,"CONSTANT(INT(\"%s\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))")
*= Exp_ev(Int_spec(SIGNED,STD),(funptr)&EV_84,"CONSTANT(INT(\"%s\"),tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))")
),"ECALL(RESIDUALIZED,ROOT(E(\"printf\")),CALL_SIG([],[],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([],[]),ETA_RETURN_SIG(U,[],[])),[%s],tINT(NON_CST,NON_VOL,SIGNED,STD),A(U))"),"EXP(%s,A(U))")
*= Stmt_id("EXP(ECALL(RESIDUALIZED,ROOT(E(\"exit\")),CALL_SIG([],[],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([],[]),ETA_RETURN_SIG(U,[],[])),[],tINT(NON_CST,NON_VOL,SIGNED,STD),A(D)),A(D))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_85,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_86,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_87,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_88,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_89,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_90,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_91,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_92,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_93,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),(funptr)&EV_94,"BLOCK([],[%s],A(U))")
),"BLOCK([],[%s],A(U))"),Stmt_ev((funptr)&EV_95,"EMPTY(A(U))"),(funptr)&EV_96,"BLOCK([],[%s],A(U))")
*= Stmt_id("RETURN_VOID(A(D))")
),"BLOCK([],[%s],A(U))"),"FUNC_DEF(STATIC,tVOID(NON_CST,NON_VOL),G(\"%s\"),INTERNAL(UNINIT),[FUNC_DEF_PARAM(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[(FUNC_SIG(CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(D,[],[])),RETURN_SIG([VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\")))],ALIAS_RETURN_SIG([],STORE([])),BTA_RETURN_SIG(F([D],U,D),[D, D]),ETA_CALL_SIG([S, S, D],F([D],U,D),[VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\")))],[MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\")))]))), %s)])")));

return new Exp_reb(Call_reb("_Ginterpret_1",cons<param>(
   param((funptr)&EV_97)
+= param((funptr)&EV_98)
+= param(Exp_id("VAR(ROOT(L(G(\"interpret\"),0, \"sp\")),tINT(NON_CST,NON_VOL,SIGNED,STD),A(D))"))
),0,"CALL(0,G(\"%s\"),CALL_SIG([VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(L(G(\"interpret\"),0, \"sp\")))],[VAR(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(E(\"prg_size\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"mem\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"val\"))), VAR(tARRAY(\"\",tINT(NON_CST,NON_VOL,SIGNED,STD)),ROOT(E(\"stack\"))), MEMBER(tINT(NON_CST,NON_VOL,SIGNED,STD),ROOT(G(\"inst\")),ROOT(G(\"opcode\")))],ALIAS_CALL_SIG(STORE([])),BTA_CALL_SIG([D],[S, D, S, D, S]),ETA_RETURN_SIG(U,[],[])),[%s],tVOID(NON_CST,NON_VOL),A(U))"), "");
}