diff --git a/JIT/HPP/EnvironmentInit.h b/JIT/HPP/EnvironmentInit.h new file mode 100644 index 000000000..ac4acb008 --- /dev/null +++ b/JIT/HPP/EnvironmentInit.h @@ -0,0 +1,223 @@ +#if YAP_STAT_PREDS +#include +#endif + +extern Environment ExpEnv; + +#if YAP_JIT +Int STD_PROTO(Get_N_Cores,(void)); +X_API Int STD_PROTO(Init_Analysis_Struc,(void)); +X_API Int STD_PROTO(Init_Transform_Struc,(void)); +X_API Int STD_PROTO(Init_Codegen_Struc,(void)); +X_API Int STD_PROTO(Init_Config_Struc,(void)); +#if YAP_STAT_PREDS +X_API Int STD_PROTO(Init_Stats_Struc, (void)); +#endif +#endif /* YAP_JIT */ +#if YAP_DBG_PREDS +X_API Int STD_PROTO(Init_Debug_Struc,(void)); +#endif +X_API Int STD_PROTO(YAP_Init_ExpEnv,(void)); + +#if YAP_JIT +Int +Get_N_Cores() { +#ifdef WIN32 + SYSTEM_INFO sysinfo; + GetSystemInfo(&sysinfo); + return sysinfo.dwNumberOfProcessors; +#elif MACOS + int nm[2]; + size_t len = 4; + uint32_t count; + + nm[0] = CTL_HW; nm[1] = HRW_AVAILCPU; + sysctl(nm, 2, &count, &len, NULL, 0); + + if(count < 1) { + nm[1] = HRW_NCPU; + sysctl(nm, 2, &count, &len, NULL, 0); + if(count < 1) { count = 1; } + } + return count; +#else + return sysconf(_SC_NPROCESSORS_ONLN); +#endif +} + +X_API Int +Init_Analysis_Struc() +{ + ExpEnv.analysis_struc.stats_enabled = 0; + ExpEnv.analysis_struc.time_pass_enabled = 0; + ExpEnv.analysis_struc.pointtoverifymodule = NOPOINT; + ExpEnv.analysis_struc.n = 0; + ExpEnv.analysis_struc.act_an = NULL; + ExpEnv.analysis_struc.outfile = (CELL)malloc(7*sizeof(char)); + strcpy(((char*)ExpEnv.analysis_struc.outfile), "STDERR"); + return TRUE; +} + +X_API Int +Init_Transform_Struc() +{ + ExpEnv.transform_struc.optlevel = 3; + ExpEnv.transform_struc.n = 0; + ExpEnv.transform_struc.act_tr = NULL; + ExpEnv.transform_struc.opt_args.arg_promotion_max_elements = 3; + ExpEnv.transform_struc.opt_args.strip_symbols_pass_type = 0; + ExpEnv.transform_struc.opt_args.scalar_replace_aggregates_threshold = -1; + ExpEnv.transform_struc.opt_args.loop_unswitch_optimize_for_size = 0; + ExpEnv.transform_struc.opt_args.loop_unroll_threshold = -1; + ExpEnv.transform_struc.opt_args.inline_threshold = 225; + ExpEnv.transform_struc.unit_at_time_enabled = 1; + ExpEnv.transform_struc.simplify_libcalls_enabled = 1; + ExpEnv.transform_struc.link_time_opt.enabled = 0; + ExpEnv.transform_struc.link_time_opt.internalize = 0; + ExpEnv.transform_struc.link_time_opt.runinliner = 0; + return TRUE; +} + +X_API Int +Init_Codegen_Struc() +{ + ExpEnv.codegen_struc.struc_targetopt.noframepointerelim = 0; + ExpEnv.codegen_struc.struc_targetopt.lessprecisefpmadoption = 0; + ExpEnv.codegen_struc.struc_targetopt.noexcessfpprecision = 0; + ExpEnv.codegen_struc.struc_targetopt.unsafefpmath = 0; + ExpEnv.codegen_struc.struc_targetopt.honorsigndependentroundingfpmathoption = 0; + ExpEnv.codegen_struc.struc_targetopt.usesoftfloat = 0; + ExpEnv.codegen_struc.struc_targetopt.jitexceptionhandling = 0; + ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfo = 0; + ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfotodisk = 0; + ExpEnv.codegen_struc.struc_targetopt.guaranteedtailcallopt = 0; + ExpEnv.codegen_struc.struc_targetopt.disabletailcalls = 0; + ExpEnv.codegen_struc.struc_targetopt.fastisel = 0; + ExpEnv.codegen_struc.struc_targetopt.floatabitype = 0; + + ExpEnv.codegen_struc.struc_enginebuilder.engineoptlevel = 3; + ExpEnv.codegen_struc.struc_enginebuilder.relocmodel = 0; + ExpEnv.codegen_struc.struc_enginebuilder.codemodel = 1; + ExpEnv.codegen_struc.struc_enginebuilder.usemcjit = 0; + ExpEnv.codegen_struc.struc_enginebuilder.regallocator = REG_ALLOC_GREEDY; + return TRUE; +} + +X_API Int +Init_Config_Struc() +{ + if (Yap_ExecutionMode == MIXED_MODE) { + ExpEnv.config_struc.execution_mode = SMART_JIT; + ExpEnv.config_struc.frequency_type = COUNTER; + ExpEnv.config_struc.frequency_bound = 1024.0; + ExpEnv.config_struc.profiling_startp = 0.72; + ExpEnv.config_struc.mainclause_ty = HROT_AND_CALLEE; + ExpEnv.config_struc.torecompile = 1; + } + else { + if (Yap_ExecutionMode == COMPILED) + ExpEnv.config_struc.execution_mode = JUST_COMPILED; + else + ExpEnv.config_struc.execution_mode = JUST_INTERPRETED; + ExpEnv.config_struc.frequency_type = NO_FREQ; + ExpEnv.config_struc.frequency_bound = 0.0; + ExpEnv.config_struc.profiling_startp = 0.0; + ExpEnv.config_struc.mainclause_ty = UNUSED; + ExpEnv.config_struc.torecompile = 0; + } + ExpEnv.config_struc.ncores = Get_N_Cores(); + ExpEnv.config_struc.useonlypi = 0; + ExpEnv.config_struc.compilation_threads = 0; + ExpEnv.config_struc.threaded_compiler_threads = NULL; + ExpEnv.config_struc.posthreads = NULL; + return TRUE; +} + +#if YAP_STAT_PREDS +X_API Int +Init_Stats_Struc() +{ + ExpEnv.stats_struc.papi_initialized = 0; + ExpEnv.stats_struc.papi_eventset = PAPI_NULL; + return TRUE; +} +#endif + +#endif /* YAP_JIT */ + +#if YAP_DBG_PREDS +X_API Int +Init_Debug_Struc() +{ + #define OPCODE(OP,TYPE) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)NO_PLACE; \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = 0; \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = 0; + #include "YapAppliedOpcodes.h" + #undef OPCODE + + #define BBLOCK(BB) \ + ExpEnv.debug_struc.pbbs_##BB.print = (Int)NO_PLACE; \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = 0; \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = 0; + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + + ExpEnv.debug_struc.pmainclause_on_head.print = (Int)NO_PLACE; + ExpEnv.debug_struc.pmainclause_on_head.msg_before = 0; + ExpEnv.debug_struc.pmainclause_on_head.msg_after = 0; + + ExpEnv.debug_struc.pprint_intermediate.print_to_std = 0; + ExpEnv.debug_struc.pprint_intermediate.print_to_file = 0; + ExpEnv.debug_struc.pprint_intermediate.std_name = 0; + ExpEnv.debug_struc.pprint_intermediate.file_name = 0; + + ExpEnv.debug_struc.pprint_llva.print_llva_before = 0; + ExpEnv.debug_struc.pprint_llva.print_llva_after = 0; + + ExpEnv.debug_struc.pprint_me.interpreted_backtrack = 0; + ExpEnv.debug_struc.pprint_me.profiled_interpreted_backtrack = 0; + ExpEnv.debug_struc.pprint_me.native_backtrack = 0; + ExpEnv.debug_struc.pprint_me.interpreted_treat_heap = 0; + ExpEnv.debug_struc.pprint_me.native_treat_heap = 0; + ExpEnv.debug_struc.pprint_me.interpreted_treat_trail = 0; + ExpEnv.debug_struc.pprint_me.native_treat_trail = 0; + ExpEnv.debug_struc.pprint_me.criticals = 0; + ExpEnv.debug_struc.pprint_me.at_compilation = 0; + ExpEnv.debug_struc.pprint_me.at_recompilation = 0; + ExpEnv.debug_struc.pprint_me.nativerun_init = 0; + ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success = 0; + ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail = 0; + + ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 0; + ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 0; + ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; + ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; + + ExpEnv.debug_struc.act_predicate_actions.exit_on_warning = 0; + ExpEnv.debug_struc.act_predicate_actions.disable_on_warning = 1; + ExpEnv.debug_struc.act_predicate_actions.exit_on_error = 1; + + return TRUE; +} +#endif + +X_API Int +YAP_Init_ExpEnv() +{ + //ExpEnv.in = (char*)malloc(1024*sizeof(char)); + //strcpy(ExpEnv.in, fin); +#if YAP_JIT + Init_Analysis_Struc(); + Init_Transform_Struc(); + Init_Codegen_Struc(); + Init_Config_Struc(); +#if YAP_STAT_PREDS + Init_Stats_Struc(); +#endif +#endif /* YAP_JIT */ +#if YAP_DBG_PREDS + Init_Debug_Struc(); +#endif + return TRUE; +} diff --git a/JIT/HPP/IsGround.h b/JIT/HPP/IsGround.h new file mode 100644 index 000000000..a35001958 --- /dev/null +++ b/JIT/HPP/IsGround.h @@ -0,0 +1,2421 @@ +COUNT IsGround(yamop*); + +COUNT +IsGround(yamop* _p) { + op_numbers op; + COUNT c = 0; + COUNT n = 0; + while( (op = Yap_op_from_opcode(_p->opc)) ){ + n += 1; + switch(op){ + case _Ystop : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _Nstop : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _try_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _enter_profiling : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _retry_profiled : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _profiled_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _profiled_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _profiled_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _profiled_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _count_call : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _count_retry : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _count_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _count_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _count_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _count_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _lock_lu : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _unlock_lu : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _alloc_for_logical_pred : + _p = ((yamop *)(&((_p)->u.L.next))); + break; + case _copy_idb_term : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _unify_idb_term : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _ensure_space : + _p = ((yamop *)(&((_p)->u.Osbpa.next))); + break; + case _spy_or_trymark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _try_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _count_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _profiled_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _trust_fail : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _op_fail : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _cut : + _p = ((yamop *)(&((_p)->u.s.next))); + c = 1; + break; + case _cut_t : + _p = ((yamop *)(&((_p)->u.s.next))); + c = 1; + break; + case _cut_e : + _p = ((yamop *)(&((_p)->u.s.next))); + c = 1; + break; + case _save_b_x : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _save_b_y : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _commit_b_x : + _p = ((yamop *)(&((_p)->u.xps.next))); + break; + case _commit_b_y : + _p = ((yamop *)(&((_p)->u.yps.next))); + break; + case _execute : + _p = ((yamop *)(&((_p)->u.pp.next))); + l = (CELL)_p; + if (n > 5) return 0; + break; + case _dexecute : + _p = ((yamop *)(&((_p)->u.pp.next))); + l = (CELL)_p; + if (n > 5) return 0; + break; + case _fcall : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + if (c || n <= 3) { c = 0; break; } + return 0; + case _call : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + if (c || n <= 3) { c = 0; break; } + return 0; + case _procceed : + _p = ((yamop *)(&((_p)->u.p.next))); + l = (CELL)_p; + break; + case _allocate : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _deallocate : + _p = ((yamop *)(&((_p)->u.p.next))); + break; +#ifdef BEAM + case _retry_eam : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif +#ifdef BEAM + case _run_eam : + _p = ((yamop *)(&((_p)->u.os.next))); + break; +#endif + case _get_x_var : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _get_y_var : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _get_yy_var : + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + case _get_x_val : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _get_y_val : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _get_atom : + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + case _get_2atoms : + _p = ((yamop *)(&((_p)->u.cc.next))); + break; + case _get_3atoms : + _p = ((yamop *)(&((_p)->u.ccc.next))); + break; + case _get_4atoms : + _p = ((yamop *)(&((_p)->u.cccc.next))); + break; + case _get_5atoms : + _p = ((yamop *)(&((_p)->u.ccccc.next))); + break; + case _get_6atoms : + _p = ((yamop *)(&((_p)->u.cccccc.next))); + break; + case _get_list : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _get_struct : + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + case _get_float : + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + case _get_longint : + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + case _get_bigint : + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + case _get_dbterm : + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + case _glist_valx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _glist_valy : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _gl_void_varx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _gl_void_vary : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _gl_void_valx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _gl_void_valy : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _unify_x_var : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_x_var_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_var : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_var_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_x_var2 : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _unify_x_var2_write : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _unify_l_x_var2 : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _unify_l_x_var2_write : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _unify_y_var : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_y_var_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_var : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_var_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_x_val : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_x_val_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_val : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_val_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_y_val : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_y_val_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_val : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_val_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_x_loc : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_x_loc_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_loc : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_loc_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_y_loc : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_y_loc_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_loc : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_loc_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_void : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_void_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_l_void : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_l_void_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_n_voids : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _unify_n_voids_write : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _unify_l_n_voids : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _unify_l_n_voids_write : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _unify_atom : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _unify_atom_write : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _unify_l_atom : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _unify_l_atom_write : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _unify_n_atoms : + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + case _unify_n_atoms_write : + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + case _unify_float : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _unify_float_write : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _unify_l_float : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _unify_l_float_write : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _unify_longint : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _unify_longint_write : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _unify_l_longint : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _unify_l_longint_write : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _unify_bigint : + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + case _unify_l_bigint : + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + case _unify_dbterm : + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + case _unify_l_dbterm : + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + case _unify_list : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_list_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_l_list : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_l_list_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_struct : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _unify_struct_write : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _unify_l_struc : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _unify_l_struc_write : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _put_x_var : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _put_y_var : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _put_x_val : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _put_xx_val : + _p = ((yamop *)(&((_p)->u.xxxx.next))); + break; + case _put_y_val : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _put_y_vals : + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + case _put_unsafe : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _put_atom : + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + case _put_dbterm : + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + case _put_bigint : + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + case _put_float : + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + case _put_longint : + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + case _put_list : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _put_struct : + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + case _write_x_var : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _write_void : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _write_n_voids : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _write_y_var : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _write_x_val : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _write_x_loc : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _write_y_val : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _write_y_loc : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _write_atom : + _p = ((yamop *)(&((_p)->u.c.next))); + break; + case _write_bigint : + _p = ((yamop *)(&((_p)->u.N.next))); + break; + case _write_dbterm : + _p = ((yamop *)(&((_p)->u.D.next))); + break; + case _write_float : + _p = ((yamop *)(&((_p)->u.d.next))); + break; + case _write_longint : + _p = ((yamop *)(&((_p)->u.i.next))); + break; + case _write_n_atoms : + _p = ((yamop *)(&((_p)->u.sc.next))); + break; + case _write_list : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _write_l_list : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _write_struct : + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + case _write_l_struc : + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + case _save_pair_x : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _save_pair_x_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _save_pair_y : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _save_pair_y_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _save_appl_x : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _save_appl_x_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _save_appl_y : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _save_appl_y_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _jump : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _move_back : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _skip : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _either : + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + case _or_else : + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + case _pop_n : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _pop : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _call_cpred : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _execute_cpred : + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + case _call_usercpred : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _call_c_wfail : + _p = ((yamop *)(&((_p)->u.slp.next))); + break; + case _try_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + case _retry_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _cut_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + c = 1; + break; +#endif + case _try_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + case _retry_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _cut_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + c = 1; + break; +#endif + case _lock_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _index_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#ifdef THREADS + case _thread_local : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif + case _expand_index : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _expand_clauses : + _p = ((yamop *)(&((_p)->u.sssllp.next))); + break; + case _undef_p : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _spy_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _try_clause : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _try_clause2 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _try_clause3 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _try_clause4 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _retry : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _retry2 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _retry3 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _retry4 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _trust : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _try_in : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _enter_lu_pred : + _p = ((yamop *)(&((_p)->u.Illss.next))); + break; + case _try_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _user_switch : + _p = ((yamop *)(&((_p)->u.lp.next))); + break; + case _switch_on_type : + _p = ((yamop *)(&((_p)->u.llll.next))); + break; + case _switch_list_nl : + _p = ((yamop *)(&((_p)->u.ollll.next))); + break; + case _switch_on_arg_type : + _p = ((yamop *)(&((_p)->u.xllll.next))); + break; + case _switch_on_sub_arg_type : + _p = ((yamop *)(&((_p)->u.sllll.next))); + break; + case _jump_if_var : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _jump_if_nonvar : + _p = ((yamop *)(&((_p)->u.xll.next))); + break; + case _if_not_then : + _p = ((yamop *)(&((_p)->u.clll.next))); + break; + case _switch_on_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _switch_on_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _go_on_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _go_on_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _if_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _if_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _index_dbref : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _index_blob : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _index_long : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _jit_handler : + _p = ((yamop *)(&((_p)->u.jhc.next))); + break; + case _p_atom_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_atom_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_atomic_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_atomic_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_integer_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_integer_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_nonvar_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_nonvar_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_number_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_number_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_var_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_var_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_db_ref_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_db_ref_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_primitive_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_primitive_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_compound_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_compound_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_float_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_float_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_plus_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_plus_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_plus_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_plus_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_minus_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_minus_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_minus_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_minus_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_times_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_times_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_times_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_times_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_div_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_div_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_div_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_div_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_div_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_div_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_and_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_and_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_and_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_and_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_or_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_or_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_or_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_or_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_sll_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_sll_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_sll_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_sll_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_sll_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_sll_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_slr_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_slr_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_slr_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_slr_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_slr_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_slr_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _call_bfunc_xx : + _p = ((yamop *)(&((_p)->u.plxxs.next))); + break; + case _call_bfunc_yx : + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + case _call_bfunc_xy : + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + case _call_bfunc_yy : + _p = ((yamop *)(&((_p)->u.plyys.next))); + break; + case _p_equal : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _p_dif : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _p_eq : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _p_arg_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_arg_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_arg_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_arg_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_func2s_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_func2s_cv : + _p = ((yamop *)(&((_p)->u.xxc.next))); + break; + case _p_func2s_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_func2s_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_func2s_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_func2s_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_func2f_xx : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_func2f_xy : + _p = ((yamop *)(&((_p)->u.xxy.next))); + break; + case _p_func2f_yx : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_func2f_yy : + _p = ((yamop *)(&((_p)->u.yyx.next))); + break; + case _p_functor : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _p_execute2 : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _p_execute : + _p = ((yamop *)(&((_p)->u.Osbmp.next))); + break; + case _p_execute_tail : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; +#ifdef YAPOR + case _getwork_first_time : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _getwork : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _getwork_seq : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _sync : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _clause_with_cut : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif + case _table_load_answer : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_try_answer : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_try_single : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_try_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_try : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_retry : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_trust : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_new_answer : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _table_answer_resolution : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_completion : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#ifdef THREADS_CONSUMER_SHARING + case _table_answer_resolution_completion: + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#endif + case _trie_do_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif +#ifdef YAPOR + case _or_last : + _p = ((yamop *)(&((_p)->u.sblp.next))); + break; +#else + case _or_last : + _p = ((yamop *)(&((_p)->u.p.next))); + break; +#endif + case _traced_Ystop : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_Nstop : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_try_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_enter_profiling : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_retry_profiled : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_profiled_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_profiled_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_profiled_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _traced_profiled_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _traced_count_call : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_count_retry : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_count_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_count_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_count_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _traced_count_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _traced_lock_lu : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_unlock_lu : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_alloc_for_logical_pred : + _p = ((yamop *)(&((_p)->u.L.next))); + break; + case _traced_copy_idb_term : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_unify_idb_term : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_ensure_space : + _p = ((yamop *)(&((_p)->u.Osbpa.next))); + break; + case _traced_spy_or_trymark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_try_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_count_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_profiled_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_trust_fail : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_op_fail : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_cut : + _p = ((yamop *)(&((_p)->u.s.next))); + c = 1; + break; + case _traced_cut_t : + _p = ((yamop *)(&((_p)->u.s.next))); + c = 1; + break; + case _traced_cut_e : + _p = ((yamop *)(&((_p)->u.s.next))); + c = 1; + break; + case _traced_save_b_x : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_save_b_y : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _traced_commit_b_x : + _p = ((yamop *)(&((_p)->u.xps.next))); + break; + case _traced_commit_b_y : + _p = ((yamop *)(&((_p)->u.yps.next))); + break; + case _traced_execute : + _p = ((yamop *)(&((_p)->u.pp.next))); + l = (CELL)_p; + if (n > 5) return 0; + break; + case _traced_dexecute : + _p = ((yamop *)(&((_p)->u.pp.next))); + l = (CELL)_p; + if (n > 5) return 0; + break; + case _traced_fcall : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + if (c || n <= 3) { c = 0; break; } + return 0; + case _traced_call : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + if (c || n <= 3) { c = 0; break; } + return 0; + case _traced_procceed : + _p = ((yamop *)(&((_p)->u.p.next))); + l = (CELL)_p; + break; + case _traced_allocate : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_deallocate : + _p = ((yamop *)(&((_p)->u.p.next))); + break; +#ifdef BEAM + case _traced_retry_eam : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif +#ifdef BEAM + case _traced_run_eam : + _p = ((yamop *)(&((_p)->u.os.next))); + break; +#endif + case _traced_get_x_var : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_get_y_var : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_get_yy_var : + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + case _traced_get_x_val : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_get_y_val : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_get_atom : + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + case _traced_get_2atoms : + _p = ((yamop *)(&((_p)->u.cc.next))); + break; + case _traced_get_3atoms : + _p = ((yamop *)(&((_p)->u.ccc.next))); + break; + case _traced_get_4atoms : + _p = ((yamop *)(&((_p)->u.cccc.next))); + break; + case _traced_get_5atoms : + _p = ((yamop *)(&((_p)->u.ccccc.next))); + break; + case _traced_get_6atoms : + _p = ((yamop *)(&((_p)->u.cccccc.next))); + break; + case _traced_get_list : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_get_struct : + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + case _traced_get_float : + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + case _traced_get_longint : + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + case _traced_get_bigint : + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + case _traced_get_dbterm : + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + case _traced_glist_valx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_glist_valy : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_gl_void_varx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_gl_void_vary : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_gl_void_valx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_gl_void_valy : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_unify_x_var : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_x_var_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_var : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_var_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_x_var2 : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _traced_unify_x_var2_write : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _traced_unify_l_x_var2 : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _traced_unify_l_x_var2_write : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _traced_unify_y_var : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_y_var_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_var : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_var_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_x_val : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_x_val_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_val : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_val_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_y_val : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_y_val_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_val : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_val_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_x_loc : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_x_loc_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_loc : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_loc_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_y_loc : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_y_loc_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_loc : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_loc_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_void : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_void_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_l_void : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_l_void_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_n_voids : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _traced_unify_n_voids_write : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _traced_unify_l_n_voids : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _traced_unify_l_n_voids_write : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _traced_unify_atom : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _traced_unify_atom_write : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _traced_unify_l_atom : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _traced_unify_l_atom_write : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _traced_unify_n_atoms : + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + case _traced_unify_n_atoms_write : + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + case _traced_unify_float : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _traced_unify_float_write : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _traced_unify_l_float : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _traced_unify_l_float_write : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _traced_unify_longint : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _traced_unify_longint_write : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _traced_unify_l_longint : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _traced_unify_l_longint_write : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _traced_unify_bigint : + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + case _traced_unify_l_bigint : + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + case _traced_unify_dbterm : + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + case _traced_unify_l_dbterm : + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + case _traced_unify_list : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_list_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_l_list : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_l_list_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_struct : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _traced_unify_struct_write : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _traced_unify_l_struc : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _traced_unify_l_struc_write : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _traced_put_x_var : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_put_y_var : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_put_x_val : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_put_xx_val : + _p = ((yamop *)(&((_p)->u.xxxx.next))); + break; + case _traced_put_y_val : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_put_y_vals : + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + case _traced_put_unsafe : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_put_atom : + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + case _traced_put_dbterm : + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + case _traced_put_bigint : + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + case _traced_put_float : + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + case _traced_put_longint : + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + case _traced_put_list : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_put_struct : + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + case _traced_write_x_var : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_write_void : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_write_n_voids : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _traced_write_y_var : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _traced_write_x_val : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_write_x_loc : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_write_y_val : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _traced_write_y_loc : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _traced_write_atom : + _p = ((yamop *)(&((_p)->u.c.next))); + break; + case _traced_write_bigint : + _p = ((yamop *)(&((_p)->u.N.next))); + break; + case _traced_write_dbterm : + _p = ((yamop *)(&((_p)->u.D.next))); + break; + case _traced_write_float : + _p = ((yamop *)(&((_p)->u.d.next))); + break; + case _traced_write_longint : + _p = ((yamop *)(&((_p)->u.i.next))); + break; + case _traced_write_n_atoms : + _p = ((yamop *)(&((_p)->u.sc.next))); + break; + case _traced_write_list : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_write_l_list : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_write_struct : + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + case _traced_write_l_struc : + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + case _traced_save_pair_x : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_save_pair_x_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_save_pair_y : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_save_pair_y_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_save_appl_x : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_save_appl_x_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_save_appl_y : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_save_appl_y_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_jump : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_move_back : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_skip : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_either : + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + case _traced_or_else : + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + case _traced_pop_n : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _traced_pop : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_call_cpred : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _traced_execute_cpred : + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + case _traced_call_usercpred : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _traced_call_c_wfail : + _p = ((yamop *)(&((_p)->u.slp.next))); + break; + case _traced_try_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + case _traced_retry_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _traced_cut_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + c = 1; + break; +#endif + case _traced_try_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + case _traced_retry_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _traced_cut_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + c = 1; + break; +#endif + case _traced_lock_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_index_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#ifdef THREADS + case _traced_thread_local : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif + case _traced_expand_index : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_expand_clauses : + _p = ((yamop *)(&((_p)->u.sssllp.next))); + break; + case _traced_undef_p : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_spy_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_try_clause : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_try_clause2 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_try_clause3 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_try_clause4 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_retry : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_retry2 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_retry3 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_retry4 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_trust : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_try_in : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_enter_lu_pred : + _p = ((yamop *)(&((_p)->u.Illss.next))); + break; + case _traced_try_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _traced_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _traced_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _traced_user_switch : + _p = ((yamop *)(&((_p)->u.lp.next))); + break; + case _traced_switch_on_type : + _p = ((yamop *)(&((_p)->u.llll.next))); + break; + case _traced_switch_list_nl : + _p = ((yamop *)(&((_p)->u.ollll.next))); + break; + case _traced_switch_on_arg_type : + _p = ((yamop *)(&((_p)->u.xllll.next))); + break; + case _traced_switch_on_sub_arg_type : + _p = ((yamop *)(&((_p)->u.sllll.next))); + break; + case _traced_jump_if_var : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_jump_if_nonvar : + _p = ((yamop *)(&((_p)->u.xll.next))); + break; + case _traced_if_not_then : + _p = ((yamop *)(&((_p)->u.clll.next))); + break; + case _traced_switch_on_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_switch_on_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_go_on_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_go_on_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_if_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_if_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_index_dbref : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_index_blob : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_index_long : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_jit_handler : + _p = ((yamop *)(&((_p)->u.jhc.next))); + break; + case _traced_p_atom_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_atom_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_atomic_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_atomic_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_integer_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_integer_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_nonvar_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_nonvar_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_number_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_number_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_var_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_var_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_db_ref_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_db_ref_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_primitive_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_primitive_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_compound_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_compound_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_float_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_float_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_plus_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_plus_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_plus_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_plus_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_minus_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_minus_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_minus_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_minus_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_times_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_times_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_times_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_times_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_div_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_div_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_div_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_div_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_div_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_div_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_and_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_and_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_and_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_and_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_or_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_or_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_or_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_or_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_sll_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_sll_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_sll_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_sll_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_sll_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_sll_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_slr_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_slr_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_slr_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_slr_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_slr_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_slr_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_call_bfunc_xx : + _p = ((yamop *)(&((_p)->u.plxxs.next))); + break; + case _traced_call_bfunc_yx : + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + case _traced_call_bfunc_xy : + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + case _traced_call_bfunc_yy : + _p = ((yamop *)(&((_p)->u.plyys.next))); + break; + case _traced_p_equal : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_p_dif : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_p_eq : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_p_arg_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_arg_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_arg_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_arg_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_func2s_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_func2s_cv : + _p = ((yamop *)(&((_p)->u.xxc.next))); + break; + case _traced_p_func2s_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_func2s_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_func2s_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_func2s_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_func2f_xx : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_func2f_xy : + _p = ((yamop *)(&((_p)->u.xxy.next))); + break; + case _traced_p_func2f_yx : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_func2f_yy : + _p = ((yamop *)(&((_p)->u.yyx.next))); + break; + case _traced_p_functor : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_p_execute2 : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _traced_p_execute : + _p = ((yamop *)(&((_p)->u.Osbmp.next))); + break; + case _traced_p_execute_tail : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; +#ifdef YAPOR + case _traced_getwork_first_time : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_getwork : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_getwork_seq : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_sync : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _traced_clause_with_cut : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif + case _traced_table_load_answer : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_try_answer : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_try_single : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_try_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_try : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_retry : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_trust : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_new_answer : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _traced_table_answer_resolution : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_completion : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#ifdef THREADS_CONSUMER_SHARING + case _traced_table_answer_resolution_completion: + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#endif + case _traced_trie_do_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif +#ifdef YAPOR + case _traced_or_last : + _p = ((yamop *)(&((_p)->u.sblp.next))); + break; +#else + case _traced_or_last : + _p = ((yamop *)(&((_p)->u.p.next))); + break; +#endif + } + } + return 1; +} + diff --git a/JIT/HPP/JIT.hh b/JIT/HPP/JIT.hh new file mode 100644 index 000000000..2db27fa2d --- /dev/null +++ b/JIT/HPP/JIT.hh @@ -0,0 +1,24 @@ +#ifndef JIT_HPP +#define JIT_HPP + +#ifdef __cplusplus + +#include +#include +#include +#include +#include +#include +#include +#include "config.h" +#include "absmi.h" + +using namespace std; + +#else + +#define LIMIT_COUNT 4096 + +#endif + +#endif diff --git a/JIT/HPP/JIT_Compiler.hh b/JIT/HPP/JIT_Compiler.hh new file mode 100644 index 000000000..d7f0fa0cd --- /dev/null +++ b/JIT/HPP/JIT_Compiler.hh @@ -0,0 +1,104 @@ +#ifndef JIT_COMPILER_HPP +#define JIT_COMPILER_HPP + +#ifdef __cplusplus + +#include "llvm/LLVMContext.h" +#include "llvm/Module.h" +#include "llvm/Constants.h" +#include "llvm/DerivedTypes.h" +#include "llvm/Instructions.h" +#include "llvm/Linker.h" +#include "llvm/PassManager.h" +#include "llvm/CallGraphSCCPass.h" +#include "llvm/ADT/Statistic.h" +#include "llvm/ADT/StringSet.h" +#include "llvm/ADT/Triple.h" +#include "llvm/Assembly/PrintModulePass.h" +#include "llvm/CodeGen/Passes.h" +#include "llvm/CodeGen/MachineCodeInfo.h" +#include "llvm/ExecutionEngine/JIT.h" +#include "llvm/ExecutionEngine/Interpreter.h" +#include "llvm/ExecutionEngine/GenericValue.h" +#include "llvm/ExecutionEngine/JITMemoryManager.h" +#include "llvm/ExecutionEngine/JITEventListener.h" +#include "llvm/Support/DataStream.h" +#include "llvm/Support/IRReader.h" +#include "llvm/Support/Host.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/TargetSelect.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/raw_os_ostream.h" +#include "llvm/Support/IRBuilder.h" +#include "llvm/Support/PathV1.h" +#include "llvm/Support/TypeBuilder.h" +#include "llvm/Support/ToolOutputFile.h" +#include "llvm/Target/TargetData.h" +#include "llvm/Target/TargetMachine.h" +#include "llvm/Target/TargetOptions.h" +#include "llvm/Target/TargetLibraryInfo.h" +#include "llvm/Analysis/Passes.h" +#include "llvm/Analysis/IVUsers.h" +#include "llvm/Analysis/Lint.h" +#include "llvm/Analysis/DebugInfo.h" +#include "llvm/Analysis/Verifier.h" +#include "llvm/Analysis/LoopPass.h" +#include "llvm/Analysis/RegionPass.h" +#include "llvm/Analysis/CFGPrinter.h" +#include "llvm/Analysis/DomPrinter.h" +#include "llvm/Analysis/BranchProbabilityInfo.h" +#include "llvm/Analysis/RegionPrinter.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/system_error.h" +#include "llvm/Support/Process.h" +#include "llvm/Bitcode/ReaderWriter.h" +#include "llvm/Transforms/IPO.h" +#include "llvm/Transforms/Scalar.h" +#include "llvm/Transforms/Vectorize.h" +#include "llvm/Transforms/IPO/PassManagerBuilder.h" +#include "llvm/Transforms/Utils/Cloning.h" + +using namespace llvm; + +#include +#include +#include "JIT.hpp" + +using namespace std; + +extern short global; +extern Environment ExpEnv; +extern NativeContext *NativeArea; + +class JIT_Compiler { + private: + /* main method of JIT Compiler: compiles by clang, analyzes, optimizs and generates code accordingly the user choices */ + void* compile_all(LLVMContext* &Context, yamop* p); + + /* aid method to 'compile_all': adds register allocator pass to be used. + WARNING: don't use! For some reasons llvm crashes when I use it */ + void set_regalloc_pass(PassManager &PM); + + /* aid method to 'compile_all': optimizes module by individual transform passes or transform level */ + void optimize_module(llvm::Module* &M); + + /* aid method to 'compile_all': analyzes module by individual analysis passes */ + void analyze_module(llvm::Module* &M); + public: + /* method invoked by wrapper 'call_JIT_Compiler' */ + void* compile(yamop*); +}; +#else + +struct JIT_Compiler{}; // Doing this, I can call class 'JIT_Compiler' from C code + +#endif + +#ifdef __cplusplus + +extern "C" void* call_JIT_Compiler(JIT_Compiler* jc, yamop* p) { return jc->compile(p); } +extern "C" void shutdown_llvm() { llvm_shutdown(); } + +#endif //#ifdef __cplusplus + +#endif diff --git a/JIT/HPP/PassPrinters.hh b/JIT/HPP/PassPrinters.hh new file mode 100644 index 000000000..9bc4c5ab4 --- /dev/null +++ b/JIT/HPP/PassPrinters.hh @@ -0,0 +1,183 @@ +/** +* The code below is adapted from opt tool according to clearance and conditions established in NCSA license as follows: + +* Copyright (c) 2003 University of Illinois. All rights reserved. + +* Developed by: LLVM Developer Group +* University of Illinois +* http://llvm.org/ + +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +* files (the "Software"), to deal with the Software without restriction, including without limitation the rights to use, copy, +* modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +* is furnished to do so, subject to the following conditions: + +* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers. +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers +* in the documentation and/or other materials provided with the distribution. +* Neither the names of LLVM Developer Group, University of Illinois, nor the names of its contributors may be used to endorse or +* promote products derived from this Software without specific prior written permission. + +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HROLDERS +* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +* IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE. + +**/ + +struct CallGraphSCCPassPrinter : public CallGraphSCCPass { + static char ID; + const PassInfo *PassToPrint; + std::string PassName; + + CallGraphSCCPassPrinter(const PassInfo *PI) : + CallGraphSCCPass(ID), PassToPrint(PI) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "CallGraphSCCPass Printer: " + PassToPrintName; + } + + virtual bool runOnSCC(CallGraphSCC &SCC) { + errs() << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + + // Get and print pass... + for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { + Function *F = (*I)->getFunction(); + if (F) + getAnalysisID(PassToPrint->getTypeInfo()).print(errs(), + F->getParent()); + } + return false; + } + + virtual const char *getPassName() const { return PassName.c_str(); } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequiredID(PassToPrint->getTypeInfo()); + AU.setPreservesAll(); + } +}; + +char CallGraphSCCPassPrinter::ID = 0; + +struct ModulePassPrinter : public ModulePass { + static char ID; + const PassInfo *PassToPrint; + std::string PassName; + + ModulePassPrinter(const PassInfo *PI) + : ModulePass(ID), PassToPrint(PI) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "ModulePass Printer: " + PassToPrintName; + } + + virtual bool runOnModule(Module &M) { + errs() << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + + // Get and print pass... + getAnalysisID(PassToPrint->getTypeInfo()).print(errs(), &M); + return false; + } + + virtual const char *getPassName() const { return PassName.c_str(); } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequiredID(PassToPrint->getTypeInfo()); + AU.setPreservesAll(); + } +}; + +char ModulePassPrinter::ID = 0; + +struct FunctionPassPrinter : public FunctionPass { + const PassInfo *PassToPrint; + static char ID; + std::string PassName; + + FunctionPassPrinter(const PassInfo *PI) + : FunctionPass(ID), PassToPrint(PI) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "FunctionPass Printer: " + PassToPrintName; + } + + virtual bool runOnFunction(Function &F) { + errs() << "Printing analysis '" << PassToPrint->getPassName() + << "' for function '" << F.getName() << "':\n"; + + // Get and print pass... + getAnalysisID(PassToPrint->getTypeInfo()).print(errs(), + F.getParent()); + return false; + } + + virtual const char *getPassName() const { return PassName.c_str(); } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequiredID(PassToPrint->getTypeInfo()); + AU.setPreservesAll(); + } +}; + +char FunctionPassPrinter::ID = 0; + +struct LoopPassPrinter : public LoopPass { + static char ID; + const PassInfo *PassToPrint; + std::string PassName; + + LoopPassPrinter(const PassInfo *PI) : + LoopPass(ID), PassToPrint(PI) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "LoopPass Printer: " + PassToPrintName; + } + + + virtual bool runOnLoop(Loop *L, LPPassManager &LPM) { + errs() << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + + // Get and print pass... + getAnalysisID(PassToPrint->getTypeInfo()).print(errs(), + L->getHeader()->getParent()->getParent()); + return false; + } + + virtual const char *getPassName() const { return PassName.c_str(); } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequiredID(PassToPrint->getTypeInfo()); + AU.setPreservesAll(); + } +}; + +char LoopPassPrinter::ID = 0; + +struct RegionPassPrinter : public RegionPass { + static char ID; + const PassInfo *PassToPrint; + std::string PassName; + + RegionPassPrinter(const PassInfo *PI) : RegionPass(ID), + PassToPrint(PI) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "RegionPass Printer: " + PassToPrintName; + } + + virtual bool runOnRegion(Region *R, RGPassManager &RGM) { + errs() << "Printing analysis '" << PassToPrint->getPassName() << "' for " + << "region: '" << R->getNameStr() << "' in function '" + << R->getEntry()->getParent()->getName() << "':\n"; + + // Get and print pass... + getAnalysisID(PassToPrint->getTypeInfo()).print(errs(), + R->getEntry()->getParent()->getParent()); + return false; + } + + virtual const char *getPassName() const { return PassName.c_str(); } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequiredID(PassToPrint->getTypeInfo()); + AU.setPreservesAll(); + } +}; + +char RegionPassPrinter::ID = 0; diff --git a/JIT/HPP/Yap_AppliedBasicBlocks.h b/JIT/HPP/Yap_AppliedBasicBlocks.h new file mode 100644 index 000000000..da21e8d03 --- /dev/null +++ b/JIT/HPP/Yap_AppliedBasicBlocks.h @@ -0,0 +1,1502 @@ + BBLOCK( ENTRY) + BBLOCK( YAAM_DEREF_BODY_D0PT0) + BBLOCK( YAAM_DEREF_BODY_D0PT1) + BBLOCK( YAAM_DEREF_BODY_D0S_SREG) + BBLOCK( YAAM_DEREF_BODY_D1PT0) + BBLOCK( YAAM_DEREF_BODY_D1PT1) + BBLOCK( YAAM_FAIL) + BBLOCK( YAAM_CHECK_TRAIL_TR) + BBLOCK( YAAM_UNIFYBOUND) + BBLOCK( NoStackExecute_Exception) + BBLOCK( NoStackDExecute_Exception) + BBLOCK( NoStackCall_Exception) + BBLOCK( NoStackDeallocate_Exception) +#ifdef COROUTINING + BBLOCK( NoStackFail_Exception) +#endif + BBLOCK( NoStackCut_Exception) + BBLOCK( NoStackCutT_Exception) + BBLOCK( NoStackCutE_Exception) + BBLOCK( NoStackCommitX_Exception) + BBLOCK( NoStackCommitY_Exception) + BBLOCK( NoStackEither_Exception) + BBLOCK( NoStackPExecute_Exception) + BBLOCK( NoStackPExecute2_Exception) + BBLOCK( NoStackPTExecute_Exception) +/** Plain try retry and trust **/ + BBLOCK( TRY_ME_INSTINIT) +#ifdef YAPOR + BBLOCK( TRY_ME_YAPOR) +#endif + BBLOCK( TRY_ME_END) + BBLOCK( RETRY_ME_INSTINIT) +#ifdef FROZEN_STACKS + BBLOCK( RETRY_ME_FROZEN) +#else + BBLOCK( RETRY_ME_NOFROZEN) +#endif + BBLOCK( RETRY_ME_END) + BBLOCK( TRUST_ME_INSTINIT) + BBLOCK( TRUST_ME_IF) + BBLOCK( TRUST_ME_END) +/** Profiled try retry and trust **/ + BBLOCK( ENTER_PROFILING_INSTINIT) + BBLOCK( RETRY_PROFILED_INSTINIT) + BBLOCK( PROFILED_RETRY_ME_INSTINIT) +#ifdef FROZEN_STACKS + BBLOCK( PROFILED_RETRY_ME_FROZEN) +#else + BBLOCK( PROFILED_RETRY_ME_NOFROZEN) +#endif + BBLOCK( PROFILED_RETRY_ME_END) + BBLOCK( PROFILED_TRUST_ME_INSTINIT) + BBLOCK( PROFILED_TRUST_ME_IF) + BBLOCK( PROFILED_TRUST_ME_END) + BBLOCK( PROFILED_RETRY_LOGICAL_INSTINIT) +#ifdef THREADS + BBLOCK( PROFILED_RETRY_LOGICAL_THREADS) +#endif + BBLOCK( PROFILED_RETRY_LOGICAL_POST_THREADS) +#ifdef FROZEN_STACKS + BBLOCK( PROFILED_RETRY_LOGICAL_FROZEN) +#else + BBLOCK( PROFILED_RETRY_LOGICAL_NOFROZEN) +#endif + BBLOCK( PROFILED_RETRY_LOGICAL_END) + BBLOCK( PROFILED_TRUST_LOGICAL_INSTINIT) + BBLOCK( PROFILED_TRUST_LOGICAL_END) +/** Call count instructions **/ + BBLOCK( COUNT_CALL_INSTINIT) + BBLOCK( COUNT_CALL_MIDDLE) + BBLOCK( COUNT_CALL_END) + BBLOCK( COUNT_RETRY_INSTINIT) + BBLOCK( COUNT_RETRY_MIDDLE) + BBLOCK( COUNT_RETRY_END) + BBLOCK( COUNT_RETRY_ME_INSTINIT) + BBLOCK( COUNT_RETRY_ME_MIDDLE) + BBLOCK( COUNT_RETRY_ME_END) + BBLOCK( COUNT_TRUST_ME_INSTINIT) + BBLOCK( COUNT_TRUST_ME_MIDDLE) + BBLOCK( COUNT_TRUST_ME_END) + BBLOCK( COUNT_RETRY_LOGICAL_INSTINIT) + BBLOCK( COUNT_RETRY_LOGICAL_END) + BBLOCK( COUNT_TRUST_LOGICAL_INSTINIT) + BBLOCK( COUNT_TRUST_LOGICAL_END) +/** enter a logical semantics dynamic predicate **/ + BBLOCK( LOCK_LU_INSTINIT) + BBLOCK( LOCK_LU_END) + BBLOCK( UNLOCK_LU_INSTINIT) +#if defined(YAPOR) || defined(THREADS) + BBLOCK( UNLOCK_LU_YAPOR_THREADS) +#endif + BBLOCK( UNLOCK_LU_END) + BBLOCK( ALLOC_FOR_LOGICAL_PRED_INSTINIT) +#if MULTIPLE_STACKS + BBLOCK( ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS) +#if PARALLEL_YAP + BBLOCK( ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL) +#endif + BBLOCK( ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END) +#else + BBLOCK( ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT) + BBLOCK( ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF) +#endif + BBLOCK( ALLOC_FOR_LOGICAL_PRED_END) + BBLOCK( COPY_IDB_TERM_INSTINIT) + BBLOCK( COPY_IDB_TERM_END) + BBLOCK( UNIFY_IDB_TERM_INSTINIT) + BBLOCK( UNIFY_IDB_TERM_END) +/** check for enough room **/ + BBLOCK( ENSURE_SPACE_INSTINIT) + BBLOCK( ENSURE_SPACE_END) +/** try and retry of dynamic predicates **/ + BBLOCK( SPY_OR_TRYMARK_INSTINIT) + BBLOCK( TRY_AND_MARK_INSTINIT) +#if defined(YAPOR) || defined(THREADS) +#ifdef YAPOR + BBLOCK( TRY_AND_MARK_YAPOR_THREADS_YAPOR) +#endif + BBLOCK( TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF) +#endif + BBLOCK( TRY_AND_MARK_NOYAPOR_NOTHREADS) +#ifdef YAPOR + BBLOCK( TRY_AND_MARK_SET_LOAD) +#endif + BBLOCK( TRY_AND_MARK_POST_SET_LOAD) +#if MULTIPLE_STACKS + BBLOCK( TRY_AND_MARK_MULTIPLE_STACKS) +#else + BBLOCK( TRY_AND_MARK_NOMULTIPLE_STACKS_IF) +#endif + BBLOCK( TRY_AND_MARK_END) + BBLOCK( COUNT_RETRY_AND_MARK_INSTINIT) + BBLOCK( PROFILED_RETRY_AND_MARK_INSTINIT) + BBLOCK( RETRY_AND_MARK_INSTINIT) +#ifdef YAPOR + BBLOCK( RETRY_AND_MARK_YAPOR) +#endif + BBLOCK( RETRY_AND_MARK_POST_YAPOR) +#ifdef FROZEN_STACKS + BBLOCK( RETRY_AND_MARK_FROZEN) +#else + BBLOCK( RETRY_AND_MARK_NOFROZEN) +#endif + BBLOCK( RETRY_AND_MARK_POST_FROZEN) +#if MULTIPLE_STACKS + BBLOCK( RETRY_AND_MARK_MULTIPLE_STACKS) +#else + BBLOCK( RETRY_AND_MARK_NOMULTIPLE_STACKS_IF) +#endif + BBLOCK( RETRY_AND_MARK_END) +/** Failure **/ + BBLOCK( TRUST_FAIL_INSTINIT) +#ifdef CUT_C + BBLOCK( TRUST_FAIL_CUT_C) +#endif +#ifdef YAPOR + BBLOCK( TRUST_FAIL_YAPOR) +#endif + BBLOCK( TRUST_FAIL_NOYAPOR) +#ifdef YAPOR + BBLOCK( LBL_SHARED_FAIL) +#endif + BBLOCK( OP_FAIL_INSTINIT) + BBLOCK( LBL_FAIL_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( LBL_FAIL_LOW_LEVEL_TRACER) +#endif + BBLOCK( LBL_FAIL_POST_LOW_LEVEL_TRACER) + BBLOCK( LBL_FAIL_VARTERM) + BBLOCK( LBL_FAIL_PAIRTERM_INIT) + BBLOCK( LBL_FAIL_PAIRTERM_END_APPL) + BBLOCK( LBL_FAIL_END) +/** Cut & Commit Instructions **/ + BBLOCK( CUT_INSTINIT) +#ifdef COROUTINING + BBLOCK( CUT_COROUTINING) +#endif + BBLOCK( CUT_NOCOROUTINING) + BBLOCK( CUT_T_INSTINIT) +#ifdef COROUTINING + BBLOCK( CUT_T_COROUTINING) +#endif + BBLOCK( CUT_T_NOCOROUTINING) + BBLOCK( CUT_E_INSTINIT) +#ifdef COROUTINING + BBLOCK( CUT_E_COROUTINING) +#endif + BBLOCK( CUT_E_NOCOROUTINING) + BBLOCK( SAVE_B_X_INSTINIT) +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + BBLOCK( SAVE_B_X_YSBA_FROZEN) +#else + BBLOCK( SAVE_B_X_NOYSBA_NOFROZEN) +#endif + BBLOCK( SAVE_B_X_END) + BBLOCK( SAVE_B_Y_INSTINIT) +#if defined(YAPOR_SBA) + BBLOCK( SAVE_B_Y_YSBA) +#else + BBLOCK( SAVE_B_Y_NOYSBA) +#endif + BBLOCK( SAVE_B_Y_END) + BBLOCK( COMMIT_B_X_INSTINIT) + BBLOCK( COMMIT_B_X_DO_COMMIT_B_X) + BBLOCK( COMMIT_B_X_COMMIT_B_X_NVAR) +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + BBLOCK( COMMIT_B_X_YSBA_FROZEN) +#else + BBLOCK( COMMIT_B_X_NOYSBA_NOFROZEN) +#endif + BBLOCK( COMMIT_B_X_POST_YSBA_FROZEN) + BBLOCK( COMMIT_B_X_END) + BBLOCK( COMMIT_B_Y_INSTINIT) + BBLOCK( COMMIT_B_Y_DO_COMMIT_B_Y) + BBLOCK( COMMIT_B_Y_COMMIT_B_Y_NVAR) +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + BBLOCK( COMMIT_B_Y_YSBA_FROZEN) +#else + BBLOCK( COMMIT_B_Y_NOYSBA_NOFROZEN) +#endif + BBLOCK( COMMIT_B_Y_POST_YSBA_FROZEN) + BBLOCK( COMMIT_B_Y_END) +/** Call / Proceed instructions **/ + BBLOCK( EXECUTE_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( EXECUTE_LOW_LEVEL_TRACER) +#endif + BBLOCK( EXECUTE_POST_LOW_LEVEL_TRACER) + BBLOCK( EXECUTE_POST_NOCHECKING) +#ifdef DEPTH_LIMIT + BBLOCK( EXECUTE_DEPTH_MINOR) + BBLOCK( EXECUTE_DEPTH_MOFPRED) + BBLOCK( EXECUTE_DEPTH_END) +#endif + BBLOCK( EXECUTE_END_END) + BBLOCK( DEXECUTE_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( DEXECUTE_LOW_LEVEL_TRACER) +#endif + BBLOCK( DEXECUTE_POST_LOW_LEVEL_TRACER) +#ifdef DEPTH_LIMIT + BBLOCK( DEXECUTE_DEPTH_MINOR) + BBLOCK( DEXECUTE_DEPTH_MOFPRED) + BBLOCK( DEXECUTE_DEPTH_END) +#endif + BBLOCK( DEXECUTE_END_END) + BBLOCK( FCALL_INST) + BBLOCK( CALL_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( CALL_LOW_LEVEL_TRACER) +#endif + BBLOCK( CALL_POST_LOW_LEVEL_TRACER) + BBLOCK( CALL_POST_NO_CHECKING) +#ifdef DEPTH_LIMIT + BBLOCK( CALL_DEPTH_MINOR) + BBLOCK( CALL_DEPTH_MOFPRED) + BBLOCK( CALL_DEPTH_END) +#endif + BBLOCK( CALL_END_END) + BBLOCK( PROCCEED_INSTINIT) +#ifdef DEPTH_LIMIT + BBLOCK( PROCCEED_DEPTH) +#endif + BBLOCK( PROCCEED_END) + BBLOCK( ALLOCATE_INSTINIT) +#ifdef DEPTH_LIMIT + BBLOCK( ALLOCATE_DEPTH) +#endif + BBLOCK( ALLOCATE_END) + BBLOCK( DEALLOCATE_INSTINIT) + BBLOCK( DEALLOCATE_POST_CHECK) +#ifdef DEPTH_LIMIT + BBLOCK( DEALLOCATE_DEPTH) +#endif + BBLOCK( DEALLOCATE_FROZEN) + BBLOCK( DEALLOCATE_POST_FROZEN) + BBLOCK( DEALLOCATE_END) +/** OPTYap instructions **/ +// JIT does not support ) +/** Get Instructions **/ + BBLOCK( GET_X_VAR_INSTINIT) + BBLOCK( GET_Y_VAR_INSTINIT) + BBLOCK( GET_YY_VAR_INSTINIT) + BBLOCK( GET_X_VAL_INSTINIT) + BBLOCK( GET_X_VAL_GVALX_NONVAR) + BBLOCK( GET_X_VAL_GVALX_NONVAR_NONVAR) + BBLOCK( GET_X_VAL_GVALX_NONVAR_UNK) + BBLOCK( GET_X_VAL_GVALX_UNK) + BBLOCK( GET_X_VAL_GVALX_VAR_NONVAR) + BBLOCK( GET_X_VAL_GVALX_VAR_UNK) + BBLOCK( GET_Y_VAL_INSTINIT) + BBLOCK( GET_Y_VAL_GVALY_NONVAR) + BBLOCK( GET_Y_VAL_GVALY_NONVAR_NONVAR) + BBLOCK( GET_Y_VAL_GVALY_NONVAR_UNK) + BBLOCK( GET_Y_VAL_GVALY_UNK) + BBLOCK( GET_Y_VAL_GVALY_VAR_NONVAR) + BBLOCK( GET_Y_VAL_GVALY_VAR_UNK) + BBLOCK( GET_ATOM_INSTINIT) + BBLOCK( GET_ATOM_GATOM_NONVAR) + BBLOCK( GET_ATOM_GATOM_UNK) + BBLOCK( GET_2ATOMS_INSTINIT) + BBLOCK( GET_2ATOMS_GATOM_2UNK) + BBLOCK( GET_2ATOMS_GATOM_2B) + BBLOCK( GET_2ATOMS_GATOM_2BNONVAR) + BBLOCK( GET_2ATOMS_GATOM_2BUNK) + BBLOCK( GET_3ATOMS_INSTINIT) + BBLOCK( GET_3ATOMS_GATOM_3UNK) + BBLOCK( GET_3ATOMS_GATOM_3B) + BBLOCK( GET_3ATOMS_GATOM_3BUNK) + BBLOCK( GET_3ATOMS_GATOM_3C) + BBLOCK( GET_3ATOMS_GATOM_3CNONVAR) + BBLOCK( GET_3ATOMS_GATOM_3CUNK) + BBLOCK( GET_4ATOMS_INSTINIT) + BBLOCK( GET_4ATOMS_GATOM_4UNK) + BBLOCK( GET_4ATOMS_GATOM_4B) + BBLOCK( GET_4ATOMS_GATOM_4BUNK) + BBLOCK( GET_4ATOMS_GATOM_4C) + BBLOCK( GET_4ATOMS_GATOM_4CUNK) + BBLOCK( GET_4ATOMS_GATOM_4D) + BBLOCK( GET_4ATOMS_GATOM_4DNONVAR) + BBLOCK( GET_4ATOMS_GATOM_4DUNK) + BBLOCK( GET_5ATOMS_INSTINIT) + BBLOCK( GET_5ATOMS_GATOM_5UNK) + BBLOCK( GET_5ATOMS_GATOM_5B) + BBLOCK( GET_5ATOMS_GATOM_5BUNK) + BBLOCK( GET_5ATOMS_GATOM_5C) + BBLOCK( GET_5ATOMS_GATOM_5CUNK) + BBLOCK( GET_5ATOMS_GATOM_5D) + BBLOCK( GET_5ATOMS_GATOM_5DUNK) + BBLOCK( GET_5ATOMS_GATOM_5E) + BBLOCK( GET_5ATOMS_GATOM_5ENONVAR) + BBLOCK( GET_5ATOMS_GATOM_5EUNK) + BBLOCK( GET_6ATOMS_INSTINIT) + BBLOCK( GET_6ATOMS_GATOM_6UNK) + BBLOCK( GET_6ATOMS_GATOM_6B) + BBLOCK( GET_6ATOMS_GATOM_6BUNK) + BBLOCK( GET_6ATOMS_GATOM_6C) + BBLOCK( GET_6ATOMS_GATOM_6CUNK) + BBLOCK( GET_6ATOMS_GATOM_6D) + BBLOCK( GET_6ATOMS_GATOM_6DUNK) + BBLOCK( GET_6ATOMS_GATOM_6E) + BBLOCK( GET_6ATOMS_GATOM_6EUNK) + BBLOCK( GET_6ATOMS_GATOM_6F) + BBLOCK( GET_6ATOMS_GATOM_6FNONVAR) + BBLOCK( GET_6ATOMS_GATOM_6FUNK) + BBLOCK( GET_LIST_INSTINIT) + BBLOCK( GET_LIST_GLIST_NONVAR) + BBLOCK( GET_LIST_GLIST_UNK) + BBLOCK( GET_STRUCT_INSTINIT) + BBLOCK( GET_STRUCT_GSTRUCT_NONVAR) + BBLOCK( GET_STRUCT_GSTRUCT_UNK) + BBLOCK( GET_FLOAT_INSTINIT) + BBLOCK( GET_FLOAT_GFLOAT_NONVAR) + BBLOCK( GET_FLOAT_GFLOAT_UNK) + BBLOCK( GET_LONGINT_INSTINIT) + BBLOCK( GET_LONGINT_GLONGINT_NONVAR) + BBLOCK( GET_LONGINT_GLONGINT_UNK) +#ifdef USE_GMP + BBLOCK( GET_BIGINT_INSTINIT) + BBLOCK( GET_BIGINT_GBIGINT_NONVAR) + BBLOCK( GET_BIGINT_GBIGINT_UNK) +#endif + BBLOCK( GET_DBTERM_INSTINIT) + BBLOCK( GET_DBTERM_GDBTERM_NONVAR) + BBLOCK( GET_DBTERM_GDBTERM_UNK) +/** Optimised Get List Instructions **/ + BBLOCK( GLIST_VALX_INSTINIT) + BBLOCK( GLIST_VALX_GLIST_VALX_READ) + BBLOCK( GLIST_VALX_GLIST_VALX_NONVAR) + BBLOCK( GLIST_VALX_GLIST_VALX_NONVAR_NONVAR) + BBLOCK( GLIST_VALX_GLIST_VALX_NONVAR_UNK) + BBLOCK( GLIST_VALX_GLIST_VALX_UNK) + BBLOCK( GLIST_VALX_GLIST_VALX_VAR_NONVAR) + BBLOCK( GLIST_VALX_GLIST_VALX_VAR_UNK) + BBLOCK( GLIST_VALX_GLIST_VALX_WRITE) + BBLOCK( GLIST_VALY_INSTINIT) + BBLOCK( GLIST_VALY_GLIST_VALY_READ) + BBLOCK( GLIST_VALY_GLIST_VALY_NONVAR) + BBLOCK( GLIST_VALY_GLIST_VALY_NONVAR_NONVAR) + BBLOCK( GLIST_VALY_GLIST_VALY_NONVAR_UNK) + BBLOCK( GLIST_VALY_GLIST_VALY_UNK) + BBLOCK( GLIST_VALY_GLIST_VALY_VAR_NONVAR) + BBLOCK( GLIST_VALY_GLIST_VALY_VAR_UNK) + BBLOCK( GLIST_VALY_GLIST_VALY_WRITE) + BBLOCK( GL_VOID_VARX_INSTINIT) + BBLOCK( GL_VOID_VARX_GLIST_VOID_VARX_READ) + BBLOCK( GL_VOID_VARX_GLIST_VOID_VAR_WRITE) + BBLOCK( GL_VOID_VARY_INSTINIT) + BBLOCK( GL_VOID_VARY_GLIST_VOID_VARY_READ) + BBLOCK( GL_VOID_VARY_GLIST_VOID_VARY_WRITE) + BBLOCK( GL_VOID_VALX_INSTINIT) + BBLOCK( GL_VOID_VALX_GLIST_VOID_VALX_READ) + BBLOCK( GL_VOID_VALX_GLIST_VOID_VALX_NONVAR) + BBLOCK( GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR) + BBLOCK( GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK) + BBLOCK( GL_VOID_VALX_GLIST_VOID_VALX_UNK) + BBLOCK( GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR) + BBLOCK( GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK) + BBLOCK( GL_VOID_VALX_GLIST_VOID_VALX_WRITE) + BBLOCK( GL_VOID_VALY_INSTINIT) + BBLOCK( GL_VOID_VALY_GLIST_VOID_VALY_READ) + BBLOCK( GL_VOID_VALY_GLIST_VOID_VALY_NONVAR) + BBLOCK( GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR) + BBLOCK( GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK) + BBLOCK( GL_VOID_VALY_GLIST_VOID_VALY_UNK) + BBLOCK( GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR) + BBLOCK( GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK) + BBLOCK( GL_VOID_VALY_GLIST_VOID_VALY_WRITE) +/** Unify instructions **/ + BBLOCK( UNIFY_X_VAR_INSTINIT) +#ifdef YAPOR_SBA + BBLOCK( UNIFY_X_VAR_YAPOR_SBA) +#endif + BBLOCK( UNIFY_X_VAR_END) + BBLOCK( UNIFY_X_VAR_WRITE_INSTINIT) + BBLOCK( UNIFY_L_X_VAR_INSTINIT) +#ifdef YAPOR_SBA + BBLOCK( UNIFY_L_X_VAR_YAPOR_SBA) +#endif + BBLOCK( UNIFY_L_X_VAR_END) + BBLOCK( UNIFY_L_X_VAR_WRITE_INSTINIT) + BBLOCK( UNIFY_X_VAR2_INSTINIT) +#ifdef YAPOR_SBA + BBLOCK( UNIFY_X_VAR2_YAPOR_SBA) +#endif + BBLOCK( UNIFY_X_VAR2_END) + BBLOCK( UNIFY_X_VAR2_WRITE_INSTINIT) + BBLOCK( UNIFY_L_X_VAR2_INSTINIT) + BBLOCK( UNIFY_L_X_VAR2_WRITE_INSTINIT) + BBLOCK( UNIFY_Y_VAR_INSTINIT) + BBLOCK( UNIFY_Y_VAR_WRITE_INSTINIT) + BBLOCK( UNIFY_L_Y_VAR_INSTINIT) + BBLOCK( UNIFY_L_Y_VAR_WRITE_INSTINIT) + BBLOCK( UNIFY_X_VAL_INSTINIT) + BBLOCK( UNIFY_X_VAL_UVALX_NONVAR) + BBLOCK( UNIFY_X_VAL_UVALX_NONVAR_NONVAR) + BBLOCK( UNIFY_X_VAL_UVALX_NONVAR_UNK) + BBLOCK( UNIFY_X_VAL_UVALX_UNK) + BBLOCK( UNIFY_X_VAL_UVALX_VAR_NONVAR) + BBLOCK( UNIFY_X_VAL_UVALX_VAR_UNK) + BBLOCK( UNIFY_X_VAL_WRITE_INSTINIT) + BBLOCK( UNIFY_L_X_VAL_INSTINIT) + BBLOCK( UNIFY_L_X_VAL_ULVALX_NONVAR) + BBLOCK( UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR) + BBLOCK( UNIFY_L_X_VAL_ULVALX_NONVAR_UNK) + BBLOCK( UNIFY_L_X_VAL_ULVALX_UNK) + BBLOCK( UNIFY_L_X_VAL_ULVALX_VAR_NONVAR) + BBLOCK( UNIFY_L_X_VAL_ULVALX_VAR_UNK) + BBLOCK( UNIFY_L_X_VAL_WRITE_INSTINIT) + BBLOCK( UNIFY_Y_VAL_INSTINIT) + BBLOCK( UNIFY_Y_VAL_UVALY_NONVAR) + BBLOCK( UNIFY_Y_VAL_UVALY_NONVAR_NONVAR) + BBLOCK( UNIFY_Y_VAL_UVALY_NONVAR_UNK) + BBLOCK( UNIFY_Y_VAL_UVALY_UNK) + BBLOCK( UNIFY_Y_VAL_UVALY_VAR_NONVAR) + BBLOCK( UNIFY_Y_VAL_UVALY_VAR_UNK) + BBLOCK( UNIFY_Y_VAL_WRITE_INSTINIT) + BBLOCK( UNIFY_L_Y_VAL_INSTINIT) + BBLOCK( UNIFY_L_Y_VAL_ULVALY_NONVAR) + BBLOCK( UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR) + BBLOCK( UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK) + BBLOCK( UNIFY_L_Y_VAL_ULVALY_UNK) + BBLOCK( UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR) + BBLOCK( UNIFY_L_Y_VAL_ULVALY_VAR_UNK) + BBLOCK( UNIFY_L_Y_VAL_WRITE_INSTINIT) + BBLOCK( UNIFY_X_LOC_INSTINIT) + BBLOCK( UNIFY_X_LOC_UVALX_LOC_NONVAR) + BBLOCK( UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR) + BBLOCK( UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK) + BBLOCK( UNIFY_X_LOC_UVALX_LOC_UNK) + BBLOCK( UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR) + BBLOCK( UNIFY_X_LOC_UVALX_LOC_VAR_UNK) + BBLOCK( UNIFY_X_LOC_WRITE_INSTINIT) + BBLOCK( UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR) + BBLOCK( UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK) + BBLOCK( UNIFY_L_X_LOC_INSTINIT) + BBLOCK( UNIFY_L_X_LOC_ULVALX_LOC_NONVAR) + BBLOCK( UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR) + BBLOCK( UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK) + BBLOCK( UNIFY_L_X_LOC_ULVALX_LOC_UNK) + BBLOCK( UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR) + BBLOCK( UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK) + BBLOCK( UNIFY_L_X_LOC_WRITE_INSTINIT) + BBLOCK( UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR) + BBLOCK( UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK) + BBLOCK( UNIFY_Y_LOC_INSTINIT) + BBLOCK( UNIFY_Y_LOC_UVALY_LOC_NONVAR) + BBLOCK( UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR) + BBLOCK( UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK) + BBLOCK( UNIFY_Y_LOC_UVALY_LOC_UNK) + BBLOCK( UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR) + BBLOCK( UNIFY_Y_LOC_UVALY_LOC_VAR_UNK) + BBLOCK( UNIFY_Y_LOC_WRITE_INSTINIT) + BBLOCK( UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR) + BBLOCK( UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK) + BBLOCK( UNIFY_L_Y_LOC_INSTINIT) + BBLOCK( UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR) + BBLOCK( UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR) + BBLOCK( UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK) + BBLOCK( UNIFY_L_Y_LOC_ULVALY_LOC_UNK) + BBLOCK( UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR) + BBLOCK( UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK) + BBLOCK( UNIFY_L_Y_LOC_WRITE_INSTINIT) + BBLOCK( UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR) + BBLOCK( UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK) + BBLOCK( UNIFY_VOID_INSTINIT) + BBLOCK( UNIFY_VOID_WRITE_INSTINIT) + BBLOCK( UNIFY_L_VOID_INSTINIT) + BBLOCK( UNIFY_L_VOID_WRITE_INSTINIT) + BBLOCK( UNIFY_N_VOIDS_INSTINIT) + BBLOCK( UNIFY_N_VOIDS_WRITE_INSTINIT) + BBLOCK( UNIFY_L_N_VOIDS_INSTINIT) + BBLOCK( UNIFY_L_N_VOIDS_WRITE_INSTINIT) + BBLOCK( UNIFY_ATOM_INSTINIT) + BBLOCK( UNIFY_ATOM_UATOM_NONVAR) + BBLOCK( UNIFY_ATOM_UATOM_UNK) + BBLOCK( UNIFY_ATOM_WRITE_INSTINIT) + BBLOCK( UNIFY_L_ATOM_INSTINIT) + BBLOCK( UNIFY_L_ATOM_ULATOM_NONVAR) + BBLOCK( UNIFY_L_ATOM_ULATOM_UNK) + BBLOCK( UNIFY_L_ATOM_WRITE_INSTINIT) + BBLOCK( UNIFY_N_ATOMS_INSTINIT) + BBLOCK( UNIFY_N_ATOMS_WRITE_INSTINIT) + BBLOCK( UNIFY_FLOAT_INSTINIT) + BBLOCK( UNIFY_FLOAT_UFLOAT_NONVAR_INIT) + BBLOCK( UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR) + BBLOCK( UNIFY_FLOAT_UFLOAT_NONVAR_END) + BBLOCK( UNIFY_FLOAT_UFLOAT_UNK) + BBLOCK( UNIFY_FLOAT_WRITE_INSTINIT) + BBLOCK( UNIFY_L_FLOAT_INSTINIT) + BBLOCK( UNIFY_L_FLOAT_D0ISAPPL) + BBLOCK( UNIFY_L_FLOAT_D0ISFUNC) + BBLOCK( UNIFY_L_FLOAT_EQUALS) + BBLOCK( UNIFY_L_FLOAT_ULFLOAT_UNK) + BBLOCK( UNIFY_L_FLOAT_WRITE_INSTINIT) + BBLOCK( UNIFY_LONGINT_INSTINIT) + BBLOCK( UNIFY_LONGINT_D0ISAPPL) + BBLOCK( UNIFY_LONGINT_D0ISFUNC) + BBLOCK( UNIFY_LONGINT_EQUALS) + BBLOCK( UNIFY_LONGINT_ULONGINT_UNK) + BBLOCK( UNIFY_LONGINT_WRITE_INSTINIT) + BBLOCK( UNIFY_L_LONGINT_INSTINIT) + BBLOCK( UNIFY_L_LONGINT_D0ISAPPL) + BBLOCK( UNIFY_L_LONGINT_D0ISFUNC) + BBLOCK( UNIFY_L_LONGINT_EQUALS) + BBLOCK( UNIFY_L_LONGINT_ULLONGINT_UNK) + BBLOCK( UNIFY_L_LONGINT_WRITE_INSTINIT) +#ifdef USE_GMP + BBLOCK( UNIFY_BIGINT_INSTINIT) + BBLOCK( UNIFY_BIGINT_D0ISAPPL) + BBLOCK( UNIFY_BIGINT_D1ISFUNC_GMP) + BBLOCK( UNIFY_BIGINT_UBIGINT_UNK) + BBLOCK( UNIFY_L_BIGINT_INSTINIT) + BBLOCK( UNIFY_L_BIGINT_D0ISAPPL) + BBLOCK( UNIFY_L_BIGINT_D0ISFUNC_GMP) + BBLOCK( UNIFY_L_BIGINT_ULBIGINT_UNK) +#endif + BBLOCK( UNIFY_DBTERM_INSTINIT) + BBLOCK( UNIFY_DBTERM_UDBTERM_NONVAR) + BBLOCK( UNIFY_DBTERM_UDBTERM_UNK) + BBLOCK( UNIFY_L_DBTERM_INSTINIT) + BBLOCK( UNIFY_L_DBTERM_ULDBTERM_NONVAR) + BBLOCK( UNIFY_L_DBTERM_ULDBTERM_UNK) + BBLOCK( UNIFY_LIST_INSTINIT) + BBLOCK( UNIFY_LIST_READMODE) + BBLOCK( UNIFY_LIST_WRITEMODE) + BBLOCK( UNIFY_LIST_WRITE_INSTINIT) + BBLOCK( UNIFY_L_LIST_INSTINIT) + BBLOCK( UNIFY_L_LIST_READMODE) + BBLOCK( UNIFY_L_LIST_WRITEMODE) + BBLOCK( UNIFY_L_LIST_WRITE_INSTINIT) + BBLOCK( UNIFY_STRUCT_INSTINIT) + BBLOCK( UNIFY_STRUCT_READMODE) + BBLOCK( UNIFY_STRUCT_WRITEMODE) + BBLOCK( UNIFY_STRUCT_WRITE_INSTINIT) + BBLOCK( UNIFY_L_STRUC_INSTINIT) + BBLOCK( UNIFY_L_STRUC_READMODE) + BBLOCK( UNIFY_L_STRUC_WRITEMODE) + BBLOCK( UNIFY_L_STRUC_WRITE_INSTINIT) +/** Put Instructions **/ + BBLOCK( PUT_X_VAR_INSTINIT) + BBLOCK( PUT_Y_VAR_INSTINIT) + BBLOCK( PUT_X_VAL_INSTINIT) + BBLOCK( PUT_XX_VAL_INSTINIT) + BBLOCK( PUT_Y_VAL_INSTINIT) + BBLOCK( PUT_Y_VALS_INSTINIT) + BBLOCK( PUT_UNSAFE_INSTINIT) + BBLOCK( PUT_UNSAFE_PUNSAFE_NONVAR) + BBLOCK( PUT_UNSAFE_PUNSAFE_UNK) + BBLOCK( PUT_ATOM_INSTINIT) + BBLOCK( PUT_DBTERM_INSTINIT) + BBLOCK( PUT_BIGINT_INSTINIT) + BBLOCK( PUT_FLOAT_INSTINIT) + BBLOCK( PUT_LONGINT_INSTINIT) + BBLOCK( PUT_LIST_INSTINIT) + BBLOCK( PUT_STRUCT_INSTINIT) +/** Write Instructions **/ + BBLOCK( WRITE_X_VAR_INSTINIT) + BBLOCK( WRITE_VOID_INSTINIT) + BBLOCK( WRITE_N_VOIDS_INSTINIT) + BBLOCK( WRITE_Y_VAR_INSTINIT) + BBLOCK( WRITE_X_VAL_INSTINIT) + BBLOCK( WRITE_X_LOC_INSTINIT) + BBLOCK( WRITE_X_LOC_W_X_BOUND) + BBLOCK( WRITE_X_LOC_W_X_UNK) + BBLOCK( WRITE_Y_VAL_INSTINIT) + BBLOCK( WRITE_Y_LOC_INSTINIT) + BBLOCK( WRITE_Y_LOC_W_Y_BOUND) + BBLOCK( WRITE_Y_LOC_W_Y_UNK) + BBLOCK( WRITE_ATOM_INSTINIT) + BBLOCK( WRITE_BIGINT_INSTINIT) + BBLOCK( WRITE_DBTERM_INSTINIT) + BBLOCK( WRITE_FLOAT_INSTINIT) + BBLOCK( WRITE_LONGIT_INSTINIT) + BBLOCK( WRITE_N_ATOMS_INSTINIT) + BBLOCK( WRITE_LIST_INSTINIT) + BBLOCK( WRITE_L_LIST_INSTINIT) + BBLOCK( WRITE_STRUCT_INSTINIT) + BBLOCK( WRITE_L_STRUC_INSTINIT) +/** Save last unified struct or list **/ + BBLOCK( SAVE_PAIR_X_INSTINIT) + BBLOCK( SAVE_PAIR_X_WRITE_INSTINIT) + BBLOCK( SAVE_PAIR_Y_INSTINIT) + BBLOCK( SAVE_PAIR_Y_WRITE_INSTINIT) + BBLOCK( SAVE_APPL_X_INSTINIT) + BBLOCK( SAVE_APPL_X_WRITE_INSTINIT) + BBLOCK( SAVE_APPL_Y_INSTINIT) + BBLOCK( SAVE_APPL_Y_WRITE_INSTINIT) +/** Instructions for implemeting 'or' **/ + BBLOCK( JUMP_INSTINIT) + BBLOCK( MOVE_BACK_INSTINIT) + BBLOCK( SKIP_INSTINIT) + BBLOCK( EITHER_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( EITHER_LOW_LEVEL_TRACER) +#endif + BBLOCK( EITHER_POST_COROUTINING) + BBLOCK( EITHER_FROZEN_YSBA) + BBLOCK( EITHER_POST_FROZEN_YSBA) +#ifdef YAPOR + BBLOCK( EITHER_YAPOR) +#endif + BBLOCK( EITHER_END) + BBLOCK( OR_ELSE_INSTINIT) +#ifdef DEPTH_LIMIT + BBLOCK( OR_ELSE_DEPTH) +#endif + BBLOCK( OR_ELSE_POST_DEPTH) +#ifdef YAPOR + BBLOCK( OR_ELSE_YAPOR) +#endif + BBLOCK( OR_ELSE_END) + BBLOCK( OR_LAST_INSTINIT) +#ifdef YAPOR + BBLOCK( OR_LAST_IFOK_INIT) +#ifdef DEPTH_LIMIT + BBLOCK( OR_LAST_IFOK_DEPTH) +#endif + BBLOCK( OR_LAST_IFOK_END) +#endif + BBLOCK( OR_LAST_NOIF_INIT) +#ifdef DEPTH_LIMIT + BBLOCK( OR_LAST_NOIF_DEPTH) +#endif + BBLOCK( OR_LAST_NOIF_END) +#ifdef YAPOR + BBLOCK( OR_LAST_YAPOR) +#else + BBLOCK( OR_LAST_NOYAPOR) +#endif + BBLOCK( OR_LAST_END) +/** Pop operations **/ + BBLOCK( POP_N_INSTINIT) + BBLOCK( POP_N_END) + BBLOCK( POP_INSTINIT) + BBLOCK( POP_END) +/** Call C predicates instructions **/ + BBLOCK( CALL_CPRED_INSTINIT) + BBLOCK( CALL_CPRED_TEST_STACK) +#ifdef FROZEN_STACKS + BBLOCK( CALL_CPRED_FROZEN_INIT) + BBLOCK( CALL_CPRED_TOPB) +#else + BBLOCK( CALL_CPRED_NOFROZEN) +#endif +#ifdef LOW_LEVEL_TRACER + BBLOCK( CALL_CPRED_LOW_LEVEL_TRACER) +#endif + BBLOCK( CALL_CPRED_POST_LOW_LEVEL_TRACER) +#ifdef SHADOW_S + BBLOCK( CALL_CPRED_SETSREG) +#endif + BBLOCK( CALL_CPRED_END) + BBLOCK( EXECUTE_CPRED_INSTINIT) + BBLOCK( EXECUTE_CPRED_POST_CHECK_TRAIL) +#ifdef FROZEN_STACKS + BBLOCK( EXECUTE_CPRED_FROZEN) + BBLOCK( EXECUTE_CPRED_TOPB) +#else + BBLOCK( EXECUTE_CPRED_NOFROZEN) +#endif + BBLOCK( EXECUTE_CPRED_POST_FROZEN) +#ifdef LOW_LEVEL_TRACER + BBLOCK( EXECUTE_CPRED_LOW_LEVEL_TRACER) +#endif + BBLOCK( EXECUTE_CPRED_POST_LOW_LEVEL_TRACER) + BBLOCK( EXECUTE_CPRED_SAVE_PC) +#ifdef DEPTH_LIMIT + BBLOCK( EXECUTE_CPRED_DEPTH_MINOR) + BBLOCK( EXECUTE_CPRED_DEPTH_MOFPRED) + BBLOCK( EXECUTE_CPRED_DEPTH_END) +#endif + BBLOCK( EXECUTE_CPRED_END) + BBLOCK( CALL_USERCPRED_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( CALL_USERCPRED_LOW_LEVEL_TRACER) +#endif + BBLOCK( CALL_USERCPRED_FROZEN) + BBLOCK( CALL_USERCPRED_POST_FROZEN) + BBLOCK( CALL_USERCPRED_END) +/** support instructions **/ + BBLOCK( LOCK_PRED_INSTINIT) + BBLOCK( LOCK_PRED_FIRSTIFOK) + BBLOCK( LOCK_PRED_SECONDTIFOK) + BBLOCK( LOCK_PRED_END) + BBLOCK( INDEX_PRED_INSTINIT) + BBLOCK( INDEX_PRED_END) +#if THREADS + BBLOCK( THREAD_LOCAL_INSTINIT) +#endif + BBLOCK( EXPAND_INDEX_INSTINIT) +#if defined(YAPOR) || defined(THREADS) + BBLOCK( EXPAND_INDEX_YAPOR_THREADS_NOPP) + BBLOCK( EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT) + BBLOCK( EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK) + BBLOCK( EXPAND_INDEX_YAPOR_THREADS_IFOK_END) +#endif +#ifdef SHADOW_S + BBLOCK( EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS) +#endif + BBLOCK( EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS) +#ifdef SHADOW_S + BBLOCK( EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG) +#endif + BBLOCK( EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG) +#if defined(YAPOR) || defined(THREADS) + BBLOCK( EXPAND_INDEX_UNLOCK) +#endif + BBLOCK( EXPAND_INDEX_END) + BBLOCK( EXPAND_CLAUSES_INSTINIT) +#if defined(YAPOR) || defined(THREADS) + BBLOCK( EXPAND_CLAUSES_YAPOR_THREADS_NOPP) + BBLOCK( EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT) + BBLOCK( EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK) + BBLOCK( EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END) +#endif + BBLOCK( EXPAND_CLAUSES_NOYAPOR_NOTHREADS) +#if defined(YAPOR) || defined(THREADS) + BBLOCK( EXPAND_CLAUSES_UNLOCK) +#endif + BBLOCK( EXPAND_CLAUSES_END) + BBLOCK( UNDEF_P_INSTINIT) + BBLOCK( UNDEF_P_END) + BBLOCK( SPY_PRED_INSTINIT) + BBLOCK( SPY_PRED_FIRSTIFOK) + BBLOCK( SPY_PRED_SECONDIFOK_INIT) + BBLOCK( SPY_PRED_SECONDIFOK_FIRSTIFOK) + BBLOCK( SPY_PRED_SECONDIFOK_POST_FIRSTIF) + BBLOCK( SPY_PRED_SECONDIFOK_SECONDIFOK) + BBLOCK( SPY_PRED_SECONDIFOK_THIRDIFOK) + BBLOCK( SPY_PRED_THIRDIFOK_INIT) + BBLOCK( SPY_PRED_THIRDIFOK_FIRSTIFOK) + BBLOCK( SPY_PRED_FOURTHIFOK) + BBLOCK( SPY_PRED_POST_FOURTHIF) + BBLOCK( SPY_PRED_D0ISZERO) + BBLOCK( SPY_PRED_D0ISNOZERO_INIT) + BBLOCK( SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT) + BBLOCK( SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR) + BBLOCK( SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR) + BBLOCK( SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR) + BBLOCK( SPY_PRED_POST_IFS) +#ifdef THREADS + BBLOCK( SPY_PRED_THREADS_LOCK) +#endif + BBLOCK( SPY_PRED_POST_LOCK) +#ifdef THREADS + BBLOCK( SPY_PRED_THREADS_UNLOCK) +#endif + BBLOCK( SPY_PRED_POST_UNLOCK) +#ifdef LOW_LEVEL_TRACER + BBLOCK( SPY_PRED_LOW_LEVEL_TRACER) +#endif + BBLOCK( SPY_PRED_END) +/** Try / Retry / Trust for main indexing blocks **/ + BBLOCK( TRY_CLAUSE_INSTINIT) +#ifdef YAPOR + BBLOCK( TRY_CLAUSE_YAPOR) +#endif + BBLOCK( TRY_CLAUSE_END) + BBLOCK( TRY_CLAUSE2_INSTINIT) +#ifdef YAPOR + BBLOCK( TRY_CLAUSE2_YAPOR) +#endif + BBLOCK( TRY_CLAUSE2_END) + BBLOCK( TRY_CLAUSE3_INSTINIT) +#ifdef YAPOR + BBLOCK( TRY_CLAUSE3_YAPOR) +#endif + BBLOCK( TRY_CLAUSE3_END) + BBLOCK( TRY_CLAUSE4_INSTINIT) +#ifdef YAPOR + BBLOCK( TRY_CLAUSE4_YAPOR) +#endif + BBLOCK( TRY_CLAUSE4_END) + BBLOCK( RETRY_INSTINIT) +#ifdef FROZEN_STACKS + BBLOCK( RETRY_FROZEN) +#else + BBLOCK( RETRY_NOFROZEN) +#endif + BBLOCK( RETRY_END) + BBLOCK( RETRY2_INSTINIT) +#ifdef FROZEN_STACKS + BBLOCK( RETRY2_FROZEN) +#else + BBLOCK( RETRY2_NOFROZEN) +#endif + BBLOCK( RETRY2_END) + BBLOCK( RETRY3_INSTINIT) +#ifdef FROZEN_STACKS + BBLOCK( RETRY3_FROZEN) +#else + BBLOCK( RETRY3_NOFROZEN) +#endif + BBLOCK( RETRY3_END) + BBLOCK( RETRY4_INSTINIT) +#ifdef FROZEN_STACKS + BBLOCK( RETRY4_FROZEN) +#else + BBLOCK( RETRY4_NOFROZEN) +#endif + BBLOCK( RETRY4_END) + BBLOCK( TRUST_INSTINIT) +#ifdef YAPOR + BBLOCK( TRUST_IFOK_INIT) +#ifdef FROZEN_STACKS + BBLOCK( TRUST_IFOK_FROZEN) +#endif + BBLOCK( TRUST_IFOK_END) +#endif + BBLOCK( TRUST_NOIF_INIT) +#ifdef FROZEN_STACKS + BBLOCK( TRUST_NOIF_FROZEN) +#endif + BBLOCK( TRUST_END) + BBLOCK( TRY_IN_INSTINIT) + BBLOCK( TRY_IN_END) +/** Logical Updates **/ +// JIT does not support) +/** Indexing in ARG1 **/ + BBLOCK( USER_SWITCH_INSTINIT) + BBLOCK( USER_SWITCH_END) + BBLOCK( SWITCH_ON_TYPE_INSTINIT) + BBLOCK( SWITCH_ON_TYPE_END) + BBLOCK( SWITCH_LIST_NL_INSTINIT) + BBLOCK( SWITCH_LIST_NL_END) + BBLOCK( SWITCH_ON_ARG_TYPE_INSTINIT) + BBLOCK( SWITCH_ON_ARG_TYPE_END) + BBLOCK( SWITCH_ON_SUB_ARG_TYPE_INSTINIT) + BBLOCK( SWITCH_ON_SUB_ARG_TYPE_END) + BBLOCK( JUMP_IF_VAR_INSTINIT) + BBLOCK( JUMP_IF_VAR_END) + BBLOCK( JUMP_IF_NONVAR_INSTINIT) + BBLOCK( JUMP_IF_NONVAR_END) + BBLOCK( IF_NOT_THEN_INSTINIT) + BBLOCK( IF_NOT_THEN_END) +/** Indexing on ARG1 **/ + BBLOCK( SWITCH_ON_FUNC_INSTINIT) + BBLOCK( SWITCH_ON_FUNC_END) + BBLOCK( SWITCH_ON_CONS_INSTINIT) + BBLOCK( SWITCH_ON_CONS_END) + BBLOCK( GO_ON_FUNC_INSTINIT) + BBLOCK( GO_ON_FUNC_END) + BBLOCK( GO_ON_CONS_INSTINIT) + BBLOCK( GO_ON_CONS_END) + BBLOCK( IF_FUNC_INSTINIT) + BBLOCK( IF_FUNC_END) + BBLOCK( IF_CONS_INSTINIT) + BBLOCK( IF_CONS_END) + BBLOCK( INDEX_DBREF_INSTINIT) + BBLOCK( INDEX_DBREF_END) + BBLOCK( INDEX_BLOB_INSTINIT) + BBLOCK( INDEX_BLOB_END) + BBLOCK( INDEX_LONG_INSTINIT) + BBLOCK( INDEX_LONG_END) +/** Native **/ + BBLOCK( JIT_HANDLER_INSTINIT) +/** Basic Primitive Predicates **/ + BBLOCK( P_ATOM_X_INSTINIT) + BBLOCK( P_ATOM_X_ATOM) + BBLOCK( P_ATOM_X_NOATOM) + BBLOCK( P_ATOM_Y_INSTINIT) + BBLOCK( P_ATOM_Y_IFOK) + BBLOCK( P_ATOM_Y_NOIF) + BBLOCK( P_ATOM_Y_END) + BBLOCK( P_ATOMIC_X_INSTINIT) + BBLOCK( P_ATOMIC_X_NONVAR) + BBLOCK( P_ATOMIC_X_VAR) + BBLOCK( P_ATOMIC_X_END) + BBLOCK( P_ATOMIC_Y_INSTINIT) + BBLOCK( P_ATOMIC_Y_NONVAR) + BBLOCK( P_ATOMIC_Y_VAR) + BBLOCK( P_ATOMIC_Y_END) + BBLOCK( P_INTEGER_X_INSTINIT) + BBLOCK( P_INTEGER_X_INTEGER_X_NVAR_OK) + BBLOCK( P_INTEGER_X_INTEGER_X_NVAR_NOOK) + BBLOCK( P_INTEGER_X_INTEGER_X_UNK) + BBLOCK( P_INTEGER_Y_INSTINIT) + BBLOCK( P_INTEGER_Y_INTEGER_Y_NVAR_OK) + BBLOCK( P_INTEGER_Y_INTEGER_Y_NVAR_NOOK) + BBLOCK( P_INTEGER_Y_INTEGER_Y_UNK) + BBLOCK( P_NONVAR_X_INSTINIT) + BBLOCK( P_NONVAR_X_NONVAR) + BBLOCK( P_NONVAR_X_NONONVAR) + BBLOCK( P_NONVAR_Y_INSTINIT) + BBLOCK( P_NONVAR_Y_NONVAR) + BBLOCK( P_NONVAR_Y_NONONVAR) + BBLOCK( P_NUMBER_X_INSTINIT) + BBLOCK( P_NUMBER_X_INT) + BBLOCK( P_NUMBER_X_FUNCTORINT) + BBLOCK( P_NUMBER_X_FUNCTORDEFAULT) + BBLOCK( P_NUMBER_X_POST_IF) + BBLOCK( P_NUMBER_X_NUMBER_X_UNK) + BBLOCK( P_NUMBER_Y_INSTINIT) + BBLOCK( P_NUMBER_Y_INT) + BBLOCK( P_NUMBER_Y_FUNCTORINT) + BBLOCK( P_NUMBER_Y_FUNCTORDEFAULT) + BBLOCK( P_NUMBER_Y_POST_IF) + BBLOCK( P_NUMBER_Y_NUMBER_Y_UNK) + BBLOCK( P_VAR_X_INSTINIT) + BBLOCK( P_VAR_X_NONVAR) + BBLOCK( P_VAR_X_VAR) + BBLOCK( P_VAR_Y_INSTINIT) + BBLOCK( P_VAR_Y_NONVAR) + BBLOCK( P_VAR_Y_VAR) + BBLOCK( P_DB_REF_X_INSTINIT) + BBLOCK( P_DB_REF_X_DBREF) + BBLOCK( P_DB_REF_X_NODBREF) + BBLOCK( P_DB_REF_X_DBREF_X_UNK) + BBLOCK( P_DB_REF_Y_INSTINIT) + BBLOCK( P_DB_REF_Y_DBREF) + BBLOCK( P_DB_REF_Y_NODBREF) + BBLOCK( P_DB_REF_Y_DBREF_Y_UNK) + BBLOCK( P_PRIMITIVE_X_INSTINIT) + BBLOCK( P_PRIMITIVE_X_PRIMITIVE) + BBLOCK( P_PRIMITIVE_X_NOPRIMITIVE) + BBLOCK( P_PRIMITIVE_X_PRIMI_X_UNK) + BBLOCK( P_PRIMITIVE_Y_INSTINIT) + BBLOCK( P_PRIMITIVE_Y_PRIMITIVE) + BBLOCK( P_PRIMITIVE_Y_NOPRIMITIVE) + BBLOCK( P_PRIMITIVE_Y_PRIMI_Y_UNK) + BBLOCK( P_COMPOUND_X_INSTINIT) + BBLOCK( P_COMPOUND_X_PAIR) + BBLOCK( P_COMPOUND_X_APPL_IFOK) + BBLOCK( P_COMPOUND_X_APPL) + BBLOCK( P_COMPOUND_X_NOAPPL) + BBLOCK( P_COMPOUND_X_COMPOUND_X_UNK) + BBLOCK( P_COMPOUND_Y_INSTINIT) + BBLOCK( P_COMPOUND_Y_PAIR) + BBLOCK( P_COMPOUND_Y_APPL_IFOK) + BBLOCK( P_COMPOUND_Y_APPL) + BBLOCK( P_COMPOUND_Y_NOAPPL) + BBLOCK( P_COMPOUND_Y_COMPOUND_Y_UNK) + BBLOCK( P_FLOAT_X_INSTINIT) + BBLOCK( P_FLOAT_X_FLOAT) + BBLOCK( P_FLOAT_X_POST_IF) + BBLOCK( P_FLOAT_X_FLOAT_X_UNK) + BBLOCK( P_FLOAT_Y_INSTINIT) + BBLOCK( P_FLOAT_Y_FLOAT) + BBLOCK( P_FLOAT_Y_POST_IF) + BBLOCK( P_FLOAT_Y_FLOAT_Y_UNK) + BBLOCK( P_PLUS_VV_INSTINIT) + BBLOCK( P_PLUS_VV_PLUS_VV_NVAR) + BBLOCK( P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT) + BBLOCK( P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT) + BBLOCK( P_PLUS_VV_PLUS_VV_UNK) + BBLOCK( P_PLUS_VV_PLUS_VV_NVAR_UNK) + BBLOCK( P_PLUS_VC_INSTINIT) + BBLOCK( P_PLUS_VC_PLUS_VC_NVAR_INT) + BBLOCK( P_PLUS_VC_PLUS_VC_NVAR_NOINT) + BBLOCK( P_PLUS_VC_PLUS_VC_UNK) + BBLOCK( P_PLUS_Y_VV_INSTINIT) + BBLOCK( P_PLUS_Y_VV_PLUS_Y_VV_NVAR) + BBLOCK( P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT) + BBLOCK( P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT) + BBLOCK( P_PLUS_Y_VV_PLUS_Y_VV_UNK) + BBLOCK( P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK) + BBLOCK( P_PLUS_Y_VC_INSTINIT) + BBLOCK( P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT) + BBLOCK( P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT) + BBLOCK( P_PLUS_Y_VC_PLUS_Y_VC_UNK) + BBLOCK( P_MINUS_VV_INSTINIT) + BBLOCK( P_MINUS_VV_MINUS_VV_NVAR) + BBLOCK( P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT) + BBLOCK( P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT) + BBLOCK( P_MINUS_VV_MINUS_VV_UNK) + BBLOCK( P_MINUS_VV_MINUS_VV_NVAR_UNK) + BBLOCK( P_MINUS_CV_INSTINIT) + BBLOCK( P_MINUS_CV_MINUS_CV_NVAR_INT) + BBLOCK( P_MINUS_CV_MINUS_CV_NVAR_NOINT) + BBLOCK( P_MINUS_CV_MINUS_CV_UNK) + BBLOCK( P_MINUS_Y_VV_INSTINIT) + BBLOCK( P_MINUS_Y_VV_MINUS_Y_VV_NVAR) + BBLOCK( P_MINUS_Y_VV_INTTERM) + BBLOCK( P_MINUS_Y_VV_NOINTTERM) + BBLOCK( P_MINUS_Y_VV_D0EQUALS0L) + BBLOCK( P_MINUS_Y_VV_NVAR_END) + BBLOCK( P_MINUS_Y_VV_MINUS_Y_VV_UNK) + BBLOCK( P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK) + BBLOCK( P_MINUS_Y_CV_INSTINIT) + BBLOCK( P_MINUS_Y_CV_MINUS_Y_CV_NVAR) + BBLOCK( P_MINUS_Y_CV_INTTERM) + BBLOCK( P_MINUS_Y_CV_NOINTTERM) + BBLOCK( P_MINUS_Y_CV_D0EQUALS0L) + BBLOCK( P_MINUS_Y_CV_NVAR_END) + BBLOCK( P_MINUS_Y_CV_MINUS_Y_CV_UNK) + BBLOCK( P_TIMES_VV_INSTINIT) + BBLOCK( P_TIMES_VV_TIMES_VV_NVAR) + BBLOCK( P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT) + BBLOCK( P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT) + BBLOCK( P_TIMES_VV_TIMES_VV_UNK) + BBLOCK( P_TIMES_VV_TIMES_VV_NVAR_UNK) + BBLOCK( P_TIMES_VC_INSTINIT) + BBLOCK( P_TIMES_VC_TIMES_VC_NVAR_INT) + BBLOCK( P_TIMES_VC_TIMES_VC_NVAR_NOINT) + BBLOCK( P_TIMES_VC_TIMES_VC_UNK) + BBLOCK( P_TIMES_Y_VV_INSTINIT) + BBLOCK( P_TIMES_Y_VV_TIMES_Y_VV_NVAR) + BBLOCK( P_TIMES_Y_VV_INTTERM) + BBLOCK( P_TIMES_Y_VV_NOINTTERM) + BBLOCK( P_TIMES_Y_VV_D0EQUALS0L) + BBLOCK( P_TIMES_Y_VV_NVAR_END) + BBLOCK( P_TIMES_Y_VV_TIMES_Y_VV_UNK) + BBLOCK( P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK) + BBLOCK( P_TIMES_Y_VC_INSTINIT) + BBLOCK( P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT) + BBLOCK( P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT) + BBLOCK( P_TIMES_Y_VC_NVAR_END) + BBLOCK( P_TIMES_Y_VC_TIMES_Y_VC_UNK) + BBLOCK( P_DIV_VV_INSTINIT) + BBLOCK( P_DIV_VV_DIV_VV_NVAR) + BBLOCK( P_DIV_VV_DIV_VV_NVAR_NVAR_INT) + BBLOCK( P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT) + BBLOCK( P_DIV_VV_DIV_VV_UNK) + BBLOCK( P_DIV_VV_DIV_VV_NVAR_UNK) + BBLOCK( P_DIV_VC_INSTINIT) + BBLOCK( P_DIV_VC_DIV_VC_NVAR) + BBLOCK( P_DIV_VC_INTTERM) + BBLOCK( P_DIV_VC_NOINTTERM) + BBLOCK( P_DIV_VC_D0EQUALS0L) + BBLOCK( P_DIV_VC_NVAR_END) + BBLOCK( P_DIV_VC_DIV_VC_UNK) + BBLOCK( P_DIV_CV_INSTINIT) + BBLOCK( P_DIV_CV_DIV_CV_NVAR) + BBLOCK( P_DIV_CV_INTTERM_INIT) + BBLOCK( P_DIV_CV_INTTERM_DIVEQUALS0) + BBLOCK( P_DIV_CV_INTTERM_END) + BBLOCK( P_DIV_CV_NOINTTERM) + BBLOCK( P_DIV_CV_D0EQUALS0L) + BBLOCK( P_DIV_CV_NVAR_END) + BBLOCK( P_DIV_CV_DIV_CV_UNK) + BBLOCK( P_DIV_Y_VV_INSTINIT) + BBLOCK( P_DIV_Y_VV_DIV_Y_VV_NVAR) + BBLOCK( P_DIV_Y_VV_INTTERM_INIT) + BBLOCK( P_DIV_Y_VV_INTTERM_DIVEQUALS0) + BBLOCK( P_DIV_Y_VV_INTTERM_END) + BBLOCK( P_DIV_Y_VV_NOINTTERM) + BBLOCK( P_DIV_Y_VV_D0EQUALS0L) + BBLOCK( P_DIV_Y_VV_NVAR_END) + BBLOCK( P_DIV_Y_VV_DIV_Y_VV_UNK) + BBLOCK( P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK) + BBLOCK( P_DIV_Y_VC_INSTINIT) + BBLOCK( P_DIV_Y_VC_DIV_Y_VC_NVAR) + BBLOCK( P_DIV_Y_VC_INTTERM) + BBLOCK( P_DIV_Y_VC_NOINTTERM) + BBLOCK( P_DIV_Y_VC_D0EQUALS0L) + BBLOCK( P_DIV_Y_VC_NVAR_END) + BBLOCK( P_DIV_Y_VC_DIV_Y_VC_UNK) + BBLOCK( P_DIV_Y_CV_INSTINIT) + BBLOCK( P_DIV_Y_CV_DIV_Y_CV_NVAR) + BBLOCK( P_DIV_Y_CV_INTTERM_INIT) + BBLOCK( P_DIV_Y_CV_INTTERM_DIVEQUALS0) + BBLOCK( P_DIV_Y_CV_INTTERM_END) + BBLOCK( P_DIV_Y_CV_NOINTTERM) + BBLOCK( P_DIV_Y_CV_D0EQUALS0L) + BBLOCK( P_DIV_Y_CV_NVAR_END) + BBLOCK( P_DIV_Y_CV_DIV_Y_CV_UNK) + BBLOCK( P_AND_VV_INSTINIT) + BBLOCK( P_AND_VV_AND_VV_NVAR) + BBLOCK( P_AND_VV_AND_VV_NVAR_NVAR_INT) + BBLOCK( P_AND_VV_AND_VV_NVAR_NVAR_NOINT) + BBLOCK( P_AND_VV_AND_VV_UNK) + BBLOCK( P_AND_VV_AND_VV_NVAR_UNK) + BBLOCK( P_AND_VC_INSTINIT) + BBLOCK( P_AND_VC_AND_VC_NVAR_INT) + BBLOCK( P_AND_VC_AND_VC_NVAR_NOINT) + BBLOCK( P_AND_VC_AND_VC_UNK) + BBLOCK( P_AND_Y_VV_INSTINIT) + BBLOCK( P_AND_Y_VV_AND_Y_VV_NVAR) + BBLOCK( P_AND_Y_VV_INTTERM) + BBLOCK( P_AND_Y_VV_NOINTTERM) + BBLOCK( P_AND_Y_VV_D0EQUALS0L) + BBLOCK( P_AND_Y_VV_NVAR_END) + BBLOCK( P_AND_Y_VV_AND_Y_VV_UNK) + BBLOCK( P_AND_Y_VV_AND_Y_VV_NVAR_UNK) + BBLOCK( P_AND_Y_VC_INSTINIT) + BBLOCK( P_AND_Y_VC_AND_Y_VC_NVAR) + BBLOCK( P_AND_Y_VC_INTTERM) + BBLOCK( P_AND_Y_VC_NOINTTERM) + BBLOCK( P_AND_Y_VC_D0EQUALS0L) + BBLOCK( P_AND_Y_VC_NVAR_END) + BBLOCK( P_AND_Y_VC_AND_Y_VC_UNK) + BBLOCK( P_OR_VV_INSTINIT) + BBLOCK( P_OR_VV_OR_VV_NVAR) + BBLOCK( P_OR_VV_INTTERM) + BBLOCK( P_OR_VV_NOINTTERM) + BBLOCK( P_OR_VV_D0EQUALS0L) + BBLOCK( P_OR_VV_NVAR_END) + BBLOCK( P_OR_VV_OR_VV_UNK) + BBLOCK( P_OR_VV_OR_VV_NVAR_UNK) + BBLOCK( P_OR_VC_INSTINIT) + BBLOCK( P_OR_VC_OR_VC_NVAR) + BBLOCK( P_OR_VC_INTTERM) + BBLOCK( P_OR_VC_NOINTTERM) + BBLOCK( P_OR_VC_D0EQUALS0L) + BBLOCK( P_OR_VC_NVAR_END) + BBLOCK( P_OR_VC_OR_VC_UNK) + BBLOCK( P_OR_Y_VV_INSTINIT) + BBLOCK( P_OR_Y_VV_OR_Y_VV_NVAR) + BBLOCK( P_OR_Y_VV_INTTERM) + BBLOCK( P_OR_Y_VV_NOINTTERM) + BBLOCK( P_OR_Y_VV_D0EQUALS0L) + BBLOCK( P_OR_Y_VV_NVAR_END) + BBLOCK( P_OR_Y_VV_OR_Y_VV_UNK) + BBLOCK( P_OR_Y_VV_OR_Y_VV_NVAR_UNK) + BBLOCK( P_OR_Y_VC_INSTINIT) + BBLOCK( P_OR_Y_VC_OR_Y_VC_NVAR) + BBLOCK( P_OR_Y_VC_INTTERM) + BBLOCK( P_OR_Y_VC_NOINTTERM) + BBLOCK( P_OR_Y_VC_D0EQUALS0L) + BBLOCK( P_OR_Y_VC_NVAR_END) + BBLOCK( P_OR_Y_VC_OR_Y_VC_UNK) + BBLOCK( P_SLL_VV_INSTINIT) + BBLOCK( P_SLL_VV_SLL_VV_NVAR) + BBLOCK( P_SLL_VV_INTTERM_INIT) + BBLOCK( P_SLL_VV_INTTERM_LESS) + BBLOCK( P_SLL_VV_INTTERM_GREATER) + BBLOCK( P_SLL_VV_NOINTTERM) + BBLOCK( P_SLL_VV_D0EQUALS0L) + BBLOCK( P_SLL_VV_NVAR_END) + BBLOCK( P_SLL_VV_SLL_VV_UNK) + BBLOCK( P_SLL_VV_SLL_VV_NVAR_UNK) + BBLOCK( P_SLL_VC_INSTINIT) + BBLOCK( P_SLL_VC_SLL_VC_NVAR) + BBLOCK( P_SLL_VC_INTTERM) + BBLOCK( P_SLL_VC_NOINTTERM) + BBLOCK( P_SLL_VC_D0EQUALS0L) + BBLOCK( P_SLL_VC_NVAR_END) + BBLOCK( P_SLL_VC_SLL_VC_UNK) + BBLOCK( P_SLL_CV_INSTINIT) + BBLOCK( P_SLL_CV_SLL_CV_NVAR_INT) + BBLOCK( P_SLL_CV_SLL_CV_NVAR_NOINT) + BBLOCK( P_SLL_CV_SLL_CV_UNK) + BBLOCK( P_SLL_Y_VV_INSTINIT) + BBLOCK( P_SLL_Y_VV_SLL_Y_VV_NVAR) + BBLOCK( P_SLL_Y_VV_INTTERM_INIT) + BBLOCK( P_SLL_Y_VV_INTERM_LESS) + BBLOCK( P_SLL_Y_VV_INTTERM_GREATER) + BBLOCK( P_SLL_Y_VV_NOINTTERM) + BBLOCK( P_SLL_Y_VV_D0EQUALS0L) + BBLOCK( P_SLL_Y_VV_NVAR_END) + BBLOCK( P_SLL_Y_VV_SLL_Y_VV_UNK) + BBLOCK( P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK) + BBLOCK( P_SLL_Y_VC_INSTINIT) + BBLOCK( P_SLL_Y_VC_SLL_Y_VC_NVAR) + BBLOCK( P_SLL_Y_VC_INTTERM) + BBLOCK( P_SLL_Y_VC_NOINTTERM) + BBLOCK( P_SLL_Y_VC_D0EQUALS0L) + BBLOCK( P_SLL_Y_VC_NVAR_END) + BBLOCK( P_SLL_Y_VC_SLL_Y_VC_UNK) + BBLOCK( P_SLL_Y_CV_INSTINIT) + BBLOCK( P_SLL_Y_CV_SLL_Y_CV_NVAR) + BBLOCK( P_SLL_Y_CV_INTTERM_INIT) + BBLOCK( P_SLL_Y_CV_INTTERM_LESS) + BBLOCK( P_SLL_Y_CV_INTTERM_GREATER) + BBLOCK( P_SLL_Y_CV_NOINTTERM) + BBLOCK( P_SLL_Y_CV_D0EQUALS0L) + BBLOCK( P_SLL_Y_CV_NVAR_END) + BBLOCK( P_SLL_Y_CV_SLL_Y_CV_UNK) + BBLOCK( P_SLR_VV_INSTINIT) + BBLOCK( P_SLR_VV_SLR_VV_NVAR) + BBLOCK( P_SLR_VV_INTTERM_INIT) + BBLOCK( P_SLR_VV_INTTERM_LESS) + BBLOCK( P_SLR_VV_INTTERM_GREATER) + BBLOCK( P_SLR_VV_NOINTTERM) + BBLOCK( P_SLR_VV_D0EQUALS0L) + BBLOCK( P_SLR_VV_NVAR_END) + BBLOCK( P_SLR_VV_SRL_VV_UNK) + BBLOCK( P_SLR_VV_SRL_VV_NVAR_UNK) + BBLOCK( P_SLR_VC_INSTINIT) + BBLOCK( P_SLR_VC_SLR_VC_NVAR_INT) + BBLOCK( P_SLR_VC_SLR_VC_NVAR_NOINT) + BBLOCK( P_SLR_VC_SRL_VC_UNK) + BBLOCK( P_SLR_CV_INSTINIT) + BBLOCK( P_SLR_CV_SLR_CV_NVAR) + BBLOCK( P_SLR_CV_INTTERM_INIT) + BBLOCK( P_SLR_CV_INTTERM_LESS) + BBLOCK( P_SLR_CV_INTTERM_GREATER) + BBLOCK( P_SLR_CV_NOINTTERM) + BBLOCK( P_SLR_CV_D0EQUALS0L) + BBLOCK( P_SLR_CV_NVAR_END) + BBLOCK( P_SLR_CV_SLR_CV_UNK) + BBLOCK( P_SLR_Y_VV_INSTINIT) + BBLOCK( P_SLR_Y_VV_SLR_Y_VV_NVAR) + BBLOCK( P_SLR_Y_VV_INTTERM_INIT) + BBLOCK( P_SLR_Y_VV_INTTERM_LESS) + BBLOCK( P_SLR_Y_VV_INTTERM_GREATER) + BBLOCK( P_SLR_Y_VV_NOINTTERM) + BBLOCK( P_SLR_Y_VV_D0EQUALS0L) + BBLOCK( P_SLR_Y_VV_NVAR_END) + BBLOCK( P_SLR_Y_VV_SLR_Y_VV_UNK) + BBLOCK( P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK) + BBLOCK( P_SLR_Y_VC_INSTINIT) + BBLOCK( P_SLR_Y_VC_SLR_Y_VC_NVAR) + BBLOCK( P_SLR_Y_VC_INTTERM) + BBLOCK( P_SLR_Y_VC_NOINTTERM) + BBLOCK( P_SLR_Y_VC_D0EQUALS0L) + BBLOCK( P_SLR_Y_VC_NVAR_END) + BBLOCK( P_SLR_Y_VC_SLR_Y_VC_UNK) + BBLOCK( P_SLR_Y_CV_INSTINIT) + BBLOCK( P_SLR_Y_CV_SLR_Y_CV_NVAR) + BBLOCK( P_SLR_Y_CV_INTTERM_INIT) + BBLOCK( P_SLR_Y_CV_INTTERM_LESS) + BBLOCK( P_SLR_Y_CV_INTTERM_GREATER) + BBLOCK( P_SLR_Y_CV_NOINTTERM) + BBLOCK( P_SLR_Y_CV_D0EQUALS0L) + BBLOCK( P_SLR_Y_CV_NVAR_END) + BBLOCK( P_SLR_Y_CV_SLR_Y_CV_UNK) + BBLOCK( CALL_BFUNC_XX_INSTINIT) + BBLOCK( CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR) + BBLOCK( CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT) + BBLOCK( CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT) + BBLOCK( CALL_BFUNC_XX_CALL_BFUNC_XX_UNK) + BBLOCK( CALL_BFUNC_YX_INSTINIT) + BBLOCK( CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT) + BBLOCK( CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT) + BBLOCK( CALL_BFUNC_YX_CALL_BFUNC_YX_UNK) + BBLOCK( CALL_BFUNC_XY_INSTINIT) + BBLOCK( CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT) + BBLOCK( CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT) + BBLOCK( CALL_BFUNC_XY_CALL_BFUNC_XY_UNK) + BBLOCK( CALL_BFUNC_YY_INSTINIT) + BBLOCK( CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT) + BBLOCK( CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT) + BBLOCK( CALL_BFUNC_YY_CALL_BFUNC_YY_UNK) + BBLOCK( P_EQUAL_INSTINIT) + BBLOCK( P_EQUAL_END) + BBLOCK( P_DIF_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_DIF_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_DIF_POST_LOW_LEVEL_TRACER) + BBLOCK( P_DIF_DIF_NVAR1) + BBLOCK( P_DIF_DIF_NVAR1_NVAR2) + BBLOCK( P_DIF_DIF_UNK1) + BBLOCK( P_DIF_DIF_NVAR1_UNK2) + BBLOCK( P_EQ_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_EQ_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_EQ_POST_LOW_LEVEL_TRACER) + BBLOCK( P_EQ_P_EQ_NVAR1) + BBLOCK( P_EQ_P_EQ_NVAR1_NVAR2) + BBLOCK( P_EQ_P_EQ_NVAR1_UNK2) + BBLOCK( P_EQ_P_EQ_UNK1) + BBLOCK( P_EQ_P_EQ_VAR1_NVAR2) + BBLOCK( P_EQ_P_EQ_VAR1_UNK2_END) + BBLOCK( P_ARG_VV_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_ARG_VV_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_ARG_VV_TEST_D0) + BBLOCK( P_ARG_VV_ARG_ARG1_NVAR) + BBLOCK( P_ARG_VV_TEST_D1) + BBLOCK( P_ARG_VV_ARG_ARG2_NVAR) + BBLOCK( P_ARG_VV_ARG_ARG2_UNK) + BBLOCK( P_ARG_VV_ARG_ARG1_UNK) + BBLOCK( P_ARG_CV_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_ARG_CV_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_ARG_CV_TEST_D1) + BBLOCK( P_ARG_CV_ARG_ARG2_VC_NVAR) + BBLOCK( P_ARG_CV_ARG_ARG2_VC_UNK) + BBLOCK( P_ARG_Y_VV_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_ARG_Y_VV_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_ARG_Y_VV_TEST_D0) + BBLOCK( P_ARG_Y_VV_ARG_Y_ARG1_NVAR) + BBLOCK( P_ARG_Y_VV_TEST_D1) + BBLOCK( P_ARG_Y_VV_ARG_Y_ARG2_NVAR) + BBLOCK( P_ARG_Y_VV_ARG_Y_ARG2_UNK) + BBLOCK( P_ARG_Y_VV_ARG_Y_ARG1_UNK) + BBLOCK( P_ARG_Y_CV_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_ARG_Y_CV_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_ARG_Y_CV_TEST_D1) + BBLOCK( P_ARG_Y_CV_D1APPL_INIT) + BBLOCK( P_ARG_Y_CV_D1APPL_END) + BBLOCK( P_ARG_Y_CV_D1PAIR_INIT) + BBLOCK( P_ARG_Y_CV_D1PAIR_LESS0) + BBLOCK( P_ARG_Y_CV_D1PAIR_END) + BBLOCK( P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK) + BBLOCK( P_FUNCTOR_INSTINIT) + BBLOCK( P_FUNCTOR_END) + BBLOCK( P_FUNC2S_VV_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2S_VV_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2S_TEST_D0) + BBLOCK( P_FUNC2S_VV_TEST_D1) + BBLOCK( P_FUNC2S_VV_D1INT) + BBLOCK( P_FUNC2S_VV_D1NOTINT) + BBLOCK( P_FUNC2S_VV_D1BIGINT) + BBLOCK( P_FUNC2S_VV_D1NOTBIGINT) + BBLOCK( P_FUNC2S_VV_D1NOTINT_END) + BBLOCK( P_FUNC2S_VV_D0NOTATOMIC) + BBLOCK( P_FUNC2S_VV_FIRSTIFOK) + BBLOCK( P_FUNC2S_VV_SECONDIFOK_D0NOTATOM) + BBLOCK( P_FUNC2S_VV_SECONDIFOK_D0ATOM) + BBLOCK( P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM) + BBLOCK( P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT) + BBLOCK( P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK) + BBLOCK( P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF) + BBLOCK( P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE) + BBLOCK( P_FUNC2S_VV_SECONDIFOK_END) + BBLOCK( P_FUNC2S_VV_THIRDIFOK) + BBLOCK( P_FUNC2S_VV_ELSE) + BBLOCK( P_FUNC2S_VV_FUNC2S_UNK2) + BBLOCK( P_FUNC2S_VV_FUNC2S_UNK) + BBLOCK( P_FUNC2S_CV_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2S_CV_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2S_CV_TEST_D1) + BBLOCK( P_FUNC2S_CV_D1INT) + BBLOCK( P_FUNC2S_CV_D1NOTINT) + BBLOCK( P_FUNC2S_CV_D1NOINT_D1BIGINT) + BBLOCK( P_FUNC2S_CV_D1NOTBIGINT) + BBLOCK( P_FUNC2S_CV_POST_IF) + BBLOCK( P_FUNC2S_CV_FIRSTIFOK) + BBLOCK( P_FUNC2S_CV_D1GREATER_D0NOTATOM) + BBLOCK( P_FUNC2S_CV_D1GREATER_D0ATOM) + BBLOCK( P_FUNC2S_CV_D1GREATER_POST_IF) + BBLOCK( P_FUNC2S_CV_D1GREATER_IFOK_INIT) + BBLOCK( P_FUNC2S_CV_D1GREATER_IFOK_IFOK) + BBLOCK( P_FUNC2S_CV_D1GREATER_IFOK_NOIF) + BBLOCK( P_FUNC2S_CV_D1GREATER_INSIDEWHILE) + BBLOCK( P_FUNC2S_CV_D1GREATER_END) + BBLOCK( P_FUNC2S_CV_D1ISZERO) + BBLOCK( P_FUNC2S_CV_ELSE) + BBLOCK( P_FUNC2S_CV_END) + BBLOCK( P_FUNC2S_VC_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2S_VC_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2S_VC_TEST_D0) + BBLOCK( P_FUNC2S_VC_FUNC2S_NVAR_VC) + BBLOCK( P_FUNC2S_VC_D0NOATOMIC) + BBLOCK( P_FUNC2S_VC_EQUALS) + BBLOCK( P_FUNC2S_VC_D1ISZERO) + BBLOCK( P_FUNC2S_VC_D0NOATOM) + BBLOCK( P_FUNC2S_VC_D0ATOM) + BBLOCK( P_FUNC2S_VC_POST_ELSE) + BBLOCK( P_FUNC2S_VC_IFOK_INIT) + BBLOCK( P_FUNC2S_VC_IFOK_IFOK) + BBLOCK( P_FUNC2S_VC_IFOK_NOIF) + BBLOCK( P_FUNC2S_VC_INSIDEWHILE) + BBLOCK( P_FUNC2S_VC_END1) + BBLOCK( P_FUNC2S_VC_END2) + BBLOCK( P_FUNC2S_Y_VV_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2S_Y_VV_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2S_Y_VV_TEST_D0) + BBLOCK( P_FUNC2S_Y_VV_TEST_D1) + BBLOCK( P_FUNC2S_Y_VV_D1INT) + BBLOCK( P_FUNC2S_Y_VV_D1NOTINT) + BBLOCK( P_FUNC2S_Y_VV_D1BIGINT) + BBLOCK( P_FUNC2S_Y_VV_D1NOTBIGINT) + BBLOCK( P_FUNC2S_Y_VV_POST_IF) + BBLOCK( P_FUNC2S_Y_VV_D0NOATOMIC) + BBLOCK( P_FUNC2S_Y_VV_EQUALS) + BBLOCK( P_FUNC2S_Y_VV_D1GREATER_D0NOATOM) + BBLOCK( P_FUNC2S_Y_VV_D1GREATER_D0ATOM) + BBLOCK( P_FUNC2S_Y_VV_D1GREATER_POST_ELSE) + BBLOCK( P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT) + BBLOCK( P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK) + BBLOCK( P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF) + BBLOCK( P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE) + BBLOCK( P_FUNC2S_Y_VV_D1GREATER_END) + BBLOCK( P_FUNC2S_Y_VV_D1ISZERO) + BBLOCK( P_FUNC2S_Y_VV_ELSE) + BBLOCK( P_FUNC2S_Y_VV_END1) + BBLOCK( P_FUNC2S_Y_VV_END2) + BBLOCK( P_FUNC2S_Y_CV_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2S_Y_CV_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2S_Y_CV_TEST_D1) + BBLOCK( P_FUNC2S_Y_CV_D1INT) + BBLOCK( P_FUNC2S_Y_CV_D1NOTINT) + BBLOCK( P_FUNC2S_Y_CV_D1BIGINT) + BBLOCK( P_FUNC2S_Y_CV_D1NOTBIGINT) + BBLOCK( P_FUNC2S_Y_CV_POST_IF) + BBLOCK( P_FUNC2S_Y_CV_EQUALS) + BBLOCK( P_FUNC2S_Y_CV_D1GREATER_D0NOATOM) + BBLOCK( P_FUNC2S_Y_CV_D1GREATER_D0ATOM) + BBLOCK( P_FUNC2S_Y_CV_D1GREATER_POST_ELSE) + BBLOCK( P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT) + BBLOCK( P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK) + BBLOCK( P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF) + BBLOCK( P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE) + BBLOCK( P_FUNC2S_Y_CV_D1GREATER_END) + BBLOCK( P_FUNC2S_Y_CV_D1ISZERO) + BBLOCK( P_FUNC2S_Y_CV_ELSE) + BBLOCK( P_FUNC2S_Y_CV_END) + BBLOCK( P_FUNC2S_Y_VC_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2S_Y_VC_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2S_Y_VC_TEST_D0) + BBLOCK( P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC) + BBLOCK( P_FUNC2S_Y_VC_D0NOATOMIC) + BBLOCK( P_FUNC2S_Y_VC_EQUALS) + BBLOCK( P_FUNC2S_Y_VC_D1ISZERO) + BBLOCK( P_FUNC2S_Y_VC_D0NOATOM1) + BBLOCK( P_FUNC2S_Y_VC_D0NOATOM2) + BBLOCK( P_FUNC2S_Y_VC_D0ATOM) + BBLOCK( P_FUNC2S_Y_VC_POST_ELSE) + BBLOCK( P_FUNC2S_Y_VC_IFOK_INIT) + BBLOCK( P_FUNC2S_Y_VC_IFOK_IFOK) + BBLOCK( P_FUNC2S_Y_VC_IFOK_NOIF) + BBLOCK( P_FUNC2S_Y_VC_INSIDEWHILE) + BBLOCK( P_FUNC2S_Y_VC_END1) + BBLOCK( P_FUNC2S_Y_VC_END2) + BBLOCK( P_FUNC2F_XX_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2F_XX_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2F_XX_TEST_D0) + BBLOCK( P_FUNC2F_XX_D0APPL) + BBLOCK( P_FUNC2F_XX_D0APPL_D1EXTFUNC) + BBLOCK( P_FUNC2F_XX_D0APPL_END) + BBLOCK( P_FUNC2F_XX_D0PAIR) + BBLOCK( P_FUNC2F_XX_D0NOCOMPOUND) + BBLOCK( P_FUNC2F_XX_END) + BBLOCK( P_FUNC2F_XY_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2F_XY_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2F_XY_TEST_D0) + BBLOCK( P_FUNC2F_XY_D0APPL) + BBLOCK( P_FUNC2F_XY_D0APPL_D1EXTFUNC) + BBLOCK( P_FUNC2F_XY_D0APPL_END) + BBLOCK( P_FUNC2F_XY_D0PAIR) + BBLOCK( P_FUNC2F_XY_D0NOCOMPOUND) + BBLOCK( P_FUNC2F_XY_END) + BBLOCK( P_FUNC2F_YX_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2F_YX_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2F_YX_TEST_D0) + BBLOCK( P_FUNC2F_YX_D0APPL) + BBLOCK( P_FUNC2F_YX_D0APPL_D1EXTFUNC) + BBLOCK( P_FUNC2F_YX_D0APPL_END) + BBLOCK( P_FUNC2F_YX_D0PAIR) + BBLOCK( P_FUNC2F_YX_D0NOCOMPOUND) + BBLOCK( P_FUNC2F_YX_END) + BBLOCK( P_FUNC2F_YY_INSTINIT) +#ifdef LOW_LEVEL_TRACER + BBLOCK( P_FUNC2F_YY_LOW_LEVEL_TRACER) +#endif + BBLOCK( P_FUNC2F_YY_TEST_D0) + BBLOCK( P_FUNC2F_YY_D0APPL) + BBLOCK( P_FUNC2F_YY_D0APPL_D1EXTFUNC) + BBLOCK( P_FUNC2F_YY_D0APPL_END) + BBLOCK( P_FUNC2F_YY_D0PAIR) + BBLOCK( P_FUNC2F_YY_D0NOCOMPOUND) + BBLOCK( P_FUNC2F_YY_END) diff --git a/JIT/HPP/Yap_BasicBlocks.h b/JIT/HPP/Yap_BasicBlocks.h new file mode 100644 index 000000000..a8e64b8ac --- /dev/null +++ b/JIT/HPP/Yap_BasicBlocks.h @@ -0,0 +1,1503 @@ + ENTRY, + YAAM_DEREF_BODY_D0PT0, + YAAM_DEREF_BODY_D0PT1, + YAAM_DEREF_BODY_D0S_SREG, + YAAM_DEREF_BODY_D1PT0, + YAAM_DEREF_BODY_D1PT1, + YAAM_FAIL, + YAAM_CHECK_TRAIL_TR, + YAAM_UNIFYBOUND, + NoStackExecute_Exception, + NoStackDExecute_Exception, + NoStackCall_Exception, + NoStackDeallocate_Exception, +#ifdef COROUTINING + NoStackFail_Exception, +#endif + NoStackCut_Exception, + NoStackCutT_Exception, + NoStackCutE_Exception, + NoStackCommitX_Exception, + NoStackCommitY_Exception, + NoStackEither_Exception, + NoStackPExecute_Exception, + NoStackPExecute2_Exception, + NoStackPTExecute_Exception, +/** Plain try, retry, and trust **/ + TRY_ME_INSTINIT, +#ifdef YAPOR + TRY_ME_YAPOR, +#endif + TRY_ME_END, + RETRY_ME_INSTINIT, +#ifdef FROZEN_STACKS + RETRY_ME_FROZEN, +#else + RETRY_ME_NOFROZEN, +#endif + RETRY_ME_END, + TRUST_ME_INSTINIT, + TRUST_ME_IF, + TRUST_ME_END, +/** Profiled try, retry, and trust **/ + ENTER_PROFILING_INSTINIT, + RETRY_PROFILED_INSTINIT, + PROFILED_RETRY_ME_INSTINIT, +#ifdef FROZEN_STACKS + PROFILED_RETRY_ME_FROZEN, +#else + PROFILED_RETRY_ME_NOFROZEN, +#endif + PROFILED_RETRY_ME_END, + PROFILED_TRUST_ME_INSTINIT, + PROFILED_TRUST_ME_IF, + PROFILED_TRUST_ME_END, + PROFILED_RETRY_LOGICAL_INSTINIT, +#ifdef THREADS + PROFILED_RETRY_LOGICAL_THREADS, +#endif + PROFILED_RETRY_LOGICAL_POST_THREADS, +#ifdef FROZEN_STACKS + PROFILED_RETRY_LOGICAL_FROZEN, +#else + PROFILED_RETRY_LOGICAL_NOFROZEN, +#endif + PROFILED_RETRY_LOGICAL_END, + PROFILED_TRUST_LOGICAL_INSTINIT, + PROFILED_TRUST_LOGICAL_END, +/** Call count instructions **/ + COUNT_CALL_INSTINIT, + COUNT_CALL_MIDDLE, + COUNT_CALL_END, + COUNT_RETRY_INSTINIT, + COUNT_RETRY_MIDDLE, + COUNT_RETRY_END, + COUNT_RETRY_ME_INSTINIT, + COUNT_RETRY_ME_MIDDLE, + COUNT_RETRY_ME_END, + COUNT_TRUST_ME_INSTINIT, + COUNT_TRUST_ME_MIDDLE, + COUNT_TRUST_ME_END, + COUNT_RETRY_LOGICAL_INSTINIT, + COUNT_RETRY_LOGICAL_END, + COUNT_TRUST_LOGICAL_INSTINIT, + COUNT_TRUST_LOGICAL_END, +/** enter a logical semantics dynamic predicate **/ + LOCK_LU_INSTINIT, + LOCK_LU_END, + UNLOCK_LU_INSTINIT, +#if defined(YAPOR) || defined(THREADS) + UNLOCK_LU_YAPOR_THREADS, +#endif + UNLOCK_LU_END, + ALLOC_FOR_LOGICAL_PRED_INSTINIT, +#if MULTIPLE_STACKS + ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS, +#if PARALLEL_YAP + ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL, +#endif + ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END, +#else + ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT, + ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF, +#endif + ALLOC_FOR_LOGICAL_PRED_END, + COPY_IDB_TERM_INSTINIT, + COPY_IDB_TERM_END, + UNIFY_IDB_TERM_INSTINIT, + UNIFY_IDB_TERM_END, +/** check for enough room **/ + ENSURE_SPACE_INSTINIT, + ENSURE_SPACE_END, +/** try and retry of dynamic predicates **/ + SPY_OR_TRYMARK_INSTINIT, + TRY_AND_MARK_INSTINIT, +#if defined(YAPOR) || defined(THREADS) +#ifdef YAPOR + TRY_AND_MARK_YAPOR_THREADS_YAPOR, +#endif + TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF, +#endif + TRY_AND_MARK_NOYAPOR_NOTHREADS, +#ifdef YAPOR + TRY_AND_MARK_SET_LOAD, +#endif + TRY_AND_MARK_POST_SET_LOAD, +#if MULTIPLE_STACKS + TRY_AND_MARK_MULTIPLE_STACKS, +#else + TRY_AND_MARK_NOMULTIPLE_STACKS_IF, +#endif + TRY_AND_MARK_END, + COUNT_RETRY_AND_MARK_INSTINIT, + PROFILED_RETRY_AND_MARK_INSTINIT, + RETRY_AND_MARK_INSTINIT, +#ifdef YAPOR + RETRY_AND_MARK_YAPOR, +#endif + RETRY_AND_MARK_POST_YAPOR, +#ifdef FROZEN_STACKS + RETRY_AND_MARK_FROZEN, +#else + RETRY_AND_MARK_NOFROZEN, +#endif + RETRY_AND_MARK_POST_FROZEN, +#if MULTIPLE_STACKS + RETRY_AND_MARK_MULTIPLE_STACKS, +#else + RETRY_AND_MARK_NOMULTIPLE_STACKS_IF, +#endif + RETRY_AND_MARK_END, +/** Failure **/ + TRUST_FAIL_INSTINIT, +#ifdef CUT_C + TRUST_FAIL_CUT_C, +#endif +#ifdef YAPOR + TRUST_FAIL_YAPOR, +#endif + TRUST_FAIL_NOYAPOR, +#ifdef YAPOR + LBL_SHARED_FAIL, +#endif + OP_FAIL_INSTINIT, + LBL_FAIL_INSTINIT, +#ifdef LOW_LEVEL_TRACER + LBL_FAIL_LOW_LEVEL_TRACER, +#endif + LBL_FAIL_POST_LOW_LEVEL_TRACER, + LBL_FAIL_VARTERM, + LBL_FAIL_PAIRTERM_INIT, + LBL_FAIL_PAIRTERM_END_APPL, + LBL_FAIL_END, +/** Cut & Commit Instructions **/ + CUT_INSTINIT, +#ifdef COROUTINING + CUT_COROUTINING, +#endif + CUT_NOCOROUTINING, + CUT_T_INSTINIT, +#ifdef COROUTINING + CUT_T_COROUTINING, +#endif + CUT_T_NOCOROUTINING, + CUT_E_INSTINIT, +#ifdef COROUTINING + CUT_E_COROUTINING, +#endif + CUT_E_NOCOROUTINING, + SAVE_B_X_INSTINIT, +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + SAVE_B_X_YSBA_FROZEN, +#else + SAVE_B_X_NOYSBA_NOFROZEN, +#endif + SAVE_B_X_END, + SAVE_B_Y_INSTINIT, +#if defined(YAPOR_SBA) + SAVE_B_Y_YSBA, +#else + SAVE_B_Y_NOYSBA, +#endif + SAVE_B_Y_END, + COMMIT_B_X_INSTINIT, + COMMIT_B_X_DO_COMMIT_B_X, + COMMIT_B_X_COMMIT_B_X_NVAR, +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + COMMIT_B_X_YSBA_FROZEN, +#else + COMMIT_B_X_NOYSBA_NOFROZEN, +#endif + COMMIT_B_X_POST_YSBA_FROZEN, + COMMIT_B_X_END, + COMMIT_B_Y_INSTINIT, + COMMIT_B_Y_DO_COMMIT_B_Y, + COMMIT_B_Y_COMMIT_B_Y_NVAR, +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + COMMIT_B_Y_YSBA_FROZEN, +#else + COMMIT_B_Y_NOYSBA_NOFROZEN, +#endif + COMMIT_B_Y_POST_YSBA_FROZEN, + COMMIT_B_Y_END, +/** Call / Proceed instructions **/ + EXECUTE_INSTINIT, +#ifdef LOW_LEVEL_TRACER + EXECUTE_LOW_LEVEL_TRACER, +#endif + EXECUTE_POST_LOW_LEVEL_TRACER, + EXECUTE_POST_NOCHECKING, +#ifdef DEPTH_LIMIT + EXECUTE_DEPTH_MINOR, + EXECUTE_DEPTH_MOFPRED, + EXECUTE_DEPTH_END, +#endif + EXECUTE_END_END, + DEXECUTE_INSTINIT, +#ifdef LOW_LEVEL_TRACER + DEXECUTE_LOW_LEVEL_TRACER, +#endif + DEXECUTE_POST_LOW_LEVEL_TRACER, +#ifdef DEPTH_LIMIT + DEXECUTE_DEPTH_MINOR, + DEXECUTE_DEPTH_MOFPRED, + DEXECUTE_DEPTH_END, +#endif + DEXECUTE_END_END, + FCALL_INST, + CALL_INSTINIT, +#ifdef LOW_LEVEL_TRACER + CALL_LOW_LEVEL_TRACER, +#endif + CALL_POST_LOW_LEVEL_TRACER, + CALL_POST_NO_CHECKING, +#ifdef DEPTH_LIMIT + CALL_DEPTH_MINOR, + CALL_DEPTH_MOFPRED, + CALL_DEPTH_END, +#endif + CALL_END_END, + PROCCEED_INSTINIT, +#ifdef DEPTH_LIMIT + PROCCEED_DEPTH, +#endif + PROCCEED_END, + ALLOCATE_INSTINIT, +#ifdef DEPTH_LIMIT + ALLOCATE_DEPTH, +#endif + ALLOCATE_END, + DEALLOCATE_INSTINIT, + DEALLOCATE_POST_CHECK, +#ifdef DEPTH_LIMIT + DEALLOCATE_DEPTH, +#endif + DEALLOCATE_FROZEN, + DEALLOCATE_POST_FROZEN, + DEALLOCATE_END, +/** OPTYap instructions **/ +// JIT does not support +/** Get Instructions **/ + GET_X_VAR_INSTINIT, + GET_Y_VAR_INSTINIT, + GET_YY_VAR_INSTINIT, + GET_X_VAL_INSTINIT, + GET_X_VAL_GVALX_NONVAR, + GET_X_VAL_GVALX_NONVAR_NONVAR, + GET_X_VAL_GVALX_NONVAR_UNK, + GET_X_VAL_GVALX_UNK, + GET_X_VAL_GVALX_VAR_NONVAR, + GET_X_VAL_GVALX_VAR_UNK, + GET_Y_VAL_INSTINIT, + GET_Y_VAL_GVALY_NONVAR, + GET_Y_VAL_GVALY_NONVAR_NONVAR, + GET_Y_VAL_GVALY_NONVAR_UNK, + GET_Y_VAL_GVALY_UNK, + GET_Y_VAL_GVALY_VAR_NONVAR, + GET_Y_VAL_GVALY_VAR_UNK, + GET_ATOM_INSTINIT, + GET_ATOM_GATOM_NONVAR, + GET_ATOM_GATOM_UNK, + GET_2ATOMS_INSTINIT, + GET_2ATOMS_GATOM_2UNK, + GET_2ATOMS_GATOM_2B, + GET_2ATOMS_GATOM_2BNONVAR, + GET_2ATOMS_GATOM_2BUNK, + GET_3ATOMS_INSTINIT, + GET_3ATOMS_GATOM_3UNK, + GET_3ATOMS_GATOM_3B, + GET_3ATOMS_GATOM_3BUNK, + GET_3ATOMS_GATOM_3C, + GET_3ATOMS_GATOM_3CNONVAR, + GET_3ATOMS_GATOM_3CUNK, + GET_4ATOMS_INSTINIT, + GET_4ATOMS_GATOM_4UNK, + GET_4ATOMS_GATOM_4B, + GET_4ATOMS_GATOM_4BUNK, + GET_4ATOMS_GATOM_4C, + GET_4ATOMS_GATOM_4CUNK, + GET_4ATOMS_GATOM_4D, + GET_4ATOMS_GATOM_4DNONVAR, + GET_4ATOMS_GATOM_4DUNK, + GET_5ATOMS_INSTINIT, + GET_5ATOMS_GATOM_5UNK, + GET_5ATOMS_GATOM_5B, + GET_5ATOMS_GATOM_5BUNK, + GET_5ATOMS_GATOM_5C, + GET_5ATOMS_GATOM_5CUNK, + GET_5ATOMS_GATOM_5D, + GET_5ATOMS_GATOM_5DUNK, + GET_5ATOMS_GATOM_5E, + GET_5ATOMS_GATOM_5ENONVAR, + GET_5ATOMS_GATOM_5EUNK, + GET_6ATOMS_INSTINIT, + GET_6ATOMS_GATOM_6UNK, + GET_6ATOMS_GATOM_6B, + GET_6ATOMS_GATOM_6BUNK, + GET_6ATOMS_GATOM_6C, + GET_6ATOMS_GATOM_6CUNK, + GET_6ATOMS_GATOM_6D, + GET_6ATOMS_GATOM_6DUNK, + GET_6ATOMS_GATOM_6E, + GET_6ATOMS_GATOM_6EUNK, + GET_6ATOMS_GATOM_6F, + GET_6ATOMS_GATOM_6FNONVAR, + GET_6ATOMS_GATOM_6FUNK, + GET_LIST_INSTINIT, + GET_LIST_GLIST_NONVAR, + GET_LIST_GLIST_UNK, + GET_STRUCT_INSTINIT, + GET_STRUCT_GSTRUCT_NONVAR, + GET_STRUCT_GSTRUCT_UNK, + GET_FLOAT_INSTINIT, + GET_FLOAT_GFLOAT_NONVAR, + GET_FLOAT_GFLOAT_UNK, + GET_LONGINT_INSTINIT, + GET_LONGINT_GLONGINT_NONVAR, + GET_LONGINT_GLONGINT_UNK, +#ifdef USE_GMP + GET_BIGINT_INSTINIT, + GET_BIGINT_GBIGINT_NONVAR, + GET_BIGINT_GBIGINT_UNK +#endif + GET_DBTERM_INSTINIT, + GET_DBTERM_GDBTERM_NONVAR, + GET_DBTERM_GDBTERM_UNK, +/** Optimised Get List Instructions **/ + GLIST_VALX_INSTINIT, + GLIST_VALX_GLIST_VALX_READ, + GLIST_VALX_GLIST_VALX_NONVAR, + GLIST_VALX_GLIST_VALX_NONVAR_NONVAR, + GLIST_VALX_GLIST_VALX_NONVAR_UNK, + GLIST_VALX_GLIST_VALX_UNK, + GLIST_VALX_GLIST_VALX_VAR_NONVAR, + GLIST_VALX_GLIST_VALX_VAR_UNK, + GLIST_VALX_GLIST_VALX_WRITE, + GLIST_VALY_INSTINIT, + GLIST_VALY_GLIST_VALY_READ, + GLIST_VALY_GLIST_VALY_NONVAR, + GLIST_VALY_GLIST_VALY_NONVAR_NONVAR, + GLIST_VALY_GLIST_VALY_NONVAR_UNK, + GLIST_VALY_GLIST_VALY_UNK, + GLIST_VALY_GLIST_VALY_VAR_NONVAR, + GLIST_VALY_GLIST_VALY_VAR_UNK, + GLIST_VALY_GLIST_VALY_WRITE, + GL_VOID_VARX_INSTINIT, + GL_VOID_VARX_GLIST_VOID_VARX_READ, + GL_VOID_VARX_GLIST_VOID_VAR_WRITE, + GL_VOID_VARY_INSTINIT, + GL_VOID_VARY_GLIST_VOID_VARY_READ, + GL_VOID_VARY_GLIST_VOID_VARY_WRITE, + GL_VOID_VALX_INSTINIT, + GL_VOID_VALX_GLIST_VOID_VALX_READ, + GL_VOID_VALX_GLIST_VOID_VALX_NONVAR, + GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR, + GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK, + GL_VOID_VALX_GLIST_VOID_VALX_UNK, + GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR, + GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK, + GL_VOID_VALX_GLIST_VOID_VALX_WRITE, + GL_VOID_VALY_INSTINIT, + GL_VOID_VALY_GLIST_VOID_VALY_READ, + GL_VOID_VALY_GLIST_VOID_VALY_NONVAR, + GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR, + GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK, + GL_VOID_VALY_GLIST_VOID_VALY_UNK, + GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR, + GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK, + GL_VOID_VALY_GLIST_VOID_VALY_WRITE, +/** Unify instructions **/ + UNIFY_X_VAR_INSTINIT, +#ifdef YAPOR_SBA + UNIFY_X_VAR_YAPOR_SBA, +#endif + UNIFY_X_VAR_END, + UNIFY_X_VAR_WRITE_INSTINIT, + UNIFY_L_X_VAR_INSTINIT, +#ifdef YAPOR_SBA + UNIFY_L_X_VAR_YAPOR_SBA, +#endif + UNIFY_L_X_VAR_END, + UNIFY_L_X_VAR_WRITE_INSTINIT, + UNIFY_X_VAR2_INSTINIT, +#ifdef YAPOR_SBA + UNIFY_X_VAR2_YAPOR_SBA, +#endif + UNIFY_X_VAR2_END, + UNIFY_X_VAR2_WRITE_INSTINIT, + UNIFY_L_X_VAR2_INSTINIT, + UNIFY_L_X_VAR2_WRITE_INSTINIT, + UNIFY_Y_VAR_INSTINIT, + UNIFY_Y_VAR_WRITE_INSTINIT, + UNIFY_L_Y_VAR_INSTINIT, + UNIFY_L_Y_VAR_WRITE_INSTINIT, + UNIFY_X_VAL_INSTINIT, + UNIFY_X_VAL_UVALX_NONVAR, + UNIFY_X_VAL_UVALX_NONVAR_NONVAR, + UNIFY_X_VAL_UVALX_NONVAR_UNK, + UNIFY_X_VAL_UVALX_UNK, + UNIFY_X_VAL_UVALX_VAR_NONVAR, + UNIFY_X_VAL_UVALX_VAR_UNK, + UNIFY_X_VAL_WRITE_INSTINIT, + UNIFY_L_X_VAL_INSTINIT, + UNIFY_L_X_VAL_ULVALX_NONVAR, + UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR, + UNIFY_L_X_VAL_ULVALX_NONVAR_UNK, + UNIFY_L_X_VAL_ULVALX_UNK, + UNIFY_L_X_VAL_ULVALX_VAR_NONVAR, + UNIFY_L_X_VAL_ULVALX_VAR_UNK, + UNIFY_L_X_VAL_WRITE_INSTINIT, + UNIFY_Y_VAL_INSTINIT, + UNIFY_Y_VAL_UVALY_NONVAR, + UNIFY_Y_VAL_UVALY_NONVAR_NONVAR, + UNIFY_Y_VAL_UVALY_NONVAR_UNK, + UNIFY_Y_VAL_UVALY_UNK, + UNIFY_Y_VAL_UVALY_VAR_NONVAR, + UNIFY_Y_VAL_UVALY_VAR_UNK, + UNIFY_Y_VAL_WRITE_INSTINIT, + UNIFY_L_Y_VAL_INSTINIT, + UNIFY_L_Y_VAL_ULVALY_NONVAR, + UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR, + UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK, + UNIFY_L_Y_VAL_ULVALY_UNK, + UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR, + UNIFY_L_Y_VAL_ULVALY_VAR_UNK, + UNIFY_L_Y_VAL_WRITE_INSTINIT, + UNIFY_X_LOC_INSTINIT, + UNIFY_X_LOC_UVALX_LOC_NONVAR, + UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR, + UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK, + UNIFY_X_LOC_UVALX_LOC_UNK, + UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR, + UNIFY_X_LOC_UVALX_LOC_VAR_UNK, + UNIFY_X_LOC_WRITE_INSTINIT, + UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR, + UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK, + UNIFY_L_X_LOC_INSTINIT, + UNIFY_L_X_LOC_ULVALX_LOC_NONVAR, + UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR, + UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK, + UNIFY_L_X_LOC_ULVALX_LOC_UNK, + UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR, + UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK, + UNIFY_L_X_LOC_WRITE_INSTINIT, + UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR, + UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK, + UNIFY_Y_LOC_INSTINIT, + UNIFY_Y_LOC_UVALY_LOC_NONVAR, + UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR, + UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK, + UNIFY_Y_LOC_UVALY_LOC_UNK, + UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR, + UNIFY_Y_LOC_UVALY_LOC_VAR_UNK, + UNIFY_Y_LOC_WRITE_INSTINIT, + UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR, + UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK, + UNIFY_L_Y_LOC_INSTINIT, + UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR, + UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR, + UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK, + UNIFY_L_Y_LOC_ULVALY_LOC_UNK, + UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR, + UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK, + UNIFY_L_Y_LOC_WRITE_INSTINIT, + UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR, + UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK, + UNIFY_VOID_INSTINIT, + UNIFY_VOID_WRITE_INSTINIT, + UNIFY_L_VOID_INSTINIT, + UNIFY_L_VOID_WRITE_INSTINIT, + UNIFY_N_VOIDS_INSTINIT, + UNIFY_N_VOIDS_WRITE_INSTINIT, + UNIFY_L_N_VOIDS_INSTINIT, + UNIFY_L_N_VOIDS_WRITE_INSTINIT, + UNIFY_ATOM_INSTINIT, + UNIFY_ATOM_UATOM_NONVAR, + UNIFY_ATOM_UATOM_UNK, + UNIFY_ATOM_WRITE_INSTINIT, + UNIFY_L_ATOM_INSTINIT, + UNIFY_L_ATOM_ULATOM_NONVAR, + UNIFY_L_ATOM_ULATOM_UNK, + UNIFY_L_ATOM_WRITE_INSTINIT, + UNIFY_N_ATOMS_INSTINIT, + UNIFY_N_ATOMS_WRITE_INSTINIT, + UNIFY_FLOAT_INSTINIT, + UNIFY_FLOAT_UFLOAT_NONVAR_INIT, + UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR, + UNIFY_FLOAT_UFLOAT_NONVAR_END, + UNIFY_FLOAT_UFLOAT_UNK, + UNIFY_FLOAT_WRITE_INSTINIT, + UNIFY_L_FLOAT_INSTINIT, + UNIFY_L_FLOAT_D0ISAPPL, + UNIFY_L_FLOAT_D0ISFUNC, + UNIFY_L_FLOAT_EQUALS, + UNIFY_L_FLOAT_ULFLOAT_UNK, + UNIFY_L_FLOAT_WRITE_INSTINIT, + UNIFY_LONGINT_INSTINIT, + UNIFY_LONGINT_D0ISAPPL, + UNIFY_LONGINT_D0ISFUNC, + UNIFY_LONGINT_EQUALS, + UNIFY_LONGINT_ULONGINT_UNK, + UNIFY_LONGINT_WRITE_INSTINIT, + UNIFY_L_LONGINT_INSTINIT, + UNIFY_L_LONGINT_D0ISAPPL, + UNIFY_L_LONGINT_D0ISFUNC, + UNIFY_L_LONGINT_EQUALS, + UNIFY_L_LONGINT_ULLONGINT_UNK, + UNIFY_L_LONGINT_WRITE_INSTINIT, +#ifdef USE_GMP + UNIFY_BIGINT_INSTINIT, + UNIFY_BIGINT_D0ISAPPL, + UNIFY_BIGINT_D1ISFUNC_GMP, + UNIFY_BIGINT_UBIGINT_UNK, + UNIFY_L_BIGINT_INSTINIT, + UNIFY_L_BIGINT_D0ISAPPL, + UNIFY_L_BIGINT_D0ISFUNC_GMP, + UNIFY_L_BIGINT_ULBIGINT_UNK, +#endif + UNIFY_DBTERM_INSTINIT, + UNIFY_DBTERM_UDBTERM_NONVAR, + UNIFY_DBTERM_UDBTERM_UNK, + UNIFY_L_DBTERM_INSTINIT, + UNIFY_L_DBTERM_ULDBTERM_NONVAR, + UNIFY_L_DBTERM_ULDBTERM_UNK, + UNIFY_LIST_INSTINIT, + UNIFY_LIST_READMODE, + UNIFY_LIST_WRITEMODE, + UNIFY_LIST_WRITE_INSTINIT, + UNIFY_L_LIST_INSTINIT, + UNIFY_L_LIST_READMODE, + UNIFY_L_LIST_WRITEMODE, + UNIFY_L_LIST_WRITE_INSTINIT, + UNIFY_STRUCT_INSTINIT, + UNIFY_STRUCT_READMODE, + UNIFY_STRUCT_WRITEMODE, + UNIFY_STRUCT_WRITE_INSTINIT, + UNIFY_L_STRUC_INSTINIT, + UNIFY_L_STRUC_READMODE, + UNIFY_L_STRUC_WRITEMODE, + UNIFY_L_STRUC_WRITE_INSTINIT, +/** Put Instructions **/ + PUT_X_VAR_INSTINIT, + PUT_Y_VAR_INSTINIT, + PUT_X_VAL_INSTINIT, + PUT_XX_VAL_INSTINIT, + PUT_Y_VAL_INSTINIT, + PUT_Y_VALS_INSTINIT, + PUT_UNSAFE_INSTINIT, + PUT_UNSAFE_PUNSAFE_NONVAR, + PUT_UNSAFE_PUNSAFE_UNK, + PUT_ATOM_INSTINIT, + PUT_DBTERM_INSTINIT, + PUT_BIGINT_INSTINIT, + PUT_FLOAT_INSTINIT, + PUT_LONGINT_INSTINIT, + PUT_LIST_INSTINIT, + PUT_STRUCT_INSTINIT, +/** Write Instructions **/ + WRITE_X_VAR_INSTINIT, + WRITE_VOID_INSTINIT, + WRITE_N_VOIDS_INSTINIT, + WRITE_Y_VAR_INSTINIT, + WRITE_X_VAL_INSTINIT, + WRITE_X_LOC_INSTINIT, + WRITE_X_LOC_W_X_BOUND, + WRITE_X_LOC_W_X_UNK, + WRITE_Y_VAL_INSTINIT, + WRITE_Y_LOC_INSTINIT, + WRITE_Y_LOC_W_Y_BOUND, + WRITE_Y_LOC_W_Y_UNK, + WRITE_ATOM_INSTINIT, + WRITE_BIGINT_INSTINIT, + WRITE_DBTERM_INSTINIT, + WRITE_FLOAT_INSTINIT, + WRITE_LONGIT_INSTINIT, + WRITE_N_ATOMS_INSTINIT, + WRITE_LIST_INSTINIT, + WRITE_L_LIST_INSTINIT, + WRITE_STRUCT_INSTINIT, + WRITE_L_STRUC_INSTINIT, +/** Save last unified struct or list **/ + SAVE_PAIR_X_INSTINIT, + SAVE_PAIR_X_WRITE_INSTINIT, + SAVE_PAIR_Y_INSTINIT, + SAVE_PAIR_Y_WRITE_INSTINIT, + SAVE_APPL_X_INSTINIT, + SAVE_APPL_X_WRITE_INSTINIT, + SAVE_APPL_Y_INSTINIT, + SAVE_APPL_Y_WRITE_INSTINIT, +/** Instructions for implemeting 'or' **/ + JUMP_INSTINIT, + MOVE_BACK_INSTINIT, + SKIP_INSTINIT, + EITHER_INSTINIT, +#ifdef LOW_LEVEL_TRACER + EITHER_LOW_LEVEL_TRACER, +#endif + EITHER_POST_COROUTINING, + EITHER_FROZEN_YSBA, + EITHER_POST_FROZEN_YSBA, +#ifdef YAPOR + EITHER_YAPOR, +#endif + EITHER_END, + OR_ELSE_INSTINIT, +#ifdef DEPTH_LIMIT + OR_ELSE_DEPTH, +#endif + OR_ELSE_POST_DEPTH, +#ifdef YAPOR + OR_ELSE_YAPOR, +#endif + OR_ELSE_END, + OR_LAST_INSTINIT, +#ifdef YAPOR + OR_LAST_IFOK_INIT, +#ifdef DEPTH_LIMIT + OR_LAST_IFOK_DEPTH, +#endif + OR_LAST_IFOK_END, +#endif + OR_LAST_NOIF_INIT, +#ifdef DEPTH_LIMIT + OR_LAST_NOIF_DEPTH, +#endif + OR_LAST_NOIF_END, +#ifdef YAPOR + OR_LAST_YAPOR, +#else + OR_LAST_NOYAPOR, +#endif + OR_LAST_END, +/** Pop operations **/ + POP_N_INSTINIT, + POP_N_END, + POP_INSTINIT, + POP_END, +/** Call C predicates instructions **/ + CALL_CPRED_INSTINIT, + CALL_CPRED_TEST_STACK, +#ifdef FROZEN_STACKS + CALL_CPRED_FROZEN_INIT, + CALL_CPRED_TOPB, +#else + CALL_CPRED_NOFROZEN, +#endif +#ifdef LOW_LEVEL_TRACER + CALL_CPRED_LOW_LEVEL_TRACER, +#endif + CALL_CPRED_POST_LOW_LEVEL_TRACER, +#ifdef SHADOW_S + CALL_CPRED_SETSREG, +#endif + CALL_CPRED_END, + EXECUTE_CPRED_INSTINIT, + EXECUTE_CPRED_POST_CHECK_TRAIL, +#ifdef FROZEN_STACKS + EXECUTE_CPRED_FROZEN, + EXECUTE_CPRED_TOPB, +#else + EXECUTE_CPRED_NOFROZEN, +#endif + EXECUTE_CPRED_POST_FROZEN, +#ifdef LOW_LEVEL_TRACER + EXECUTE_CPRED_LOW_LEVEL_TRACER, +#endif + EXECUTE_CPRED_POST_LOW_LEVEL_TRACER, + EXECUTE_CPRED_SAVE_PC, +#ifdef DEPTH_LIMIT + EXECUTE_CPRED_DEPTH_MINOR, + EXECUTE_CPRED_DEPTH_MOFPRED, + EXECUTE_CPRED_DEPTH_END, +#endif + EXECUTE_CPRED_END, + CALL_USERCPRED_INSTINIT, +#ifdef LOW_LEVEL_TRACER + CALL_USERCPRED_LOW_LEVEL_TRACER, +#endif + CALL_USERCPRED_FROZEN, + CALL_USERCPRED_POST_FROZEN, + CALL_USERCPRED_END, +/** support instructions **/ + LOCK_PRED_INSTINIT, + LOCK_PRED_FIRSTIFOK, + LOCK_PRED_SECONDTIFOK, + LOCK_PRED_END, + INDEX_PRED_INSTINIT, + INDEX_PRED_END, +#if THREADS + THREAD_LOCAL_INSTINIT, +#endif + EXPAND_INDEX_INSTINIT, +#if defined(YAPOR) || defined(THREADS) + EXPAND_INDEX_YAPOR_THREADS_NOPP, + EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT, + EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK, + EXPAND_INDEX_YAPOR_THREADS_IFOK_END, +#endif +#ifdef SHADOW_S + EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS, +#endif + EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS, +#ifdef SHADOW_S + EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG, +#endif + EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG, +#if defined(YAPOR) || defined(THREADS) + EXPAND_INDEX_UNLOCK, +#endif + EXPAND_INDEX_END, + EXPAND_CLAUSES_INSTINIT, +#if defined(YAPOR) || defined(THREADS) + EXPAND_CLAUSES_YAPOR_THREADS_NOPP, + EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT, + EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK, + EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END, +#endif + EXPAND_CLAUSES_NOYAPOR_NOTHREADS, +#if defined(YAPOR) || defined(THREADS) + EXPAND_CLAUSES_UNLOCK, +#endif + EXPAND_CLAUSES_END, + UNDEF_P_INSTINIT, + UNDEF_P_END, + SPY_PRED_INSTINIT, + SPY_PRED_FIRSTIFOK, + SPY_PRED_SECONDIFOK_INIT, + SPY_PRED_SECONDIFOK_FIRSTIFOK, + SPY_PRED_SECONDIFOK_POST_FIRSTIF, + SPY_PRED_SECONDIFOK_SECONDIFOK, + SPY_PRED_SECONDIFOK_THIRDIFOK, + SPY_PRED_THIRDIFOK_INIT, + SPY_PRED_THIRDIFOK_FIRSTIFOK, + SPY_PRED_FOURTHIFOK, + SPY_PRED_POST_FOURTHIF, + SPY_PRED_D0ISZERO, + SPY_PRED_D0ISNOZERO_INIT, + SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT, + SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR, + SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR, + SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR, + SPY_PRED_POST_IFS, +#ifdef THREADS + SPY_PRED_THREADS_LOCK, +#endif + SPY_PRED_POST_LOCK, +#ifdef THREADS + SPY_PRED_THREADS_UNLOCK, +#endif + SPY_PRED_POST_UNLOCK, +#ifdef LOW_LEVEL_TRACER + SPY_PRED_LOW_LEVEL_TRACER, +#endif + SPY_PRED_END, +/** Try / Retry / Trust for main indexing blocks **/ + TRY_CLAUSE_INSTINIT, +#ifdef YAPOR + TRY_CLAUSE_YAPOR, +#endif + TRY_CLAUSE_END, + TRY_CLAUSE2_INSTINIT, +#ifdef YAPOR + TRY_CLAUSE2_YAPOR, +#endif + TRY_CLAUSE2_END, + TRY_CLAUSE3_INSTINIT, +#ifdef YAPOR + TRY_CLAUSE3_YAPOR, +#endif + TRY_CLAUSE3_END, + TRY_CLAUSE4_INSTINIT, +#ifdef YAPOR + TRY_CLAUSE4_YAPOR, +#endif + TRY_CLAUSE4_END, + RETRY_INSTINIT, +#ifdef FROZEN_STACKS + RETRY_FROZEN, +#else + RETRY_NOFROZEN, +#endif + RETRY_END, + RETRY2_INSTINIT, +#ifdef FROZEN_STACKS + RETRY2_FROZEN, +#else + RETRY2_NOFROZEN, +#endif + RETRY2_END, + RETRY3_INSTINIT, +#ifdef FROZEN_STACKS + RETRY3_FROZEN, +#else + RETRY3_NOFROZEN, +#endif + RETRY3_END, + RETRY4_INSTINIT, +#ifdef FROZEN_STACKS + RETRY4_FROZEN, +#else + RETRY4_NOFROZEN, +#endif + RETRY4_END, + TRUST_INSTINIT, +#ifdef YAPOR + TRUST_IFOK_INIT, +#ifdef FROZEN_STACKS + TRUST_IFOK_FROZEN, +#endif + TRUST_IFOK_END, +#endif + TRUST_NOIF_INIT, +#ifdef FROZEN_STACKS + TRUST_NOIF_FROZEN, +#endif + TRUST_END, + TRY_IN_INSTINIT, + TRY_IN_END, +/** Logical Updates **/ +// JIT does not support +/** Indexing in ARG1 **/ + USER_SWITCH_INSTINIT, + USER_SWITCH_END, + SWITCH_ON_TYPE_INSTINIT, + SWITCH_ON_TYPE_END, + SWITCH_LIST_NL_INSTINIT, + SWITCH_LIST_NL_END, + SWITCH_ON_ARG_TYPE_INSTINIT, + SWITCH_ON_ARG_TYPE_END, + SWITCH_ON_SUB_ARG_TYPE_INSTINIT, + SWITCH_ON_SUB_ARG_TYPE_END, + JUMP_IF_VAR_INSTINIT, + JUMP_IF_VAR_END, + JUMP_IF_NONVAR_INSTINIT, + JUMP_IF_NONVAR_END, + IF_NOT_THEN_INSTINIT, + IF_NOT_THEN_END, +/** Indexing on ARG1 **/ + SWITCH_ON_FUNC_INSTINIT, + SWITCH_ON_FUNC_END, + SWITCH_ON_CONS_INSTINIT, + SWITCH_ON_CONS_END, + GO_ON_FUNC_INSTINIT, + GO_ON_FUNC_END, + GO_ON_CONS_INSTINIT, + GO_ON_CONS_END, + IF_FUNC_INSTINIT, + IF_FUNC_END, + IF_CONS_INSTINIT, + IF_CONS_END, + INDEX_DBREF_INSTINIT, + INDEX_DBREF_END, + INDEX_BLOB_INSTINIT, + INDEX_BLOB_END, + INDEX_LONG_INSTINIT, + INDEX_LONG_END, +/** Native **/ + JIT_HANDLER_INSTINIT, +/** Basic Primitive Predicates **/ + P_ATOM_X_INSTINIT, + P_ATOM_X_ATOM, + P_ATOM_X_NOATOM, + P_ATOM_Y_INSTINIT, + P_ATOM_Y_IFOK, + P_ATOM_Y_NOIF, + P_ATOM_Y_END, + P_ATOMIC_X_INSTINIT, + P_ATOMIC_X_NONVAR, + P_ATOMIC_X_VAR, + P_ATOMIC_X_END, + P_ATOMIC_Y_INSTINIT, + P_ATOMIC_Y_NONVAR, + P_ATOMIC_Y_VAR, + P_ATOMIC_Y_END, + P_INTEGER_X_INSTINIT, + P_INTEGER_X_INTEGER_X_NVAR_OK, + P_INTEGER_X_INTEGER_X_NVAR_NOOK, + P_INTEGER_X_INTEGER_X_UNK, + P_INTEGER_Y_INSTINIT, + P_INTEGER_Y_INTEGER_Y_NVAR_OK, + P_INTEGER_Y_INTEGER_Y_NVAR_NOOK, + P_INTEGER_Y_INTEGER_Y_UNK, + P_NONVAR_X_INSTINIT, + P_NONVAR_X_NONVAR, + P_NONVAR_X_NONONVAR, + P_NONVAR_Y_INSTINIT, + P_NONVAR_Y_NONVAR, + P_NONVAR_Y_NONONVAR, + P_NUMBER_X_INSTINIT, + P_NUMBER_X_INT, + P_NUMBER_X_FUNCTORINT, + P_NUMBER_X_FUNCTORDEFAULT, + P_NUMBER_X_POST_IF, + P_NUMBER_X_NUMBER_X_UNK, + P_NUMBER_Y_INSTINIT, + P_NUMBER_Y_INT, + P_NUMBER_Y_FUNCTORINT, + P_NUMBER_Y_FUNCTORDEFAULT, + P_NUMBER_Y_POST_IF, + P_NUMBER_Y_NUMBER_Y_UNK, + P_VAR_X_INSTINIT, + P_VAR_X_NONVAR, + P_VAR_X_VAR, + P_VAR_Y_INSTINIT, + P_VAR_Y_NONVAR, + P_VAR_Y_VAR, + P_DB_REF_X_INSTINIT, + P_DB_REF_X_DBREF, + P_DB_REF_X_NODBREF, + P_DB_REF_X_DBREF_X_UNK, + P_DB_REF_Y_INSTINIT, + P_DB_REF_Y_DBREF, + P_DB_REF_Y_NODBREF, + P_DB_REF_Y_DBREF_Y_UNK, + P_PRIMITIVE_X_INSTINIT, + P_PRIMITIVE_X_PRIMITIVE, + P_PRIMITIVE_X_NOPRIMITIVE, + P_PRIMITIVE_X_PRIMI_X_UNK, + P_PRIMITIVE_Y_INSTINIT, + P_PRIMITIVE_Y_PRIMITIVE, + P_PRIMITIVE_Y_NOPRIMITIVE, + P_PRIMITIVE_Y_PRIMI_Y_UNK, + P_COMPOUND_X_INSTINIT, + P_COMPOUND_X_PAIR, + P_COMPOUND_X_APPL_IFOK, + P_COMPOUND_X_APPL, + P_COMPOUND_X_NOAPPL, + P_COMPOUND_X_COMPOUND_X_UNK, + P_COMPOUND_Y_INSTINIT, + P_COMPOUND_Y_PAIR, + P_COMPOUND_Y_APPL_IFOK, + P_COMPOUND_Y_APPL, + P_COMPOUND_Y_NOAPPL, + P_COMPOUND_Y_COMPOUND_Y_UNK, + P_FLOAT_X_INSTINIT, + P_FLOAT_X_FLOAT, + P_FLOAT_X_POST_IF, + P_FLOAT_X_FLOAT_X_UNK, + P_FLOAT_Y_INSTINIT, + P_FLOAT_Y_FLOAT, + P_FLOAT_Y_POST_IF, + P_FLOAT_Y_FLOAT_Y_UNK, + P_PLUS_VV_INSTINIT, + P_PLUS_VV_PLUS_VV_NVAR, + P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT, + P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT, + P_PLUS_VV_PLUS_VV_UNK, + P_PLUS_VV_PLUS_VV_NVAR_UNK, + P_PLUS_VC_INSTINIT, + P_PLUS_VC_PLUS_VC_NVAR_INT, + P_PLUS_VC_PLUS_VC_NVAR_NOINT, + P_PLUS_VC_PLUS_VC_UNK, + P_PLUS_Y_VV_INSTINIT, + P_PLUS_Y_VV_PLUS_Y_VV_NVAR, + P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT, + P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT, + P_PLUS_Y_VV_PLUS_Y_VV_UNK, + P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK, + P_PLUS_Y_VC_INSTINIT, + P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT, + P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT, + P_PLUS_Y_VC_PLUS_Y_VC_UNK, + P_MINUS_VV_INSTINIT, + P_MINUS_VV_MINUS_VV_NVAR, + P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT, + P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT, + P_MINUS_VV_MINUS_VV_UNK, + P_MINUS_VV_MINUS_VV_NVAR_UNK, + P_MINUS_CV_INSTINIT, + P_MINUS_CV_MINUS_CV_NVAR_INT, + P_MINUS_CV_MINUS_CV_NVAR_NOINT, + P_MINUS_CV_MINUS_CV_UNK, + P_MINUS_Y_VV_INSTINIT, + P_MINUS_Y_VV_MINUS_Y_VV_NVAR, + P_MINUS_Y_VV_INTTERM, + P_MINUS_Y_VV_NOINTTERM, + P_MINUS_Y_VV_D0EQUALS0L, + P_MINUS_Y_VV_NVAR_END, + P_MINUS_Y_VV_MINUS_Y_VV_UNK, + P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK, + P_MINUS_Y_CV_INSTINIT, + P_MINUS_Y_CV_MINUS_Y_CV_NVAR, + P_MINUS_Y_CV_INTTERM, + P_MINUS_Y_CV_NOINTTERM, + P_MINUS_Y_CV_D0EQUALS0L, + P_MINUS_Y_CV_NVAR_END, + P_MINUS_Y_CV_MINUS_Y_CV_UNK, + P_TIMES_VV_INSTINIT, + P_TIMES_VV_TIMES_VV_NVAR, + P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT, + P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT, + P_TIMES_VV_TIMES_VV_UNK, + P_TIMES_VV_TIMES_VV_NVAR_UNK, + P_TIMES_VC_INSTINIT, + P_TIMES_VC_TIMES_VC_NVAR_INT, + P_TIMES_VC_TIMES_VC_NVAR_NOINT, + P_TIMES_VC_TIMES_VC_UNK, + P_TIMES_Y_VV_INSTINIT, + P_TIMES_Y_VV_TIMES_Y_VV_NVAR, + P_TIMES_Y_VV_INTTERM, + P_TIMES_Y_VV_NOINTTERM, + P_TIMES_Y_VV_D0EQUALS0L, + P_TIMES_Y_VV_NVAR_END, + P_TIMES_Y_VV_TIMES_Y_VV_UNK, + P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK, + P_TIMES_Y_VC_INSTINIT, + P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT, + P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT, + P_TIMES_Y_VC_NVAR_END, + P_TIMES_Y_VC_TIMES_Y_VC_UNK, + P_DIV_VV_INSTINIT, + P_DIV_VV_DIV_VV_NVAR, + P_DIV_VV_DIV_VV_NVAR_NVAR_INT, + P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT, + P_DIV_VV_DIV_VV_UNK, + P_DIV_VV_DIV_VV_NVAR_UNK, + P_DIV_VC_INSTINIT, + P_DIV_VC_DIV_VC_NVAR, + P_DIV_VC_INTTERM, + P_DIV_VC_NOINTTERM, + P_DIV_VC_D0EQUALS0L, + P_DIV_VC_NVAR_END, + P_DIV_VC_DIV_VC_UNK, + P_DIV_CV_INSTINIT, + P_DIV_CV_DIV_CV_NVAR, + P_DIV_CV_INTTERM_INIT, + P_DIV_CV_INTTERM_DIVEQUALS0, + P_DIV_CV_INTTERM_END, + P_DIV_CV_NOINTTERM, + P_DIV_CV_D0EQUALS0L, + P_DIV_CV_NVAR_END, + P_DIV_CV_DIV_CV_UNK, + P_DIV_Y_VV_INSTINIT, + P_DIV_Y_VV_DIV_Y_VV_NVAR, + P_DIV_Y_VV_INTTERM_INIT, + P_DIV_Y_VV_INTTERM_DIVEQUALS0, + P_DIV_Y_VV_INTTERM_END, + P_DIV_Y_VV_NOINTTERM, + P_DIV_Y_VV_D0EQUALS0L, + P_DIV_Y_VV_NVAR_END, + P_DIV_Y_VV_DIV_Y_VV_UNK, + P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK, + P_DIV_Y_VC_INSTINIT, + P_DIV_Y_VC_DIV_Y_VC_NVAR, + P_DIV_Y_VC_INTTERM, + P_DIV_Y_VC_NOINTTERM, + P_DIV_Y_VC_D0EQUALS0L, + P_DIV_Y_VC_NVAR_END, + P_DIV_Y_VC_DIV_Y_VC_UNK, + P_DIV_Y_CV_INSTINIT, + P_DIV_Y_CV_DIV_Y_CV_NVAR, + P_DIV_Y_CV_INTTERM_INIT, + P_DIV_Y_CV_INTTERM_DIVEQUALS0, + P_DIV_Y_CV_INTTERM_END, + P_DIV_Y_CV_NOINTTERM, + P_DIV_Y_CV_D0EQUALS0L, + P_DIV_Y_CV_NVAR_END, + P_DIV_Y_CV_DIV_Y_CV_UNK, + P_AND_VV_INSTINIT, + P_AND_VV_AND_VV_NVAR, + P_AND_VV_AND_VV_NVAR_NVAR_INT, + P_AND_VV_AND_VV_NVAR_NVAR_NOINT, + P_AND_VV_AND_VV_UNK, + P_AND_VV_AND_VV_NVAR_UNK, + P_AND_VC_INSTINIT, + P_AND_VC_AND_VC_NVAR_INT, + P_AND_VC_AND_VC_NVAR_NOINT, + P_AND_VC_AND_VC_UNK, + P_AND_Y_VV_INSTINIT, + P_AND_Y_VV_AND_Y_VV_NVAR, + P_AND_Y_VV_INTTERM, + P_AND_Y_VV_NOINTTERM, + P_AND_Y_VV_D0EQUALS0L, + P_AND_Y_VV_NVAR_END, + P_AND_Y_VV_AND_Y_VV_UNK, + P_AND_Y_VV_AND_Y_VV_NVAR_UNK, + P_AND_Y_VC_INSTINIT, + P_AND_Y_VC_AND_Y_VC_NVAR, + P_AND_Y_VC_INTTERM, + P_AND_Y_VC_NOINTTERM, + P_AND_Y_VC_D0EQUALS0L, + P_AND_Y_VC_NVAR_END, + P_AND_Y_VC_AND_Y_VC_UNK, + P_OR_VV_INSTINIT, + P_OR_VV_OR_VV_NVAR, + P_OR_VV_INTTERM, + P_OR_VV_NOINTTERM, + P_OR_VV_D0EQUALS0L, + P_OR_VV_NVAR_END, + P_OR_VV_OR_VV_UNK, + P_OR_VV_OR_VV_NVAR_UNK, + P_OR_VC_INSTINIT, + P_OR_VC_OR_VC_NVAR, + P_OR_VC_INTTERM, + P_OR_VC_NOINTTERM, + P_OR_VC_D0EQUALS0L, + P_OR_VC_NVAR_END, + P_OR_VC_OR_VC_UNK, + P_OR_Y_VV_INSTINIT, + P_OR_Y_VV_OR_Y_VV_NVAR, + P_OR_Y_VV_INTTERM, + P_OR_Y_VV_NOINTTERM, + P_OR_Y_VV_D0EQUALS0L, + P_OR_Y_VV_NVAR_END, + P_OR_Y_VV_OR_Y_VV_UNK, + P_OR_Y_VV_OR_Y_VV_NVAR_UNK, + P_OR_Y_VC_INSTINIT, + P_OR_Y_VC_OR_Y_VC_NVAR, + P_OR_Y_VC_INTTERM, + P_OR_Y_VC_NOINTTERM, + P_OR_Y_VC_D0EQUALS0L, + P_OR_Y_VC_NVAR_END, + P_OR_Y_VC_OR_Y_VC_UNK, + P_SLL_VV_INSTINIT, + P_SLL_VV_SLL_VV_NVAR, + P_SLL_VV_INTTERM_INIT, + P_SLL_VV_INTTERM_LESS, + P_SLL_VV_INTTERM_GREATER, + P_SLL_VV_NOINTTERM, + P_SLL_VV_D0EQUALS0L, + P_SLL_VV_NVAR_END, + P_SLL_VV_SLL_VV_UNK, + P_SLL_VV_SLL_VV_NVAR_UNK, + P_SLL_VC_INSTINIT, + P_SLL_VC_SLL_VC_NVAR, + P_SLL_VC_INTTERM, + P_SLL_VC_NOINTTERM, + P_SLL_VC_D0EQUALS0L, + P_SLL_VC_NVAR_END, + P_SLL_VC_SLL_VC_UNK, + P_SLL_CV_INSTINIT, + P_SLL_CV_SLL_CV_NVAR_INT, + P_SLL_CV_SLL_CV_NVAR_NOINT, + P_SLL_CV_SLL_CV_UNK, + P_SLL_Y_VV_INSTINIT, + P_SLL_Y_VV_SLL_Y_VV_NVAR, + P_SLL_Y_VV_INTTERM_INIT, + P_SLL_Y_VV_INTERM_LESS, + P_SLL_Y_VV_INTTERM_GREATER, + P_SLL_Y_VV_NOINTTERM, + P_SLL_Y_VV_D0EQUALS0L, + P_SLL_Y_VV_NVAR_END, + P_SLL_Y_VV_SLL_Y_VV_UNK, + P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK, + P_SLL_Y_VC_INSTINIT, + P_SLL_Y_VC_SLL_Y_VC_NVAR, + P_SLL_Y_VC_INTTERM, + P_SLL_Y_VC_NOINTTERM, + P_SLL_Y_VC_D0EQUALS0L, + P_SLL_Y_VC_NVAR_END, + P_SLL_Y_VC_SLL_Y_VC_UNK, + P_SLL_Y_CV_INSTINIT, + P_SLL_Y_CV_SLL_Y_CV_NVAR, + P_SLL_Y_CV_INTTERM_INIT, + P_SLL_Y_CV_INTTERM_LESS, + P_SLL_Y_CV_INTTERM_GREATER, + P_SLL_Y_CV_NOINTTERM, + P_SLL_Y_CV_D0EQUALS0L, + P_SLL_Y_CV_NVAR_END, + P_SLL_Y_CV_SLL_Y_CV_UNK, + P_SLR_VV_INSTINIT, + P_SLR_VV_SLR_VV_NVAR, + P_SLR_VV_INTTERM_INIT, + P_SLR_VV_INTTERM_LESS, + P_SLR_VV_INTTERM_GREATER, + P_SLR_VV_NOINTTERM, + P_SLR_VV_D0EQUALS0L, + P_SLR_VV_NVAR_END, + P_SLR_VV_SRL_VV_UNK, + P_SLR_VV_SRL_VV_NVAR_UNK, + P_SLR_VC_INSTINIT, + P_SLR_VC_SLR_VC_NVAR_INT, + P_SLR_VC_SLR_VC_NVAR_NOINT, + P_SLR_VC_SRL_VC_UNK, + P_SLR_CV_INSTINIT, + P_SLR_CV_SLR_CV_NVAR, + P_SLR_CV_INTTERM_INIT, + P_SLR_CV_INTTERM_LESS, + P_SLR_CV_INTTERM_GREATER, + P_SLR_CV_NOINTTERM, + P_SLR_CV_D0EQUALS0L, + P_SLR_CV_NVAR_END, + P_SLR_CV_SLR_CV_UNK, + P_SLR_Y_VV_INSTINIT, + P_SLR_Y_VV_SLR_Y_VV_NVAR, + P_SLR_Y_VV_INTTERM_INIT, + P_SLR_Y_VV_INTTERM_LESS, + P_SLR_Y_VV_INTTERM_GREATER, + P_SLR_Y_VV_NOINTTERM, + P_SLR_Y_VV_D0EQUALS0L, + P_SLR_Y_VV_NVAR_END, + P_SLR_Y_VV_SLR_Y_VV_UNK, + P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK, + P_SLR_Y_VC_INSTINIT, + P_SLR_Y_VC_SLR_Y_VC_NVAR, + P_SLR_Y_VC_INTTERM, + P_SLR_Y_VC_NOINTTERM, + P_SLR_Y_VC_D0EQUALS0L, + P_SLR_Y_VC_NVAR_END, + P_SLR_Y_VC_SLR_Y_VC_UNK, + P_SLR_Y_CV_INSTINIT, + P_SLR_Y_CV_SLR_Y_CV_NVAR, + P_SLR_Y_CV_INTTERM_INIT, + P_SLR_Y_CV_INTTERM_LESS, + P_SLR_Y_CV_INTTERM_GREATER, + P_SLR_Y_CV_NOINTTERM, + P_SLR_Y_CV_D0EQUALS0L, + P_SLR_Y_CV_NVAR_END, + P_SLR_Y_CV_SLR_Y_CV_UNK, + CALL_BFUNC_XX_INSTINIT, + CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR, + CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT, + CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT, + CALL_BFUNC_XX_CALL_BFUNC_XX_UNK, + CALL_BFUNC_YX_INSTINIT, + CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT, + CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT, + CALL_BFUNC_YX_CALL_BFUNC_YX_UNK, + CALL_BFUNC_XY_INSTINIT, + CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT, + CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT, + CALL_BFUNC_XY_CALL_BFUNC_XY_UNK, + CALL_BFUNC_YY_INSTINIT, + CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT, + CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT, + CALL_BFUNC_YY_CALL_BFUNC_YY_UNK, + P_EQUAL_INSTINIT, + P_EQUAL_END, + P_DIF_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_DIF_LOW_LEVEL_TRACER, +#endif + P_DIF_POST_LOW_LEVEL_TRACER, + P_DIF_DIF_NVAR1, + P_DIF_DIF_NVAR1_NVAR2, + P_DIF_DIF_UNK1, + P_DIF_DIF_NVAR1_UNK2, + P_EQ_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_EQ_LOW_LEVEL_TRACER, +#endif + P_EQ_POST_LOW_LEVEL_TRACER, + P_EQ_P_EQ_NVAR1, + P_EQ_P_EQ_NVAR1_NVAR2, + P_EQ_P_EQ_NVAR1_UNK2, + P_EQ_P_EQ_UNK1, + P_EQ_P_EQ_VAR1_NVAR2, + P_EQ_P_EQ_VAR1_UNK2_END, + P_ARG_VV_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_ARG_VV_LOW_LEVEL_TRACER, +#endif + P_ARG_VV_TEST_D0, + P_ARG_VV_ARG_ARG1_NVAR, + P_ARG_VV_TEST_D1, + P_ARG_VV_ARG_ARG2_NVAR, + P_ARG_VV_ARG_ARG2_UNK, + P_ARG_VV_ARG_ARG1_UNK, + P_ARG_CV_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_ARG_CV_LOW_LEVEL_TRACER, +#endif + P_ARG_CV_TEST_D1, + P_ARG_CV_ARG_ARG2_VC_NVAR, + P_ARG_CV_ARG_ARG2_VC_UNK, + P_ARG_Y_VV_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_ARG_Y_VV_LOW_LEVEL_TRACER, +#endif + P_ARG_Y_VV_TEST_D0, + P_ARG_Y_VV_ARG_Y_ARG1_NVAR, + P_ARG_Y_VV_TEST_D1, + P_ARG_Y_VV_ARG_Y_ARG2_NVAR, + P_ARG_Y_VV_ARG_Y_ARG2_UNK, + P_ARG_Y_VV_ARG_Y_ARG1_UNK, + P_ARG_Y_CV_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_ARG_Y_CV_LOW_LEVEL_TRACER, +#endif + P_ARG_Y_CV_TEST_D1, + P_ARG_Y_CV_D1APPL_INIT, + P_ARG_Y_CV_D1APPL_END, + P_ARG_Y_CV_D1PAIR_INIT, + P_ARG_Y_CV_D1PAIR_LESS0, + P_ARG_Y_CV_D1PAIR_END, + P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK, + P_FUNCTOR_INSTINIT, + P_FUNCTOR_END, + P_FUNC2S_VV_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2S_VV_LOW_LEVEL_TRACER, +#endif + P_FUNC2S_TEST_D0, + P_FUNC2S_VV_TEST_D1, + P_FUNC2S_VV_D1INT, + P_FUNC2S_VV_D1NOTINT, + P_FUNC2S_VV_D1BIGINT, + P_FUNC2S_VV_D1NOTBIGINT, + P_FUNC2S_VV_D1NOTINT_END, + P_FUNC2S_VV_D0NOTATOMIC, + P_FUNC2S_VV_FIRSTIFOK, + P_FUNC2S_VV_SECONDIFOK_D0NOTATOM, + P_FUNC2S_VV_SECONDIFOK_D0ATOM, + P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM, + P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT, + P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK, + P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF, + P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE, + P_FUNC2S_VV_SECONDIFOK_END, + P_FUNC2S_VV_THIRDIFOK, + P_FUNC2S_VV_ELSE, + P_FUNC2S_VV_FUNC2S_UNK2, + P_FUNC2S_VV_FUNC2S_UNK, + P_FUNC2S_CV_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2S_CV_LOW_LEVEL_TRACER, +#endif + P_FUNC2S_CV_TEST_D1, + P_FUNC2S_CV_D1INT, + P_FUNC2S_CV_D1NOTINT, + P_FUNC2S_CV_D1NOINT_D1BIGINT, + P_FUNC2S_CV_D1NOTBIGINT, + P_FUNC2S_CV_POST_IF, + P_FUNC2S_CV_FIRSTIFOK, + P_FUNC2S_CV_D1GREATER_D0NOTATOM, + P_FUNC2S_CV_D1GREATER_D0ATOM, + P_FUNC2S_CV_D1GREATER_POST_IF, + P_FUNC2S_CV_D1GREATER_IFOK_INIT, + P_FUNC2S_CV_D1GREATER_IFOK_IFOK, + P_FUNC2S_CV_D1GREATER_IFOK_NOIF, + P_FUNC2S_CV_D1GREATER_INSIDEWHILE, + P_FUNC2S_CV_D1GREATER_END, + P_FUNC2S_CV_D1ISZERO, + P_FUNC2S_CV_ELSE, + P_FUNC2S_CV_END, + P_FUNC2S_VC_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2S_VC_LOW_LEVEL_TRACER, +#endif + P_FUNC2S_VC_TEST_D0, + P_FUNC2S_VC_FUNC2S_NVAR_VC, + P_FUNC2S_VC_D0NOATOMIC, + P_FUNC2S_VC_EQUALS, + P_FUNC2S_VC_D1ISZERO, + P_FUNC2S_VC_D0NOATOM, + P_FUNC2S_VC_D0ATOM, + P_FUNC2S_VC_POST_ELSE, + P_FUNC2S_VC_IFOK_INIT, + P_FUNC2S_VC_IFOK_IFOK, + P_FUNC2S_VC_IFOK_NOIF, + P_FUNC2S_VC_INSIDEWHILE, + P_FUNC2S_VC_END1, + P_FUNC2S_VC_END2, + P_FUNC2S_Y_VV_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2S_Y_VV_LOW_LEVEL_TRACER, +#endif + P_FUNC2S_Y_VV_TEST_D0, + P_FUNC2S_Y_VV_TEST_D1, + P_FUNC2S_Y_VV_D1INT, + P_FUNC2S_Y_VV_D1NOTINT, + P_FUNC2S_Y_VV_D1BIGINT, + P_FUNC2S_Y_VV_D1NOTBIGINT, + P_FUNC2S_Y_VV_POST_IF, + P_FUNC2S_Y_VV_D0NOATOMIC, + P_FUNC2S_Y_VV_EQUALS, + P_FUNC2S_Y_VV_D1GREATER_D0NOATOM, + P_FUNC2S_Y_VV_D1GREATER_D0ATOM, + P_FUNC2S_Y_VV_D1GREATER_POST_ELSE, + P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT, + P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK, + P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF, + P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE, + P_FUNC2S_Y_VV_D1GREATER_END, + P_FUNC2S_Y_VV_D1ISZERO, + P_FUNC2S_Y_VV_ELSE, + P_FUNC2S_Y_VV_END1, + P_FUNC2S_Y_VV_END2, + P_FUNC2S_Y_CV_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2S_Y_CV_LOW_LEVEL_TRACER, +#endif + P_FUNC2S_Y_CV_TEST_D1, + P_FUNC2S_Y_CV_D1INT, + P_FUNC2S_Y_CV_D1NOTINT, + P_FUNC2S_Y_CV_D1BIGINT, + P_FUNC2S_Y_CV_D1NOTBIGINT, + P_FUNC2S_Y_CV_POST_IF, + P_FUNC2S_Y_CV_EQUALS, + P_FUNC2S_Y_CV_D1GREATER_D0NOATOM, + P_FUNC2S_Y_CV_D1GREATER_D0ATOM, + P_FUNC2S_Y_CV_D1GREATER_POST_ELSE, + P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT, + P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK, + P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF, + P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE, + P_FUNC2S_Y_CV_D1GREATER_END, + P_FUNC2S_Y_CV_D1ISZERO, + P_FUNC2S_Y_CV_ELSE, + P_FUNC2S_Y_CV_END, + P_FUNC2S_Y_VC_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2S_Y_VC_LOW_LEVEL_TRACER, +#endif + P_FUNC2S_Y_VC_TEST_D0, + P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC, + P_FUNC2S_Y_VC_D0NOATOMIC, + P_FUNC2S_Y_VC_EQUALS, + P_FUNC2S_Y_VC_D1ISZERO, + P_FUNC2S_Y_VC_D0NOATOM1, + P_FUNC2S_Y_VC_D0NOATOM2, + P_FUNC2S_Y_VC_D0ATOM, + P_FUNC2S_Y_VC_POST_ELSE, + P_FUNC2S_Y_VC_IFOK_INIT, + P_FUNC2S_Y_VC_IFOK_IFOK, + P_FUNC2S_Y_VC_IFOK_NOIF, + P_FUNC2S_Y_VC_INSIDEWHILE, + P_FUNC2S_Y_VC_END1, + P_FUNC2S_Y_VC_END2, + P_FUNC2F_XX_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2F_XX_LOW_LEVEL_TRACER, +#endif + P_FUNC2F_XX_TEST_D0, + P_FUNC2F_XX_D0APPL, + P_FUNC2F_XX_D0APPL_D1EXTFUNC, + P_FUNC2F_XX_D0APPL_END, + P_FUNC2F_XX_D0PAIR, + P_FUNC2F_XX_D0NOCOMPOUND, + P_FUNC2F_XX_END, + P_FUNC2F_XY_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2F_XY_LOW_LEVEL_TRACER, +#endif + P_FUNC2F_XY_TEST_D0, + P_FUNC2F_XY_D0APPL, + P_FUNC2F_XY_D0APPL_D1EXTFUNC, + P_FUNC2F_XY_D0APPL_END, + P_FUNC2F_XY_D0PAIR, + P_FUNC2F_XY_D0NOCOMPOUND, + P_FUNC2F_XY_END, + P_FUNC2F_YX_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2F_YX_LOW_LEVEL_TRACER, +#endif + P_FUNC2F_YX_TEST_D0, + P_FUNC2F_YX_D0APPL, + P_FUNC2F_YX_D0APPL_D1EXTFUNC, + P_FUNC2F_YX_D0APPL_END, + P_FUNC2F_YX_D0PAIR, + P_FUNC2F_YX_D0NOCOMPOUND, + P_FUNC2F_YX_END, + P_FUNC2F_YY_INSTINIT, +#ifdef LOW_LEVEL_TRACER + P_FUNC2F_YY_LOW_LEVEL_TRACER, +#endif + P_FUNC2F_YY_TEST_D0, + P_FUNC2F_YY_D0APPL, + P_FUNC2F_YY_D0APPL_D1EXTFUNC, + P_FUNC2F_YY_D0APPL_END, + P_FUNC2F_YY_D0PAIR, + P_FUNC2F_YY_D0NOCOMPOUND, + P_FUNC2F_YY_END + diff --git a/JIT/HPP/debug_printers.h b/JIT/HPP/debug_printers.h new file mode 100644 index 000000000..cf0056838 --- /dev/null +++ b/JIT/HPP/debug_printers.h @@ -0,0 +1,73 @@ +void print_main_when_head(yamop*, enumPlace); + +inline void +print_main_when_head(yamop* p, enumPlace place) +{ + if((ExpEnv.debug_struc.pmainclause_on_head.print & place) == place) { + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pmainclause_on_head.msg_before); + print_preg(p); + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pmainclause_on_head.msg_after); + } +} + +void print_instruction(yamop*, enumPlace); + +inline void +print_instruction(yamop* p, enumPlace place) +{ + op_numbers op = Yap_op_from_opcode(p->opc); + switch(op) { + #define OPCODE(OP,TYPE) \ + case _##OP: \ + if((ExpEnv.debug_struc.pyaam_##OP.print & place) == place) { \ + char *tmp = (char*)malloc((16+strlen((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after))*sizeof(char)); \ + switch(place) { \ + case ON_INTERPRETER: \ + strcpy(tmp, " (as standard)"); \ + break; \ + case ON_PROFILED_INTERPRETER: \ + strcpy(tmp, " (as profiled)"); \ + break; \ + case ON_NATIVE: \ + strcpy(tmp, " (as native)"); \ + break; \ + default:; \ + } \ + strcat(tmp, (char*)ExpEnv.debug_struc.pyaam_##OP.msg_after); \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + print_op((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before, op, tmp); \ + } \ + break; + #include "YapAppliedOpcodes.h" + #undef OPCODE + default:; + } +} + +#if YAP_JIT +void print_block(YAP_BBs, enumPlace); + +inline void +print_block(YAP_BBs block, enumPlace place) +{ + switch(block) { + #define BBLOCK(BB) \ + case BB: \ + if((ExpEnv.debug_struc.pbbs_##BB.print & place) == place) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pbbs_##BB.msg_before); \ + fprint_block(block); \ + { \ + if (place == ON_NATIVE) fprintf(stderr, " (on native)"); \ + else fprintf(stderr, " (on interpreter)"); \ + } \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pbbs_##BB.msg_after); \ + } \ + break; + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + default:; + } +} +#endif diff --git a/JIT/HPP/fprintblock.h b/JIT/HPP/fprintblock.h new file mode 100644 index 000000000..03ccaf270 --- /dev/null +++ b/JIT/HPP/fprintblock.h @@ -0,0 +1,4016 @@ +static inline void +fprint_block(YAP_BBs block) { + switch(block) { + case ENTRY: break; + case YAAM_DEREF_BODY_D0PT0: + fprintf(stderr, "YAAM_DEREF_BODY_D0PT0"); + break; + case YAAM_DEREF_BODY_D0PT1: + fprintf(stderr, "YAAM_DEREF_BODY_D0PT1"); + break; + case YAAM_DEREF_BODY_D0S_SREG: + fprintf(stderr, "YAAM_DEREF_BODY_D0S_SREG"); + break; + case YAAM_DEREF_BODY_D1PT0: + fprintf(stderr, "YAAM_DEREF_BODY_D1PT0"); + break; + case YAAM_DEREF_BODY_D1PT1: + fprintf(stderr, "YAAM_DEREF_BODY_D1PT1"); + break; + case YAAM_FAIL: + fprintf(stderr, "YAAM_FAIL"); + break; + case YAAM_CHECK_TRAIL_TR: + fprintf(stderr, "YAAM_CHECK_TRAIL_TR"); + break; + case YAAM_UNIFYBOUND: + break; + case NoStackExecute_Exception: + fprintf(stderr, "NoStackExecute_Exception"); + break; + case NoStackDExecute_Exception: + fprintf(stderr, "NoStackDExecute_Exception"); + break; + case NoStackCall_Exception: + fprintf(stderr, "NoStackCall_Exception"); + break; + case NoStackDeallocate_Exception: + fprintf(stderr, "NoStackDeallocate_Exception"); + break; +#ifdef COROUTINING + case NoStackFail_Exception: + fprintf(stderr, "NoStackFail_Exception"); + break; +#endif + case NoStackCut_Exception: + fprintf(stderr, "NoStackCut_Exception"); + break; + case NoStackCutT_Exception: + fprintf(stderr, "NoStackCutT_Exception"); + break; + case NoStackCutE_Exception: + fprintf(stderr, "NoStackCutE_Exception"); + break; + case NoStackCommitX_Exception: + fprintf(stderr, "NoStackCommitX_Exception"); + break; + case NoStackCommitY_Exception: + fprintf(stderr, "NoStackCommitY_Exception"); + break; + case NoStackEither_Exception: + fprintf(stderr, "NoStackEither_Exception"); + break; + case NoStackPExecute_Exception: + fprintf(stderr, "NoStackPExecute_Exception"); + break; + case NoStackPExecute2_Exception: + fprintf(stderr, "NoStackPExecute2_Exception"); + break; + case NoStackPTExecute_Exception: + fprintf(stderr, "NoStackPTExecute_Exception"); + break; + case TRY_ME_INSTINIT: + fprintf(stderr, "TRY_ME_INSTINIT"); + break; +#ifdef YAPOR + case TRY_ME_YAPOR: + fprintf(stderr, "TRY_ME_YAPOR"); + break; +#endif + case TRY_ME_END: + fprintf(stderr, "TRY_ME_END"); + break; + case RETRY_ME_INSTINIT: + fprintf(stderr, "RETRY_ME_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY_ME_FROZEN: + fprintf(stderr, "RETRY_ME_FROZEN"); + break; +#else + case RETRY_ME_NOFROZEN: + fprintf(stderr, "RETRY_ME_NOFROZEN"); + break; +#endif + case RETRY_ME_END: + fprintf(stderr, "RETRY_ME_END"); + break; + case TRUST_ME_INSTINIT: + fprintf(stderr, "TRUST_ME_INSTINIT"); + break; + case TRUST_ME_IF: + fprintf(stderr, "TRUST_ME_IF"); + break; + case TRUST_ME_END: + fprintf(stderr, "TRUST_ME_END"); + break; + case ENTER_PROFILING_INSTINIT: + fprintf(stderr, "ENTER_PROFILING_INSTINIT"); + break; + case RETRY_PROFILED_INSTINIT: + fprintf(stderr, "RETRY_PROFILED_INSTINIT"); + break; + case PROFILED_RETRY_ME_INSTINIT: + fprintf(stderr, "PROFILED_RETRY_ME_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case PROFILED_RETRY_ME_FROZEN: + fprintf(stderr, "PROFILED_RETRY_ME_FROZEN"); + break; +#else + case PROFILED_RETRY_ME_NOFROZEN: + fprintf(stderr, "PROFILED_RETRY_ME_NOFROZEN"); + break; +#endif + case PROFILED_RETRY_ME_END: + fprintf(stderr, "PROFILED_RETRY_ME_END"); + break; + case PROFILED_TRUST_ME_INSTINIT: + fprintf(stderr, "PROFILED_TRUST_ME_INSTINIT"); + break; + case PROFILED_TRUST_ME_IF: + fprintf(stderr, "PROFILED_TRUST_ME_IF"); + break; + case PROFILED_TRUST_ME_END: + fprintf(stderr, "PROFILED_TRUST_ME_END"); + break; + case PROFILED_RETRY_LOGICAL_INSTINIT: + fprintf(stderr, "PROFILED_RETRY_LOGICAL_INSTINIT"); + break; +#ifdef THREADS + case PROFILED_RETRY_LOGICAL_THREADS: + fprintf(stderr, "PROFILED_RETRY_LOGICAL_THREADS"); + break; +#endif + case PROFILED_RETRY_LOGICAL_POST_THREADS: + fprintf(stderr, "PROFILED_RETRY_LOGICAL_POST_THREADS"); + break; +#ifdef FROZEN_STACKS + case PROFILED_RETRY_LOGICAL_FROZEN: + fprintf(stderr, "PROFILED_RETRY_LOGICAL_FROZEN"); + break; +#else + case PROFILED_RETRY_LOGICAL_NOFROZEN: + fprintf(stderr, "PROFILED_RETRY_LOGICAL_NOFROZEN"); + break; +#endif + case PROFILED_RETRY_LOGICAL_END: + fprintf(stderr, "PROFILED_RETRY_LOGICAL_END"); + break; + case PROFILED_TRUST_LOGICAL_INSTINIT: + fprintf(stderr, "PROFILED_TRUST_LOGICAL_INSTINIT"); + break; + case PROFILED_TRUST_LOGICAL_END: + fprintf(stderr, "PROFILED_TRUST_LOGICAL_END"); + break; + case COUNT_CALL_INSTINIT: + fprintf(stderr, "COUNT_CALL_INSTINIT"); + break; + case COUNT_CALL_MIDDLE: + fprintf(stderr, "COUNT_CALL_MIDDLE"); + break; + case COUNT_CALL_END: + fprintf(stderr, "COUNT_CALL_END"); + break; + case COUNT_RETRY_INSTINIT: + fprintf(stderr, "COUNT_RETRY_INSTINIT"); + break; + case COUNT_RETRY_MIDDLE: + fprintf(stderr, "COUNT_RETRY_MIDDLE"); + break; + case COUNT_RETRY_END: + fprintf(stderr, "COUNT_RETRY_END"); + break; + case COUNT_RETRY_ME_INSTINIT: + fprintf(stderr, "COUNT_RETRY_ME_INSTINIT"); + break; + case COUNT_RETRY_ME_MIDDLE: + fprintf(stderr, "COUNT_RETRY_ME_MIDDLE"); + break; + case COUNT_RETRY_ME_END: + fprintf(stderr, "COUNT_RETRY_ME_END"); + break; + case COUNT_TRUST_ME_INSTINIT: + fprintf(stderr, "COUNT_TRUST_ME_INSTINIT"); + break; + case COUNT_TRUST_ME_MIDDLE: + fprintf(stderr, "COUNT_TRUST_ME_MIDDLE"); + break; + case COUNT_TRUST_ME_END: + fprintf(stderr, "COUNT_TRUST_ME_END"); + break; + case COUNT_RETRY_LOGICAL_INSTINIT: + fprintf(stderr, "COUNT_RETRY_LOGICAL_INSTINIT"); + break; + case COUNT_RETRY_LOGICAL_END: + fprintf(stderr, "COUNT_RETRY_LOGICAL_END"); + break; + case COUNT_TRUST_LOGICAL_INSTINIT: + fprintf(stderr, "COUNT_TRUST_LOGICAL_INSTINIT"); + break; + case COUNT_TRUST_LOGICAL_END: + fprintf(stderr, "COUNT_TRUST_LOGICAL_END"); + break; + case LOCK_LU_INSTINIT: + fprintf(stderr, "LOCK_LU_INSTINIT"); + break; + case LOCK_LU_END: + fprintf(stderr, "LOCK_LU_END"); + break; + case UNLOCK_LU_INSTINIT: + fprintf(stderr, "UNLOCK_LU_INSTINIT"); + break; +#if defined(YAPOR) || defined(THREADS) + case UNLOCK_LU_YAPOR_THREADS: + fprintf(stderr, "UNLOCK_LU_YAPOR_THREADS"); + break; +#endif + case UNLOCK_LU_END: + fprintf(stderr, "UNLOCK_LU_END"); + break; + case ALLOC_FOR_LOGICAL_PRED_INSTINIT: + fprintf(stderr, "ALLOC_FOR_LOGICAL_PRED_INSTINIT"); + break; +#if MULTIPLE_STACKS + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS: + fprintf(stderr, "ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS"); + break; +#if PARALLEL_YAP + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL: + fprintf(stderr, "ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL"); + break; +#endif + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END: + fprintf(stderr, "ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END"); + break; +#else + case ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT: + fprintf(stderr, "ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT"); + break; + case ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF: + fprintf(stderr, "ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF"); + break; +#endif + case ALLOC_FOR_LOGICAL_PRED_END: + fprintf(stderr, "ALLOC_FOR_LOGICAL_PRED_END"); + break; + case COPY_IDB_TERM_INSTINIT: + fprintf(stderr, "COPY_IDB_TERM_INSTINIT"); + break; + case COPY_IDB_TERM_END: + fprintf(stderr, "COPY_IDB_TERM_END"); + break; + case UNIFY_IDB_TERM_INSTINIT: + fprintf(stderr, "UNIFY_IDB_TERM_INSTINIT"); + break; + case UNIFY_IDB_TERM_END: + fprintf(stderr, "UNIFY_IDB_TERM_END"); + break; + case ENSURE_SPACE_INSTINIT: + fprintf(stderr, "ENSURE_SPACE_INSTINIT"); + break; + case ENSURE_SPACE_END: + fprintf(stderr, "ENSURE_SPACE_END"); + break; + case SPY_OR_TRYMARK_INSTINIT: + fprintf(stderr, "SPY_OR_TRYMARK_INSTINIT"); + break; + case TRY_AND_MARK_INSTINIT: + fprintf(stderr, "TRY_AND_MARK_INSTINIT"); + break; +#if defined(YAPOR) || defined(THREADS) +#ifdef YAPOR + case TRY_AND_MARK_YAPOR_THREADS_YAPOR: + fprintf(stderr, "TRY_AND_MARK_YAPOR_THREADS_YAPOR"); + break; +#endif + case TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF: + fprintf(stderr, "TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF"); + break; +#endif + case TRY_AND_MARK_NOYAPOR_NOTHREADS: + fprintf(stderr, "TRY_AND_MARK_NOYAPOR_NOTHREADS"); + break; +#ifdef YAPOR + case TRY_AND_MARK_SET_LOAD: + fprintf(stderr, "TRY_AND_MARK_SET_LOAD"); + break; +#endif + case TRY_AND_MARK_POST_SET_LOAD: + fprintf(stderr, "TRY_AND_MARK_POST_SET_LOAD"); + break; +#if MULTIPLE_STACKS + case TRY_AND_MARK_MULTIPLE_STACKS: + fprintf(stderr, "TRY_AND_MARK_MULTIPLE_STACKS"); + break; +#else + case TRY_AND_MARK_NOMULTIPLE_STACKS_IF: + fprintf(stderr, "TRY_AND_MARK_NOMULTIPLE_STACKS_IF"); + break; +#endif + case TRY_AND_MARK_END: + fprintf(stderr, "TRY_AND_MARK_END"); + break; + case COUNT_RETRY_AND_MARK_INSTINIT: + fprintf(stderr, "COUNT_RETRY_AND_MARK_INSTINIT"); + break; + case PROFILED_RETRY_AND_MARK_INSTINIT: + fprintf(stderr, "PROFILED_RETRY_AND_MARK_INSTINIT"); + break; + case RETRY_AND_MARK_INSTINIT: + fprintf(stderr, "RETRY_AND_MARK_INSTINIT"); + break; +#ifdef YAPOR + case RETRY_AND_MARK_YAPOR: + fprintf(stderr, "RETRY_AND_MARK_YAPOR"); + break; +#endif + case RETRY_AND_MARK_POST_YAPOR: + fprintf(stderr, "RETRY_AND_MARK_POST_YAPOR"); + break; +#ifdef FROZEN_STACKS + case RETRY_AND_MARK_FROZEN: + fprintf(stderr, "RETRY_AND_MARK_FROZEN"); + break; +#else + case RETRY_AND_MARK_NOFROZEN: + fprintf(stderr, "RETRY_AND_MARK_NOFROZEN"); + break; +#endif + case RETRY_AND_MARK_POST_FROZEN: + fprintf(stderr, "RETRY_AND_MARK_POST_FROZEN"); + break; +#if MULTIPLE_STACKS + case RETRY_AND_MARK_MULTIPLE_STACKS: + fprintf(stderr, "RETRY_AND_MARK_MULTIPLE_STACKS"); + break; +#else + case RETRY_AND_MARK_NOMULTIPLE_STACKS_IF: + fprintf(stderr, "RETRY_AND_MARK_NOMULTIPLE_STACKS_IF"); + break; +#endif + case RETRY_AND_MARK_END: + fprintf(stderr, "RETRY_AND_MARK_END"); + break; + case TRUST_FAIL_INSTINIT: + fprintf(stderr, "TRUST_FAIL_INSTINIT"); + break; +#ifdef CUT_C + case TRUST_FAIL_CUT_C: + fprintf(stderr, "TRUST_FAIL_CUT_C"); + break; +#endif +#ifdef YAPOR + case TRUST_FAIL_YAPOR: + fprintf(stderr, "TRUST_FAIL_YAPOR"); + break; +#endif + case TRUST_FAIL_NOYAPOR: + fprintf(stderr, "TRUST_FAIL_NOYAPOR"); + break; +#ifdef YAPOR + case LBL_SHARED_FAIL: + fprintf(stderr, "LBL_SHARED_FAIL"); + break; +#endif + case OP_FAIL_INSTINIT: + fprintf(stderr, "OP_FAIL_INSTINIT"); + break; + case LBL_FAIL_INSTINIT: + fprintf(stderr, "LBL_FAIL_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case LBL_FAIL_LOW_LEVEL_TRACER: + fprintf(stderr, "LBL_FAIL_LOW_LEVEL_TRACER"); + break; +#endif + case LBL_FAIL_POST_LOW_LEVEL_TRACER: + fprintf(stderr, "LBL_FAIL_POST_LOW_LEVEL_TRACER"); + break; + case LBL_FAIL_VARTERM: + fprintf(stderr, "LBL_FAIL_VARTERM"); + break; + case LBL_FAIL_PAIRTERM_INIT: + fprintf(stderr, "LBL_FAIL_PAIRTERM_INIT"); + break; + case LBL_FAIL_PAIRTERM_END_APPL: + fprintf(stderr, "LBL_FAIL_PAIRTERM_END_APPL"); + break; + case LBL_FAIL_END: + fprintf(stderr, "LBL_FAIL_END"); + break; + case CUT_INSTINIT: + fprintf(stderr, "CUT_INSTINIT"); + break; +#ifdef COROUTINING + case CUT_COROUTINING: + fprintf(stderr, "CUT_COROUTINING"); + break; +#endif + case CUT_NOCOROUTINING: + fprintf(stderr, "CUT_NOCOROUTINING"); + break; + case CUT_T_INSTINIT: + fprintf(stderr, "CUT_T_INSTINIT"); + break; +#ifdef COROUTINING + case CUT_T_COROUTINING: + fprintf(stderr, "CUT_T_COROUTINING"); + break; +#endif + case CUT_T_NOCOROUTINING: + fprintf(stderr, "CUT_T_NOCOROUTINING"); + break; + case CUT_E_INSTINIT: + fprintf(stderr, "CUT_E_INSTINIT"); + break; +#ifdef COROUTINING + case CUT_E_COROUTINING: + fprintf(stderr, "CUT_E_COROUTINING"); + break; +#endif + case CUT_E_NOCOROUTINING: + fprintf(stderr, "CUT_E_NOCOROUTINING"); + break; + case SAVE_B_X_INSTINIT: + fprintf(stderr, "SAVE_B_X_INSTINIT"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case SAVE_B_X_YSBA_FROZEN: + fprintf(stderr, "SAVE_B_X_YSBA_FROZEN"); + break; +#else + case SAVE_B_X_NOYSBA_NOFROZEN: + fprintf(stderr, "SAVE_B_X_NOYSBA_NOFROZEN"); + break; +#endif + case SAVE_B_X_END: + fprintf(stderr, "SAVE_B_X_END"); + break; + case SAVE_B_Y_INSTINIT: + fprintf(stderr, "SAVE_B_Y_INSTINIT"); + break; +#if defined(YAPOR_SBA) + case SAVE_B_Y_YSBA: + fprintf(stderr, "SAVE_B_Y_YSBA"); + break; +#else + case SAVE_B_Y_NOYSBA: + fprintf(stderr, "SAVE_B_Y_NOYSBA"); + break; +#endif + case SAVE_B_Y_END: + fprintf(stderr, "SAVE_B_Y_END"); + break; + case COMMIT_B_X_INSTINIT: + fprintf(stderr, "COMMIT_B_X_INSTINIT"); + break; + case COMMIT_B_X_DO_COMMIT_B_X: + fprintf(stderr, "COMMIT_B_X_DO_COMMIT_B_X"); + break; + case COMMIT_B_X_COMMIT_B_X_NVAR: + fprintf(stderr, "COMMIT_B_X_COMMIT_B_X_NVAR"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case COMMIT_B_X_YSBA_FROZEN: + fprintf(stderr, "COMMIT_B_X_YSBA_FROZEN"); + break; +#else + case COMMIT_B_X_NOYSBA_NOFROZEN: + fprintf(stderr, "COMMIT_B_X_NOYSBA_NOFROZEN"); + break; +#endif + case COMMIT_B_X_POST_YSBA_FROZEN: + fprintf(stderr, "COMMIT_B_X_POST_YSBA_FROZEN"); + break; + case COMMIT_B_X_END: + fprintf(stderr, "COMMIT_B_X_END"); + break; + case COMMIT_B_Y_INSTINIT: + fprintf(stderr, "COMMIT_B_Y_INSTINIT"); + break; + case COMMIT_B_Y_DO_COMMIT_B_Y: + fprintf(stderr, "COMMIT_B_Y_DO_COMMIT_B_Y"); + break; + case COMMIT_B_Y_COMMIT_B_Y_NVAR: + fprintf(stderr, "COMMIT_B_Y_COMMIT_B_Y_NVAR"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case COMMIT_B_Y_YSBA_FROZEN: + fprintf(stderr, "COMMIT_B_Y_YSBA_FROZEN"); + break; +#else + case COMMIT_B_Y_NOYSBA_NOFROZEN: + fprintf(stderr, "COMMIT_B_Y_NOYSBA_NOFROZEN"); + break; +#endif + case COMMIT_B_Y_POST_YSBA_FROZEN: + fprintf(stderr, "COMMIT_B_Y_POST_YSBA_FROZEN"); + break; + case COMMIT_B_Y_END: + fprintf(stderr, "COMMIT_B_Y_END"); + break; + case EXECUTE_INSTINIT: + fprintf(stderr, "EXECUTE_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case EXECUTE_LOW_LEVEL_TRACER: + fprintf(stderr, "EXECUTE_LOW_LEVEL_TRACER"); + break; +#endif + case EXECUTE_POST_LOW_LEVEL_TRACER: + fprintf(stderr, "EXECUTE_POST_LOW_LEVEL_TRACER"); + break; + case EXECUTE_POST_NOCHECKING: + fprintf(stderr, "EXECUTE_POST_NOCHECKING"); + break; +#ifdef DEPTH_LIMIT + case EXECUTE_DEPTH_MINOR: + fprintf(stderr, "EXECUTE_DEPTH_MINOR"); + break; + case EXECUTE_DEPTH_MOFPRED: + fprintf(stderr, "EXECUTE_DEPTH_MOFPRED"); + break; + case EXECUTE_DEPTH_END: + fprintf(stderr, "EXECUTE_DEPTH_END"); + break; +#endif + case EXECUTE_END_END: + fprintf(stderr, "EXECUTE_END_END"); + break; + case DEXECUTE_INSTINIT: + fprintf(stderr, "DEXECUTE_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case DEXECUTE_LOW_LEVEL_TRACER: + fprintf(stderr, "DEXECUTE_LOW_LEVEL_TRACER"); + break; +#endif + case DEXECUTE_POST_LOW_LEVEL_TRACER: + fprintf(stderr, "DEXECUTE_POST_LOW_LEVEL_TRACER"); + break; +#ifdef DEPTH_LIMIT + case DEXECUTE_DEPTH_MINOR: + fprintf(stderr, "DEXECUTE_DEPTH_MINOR"); + break; + case DEXECUTE_DEPTH_MOFPRED: + fprintf(stderr, "DEXECUTE_DEPTH_MOFPRED"); + break; + case DEXECUTE_DEPTH_END: + fprintf(stderr, "DEXECUTE_DEPTH_END"); + break; +#endif + case DEXECUTE_END_END: + fprintf(stderr, "DEXECUTE_END_END"); + break; + case FCALL_INST: + break; + case CALL_INSTINIT: + fprintf(stderr, "CALL_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case CALL_LOW_LEVEL_TRACER: + fprintf(stderr, "CALL_LOW_LEVEL_TRACER"); + break; +#endif + case CALL_POST_LOW_LEVEL_TRACER: + fprintf(stderr, "CALL_POST_LOW_LEVEL_TRACER"); + break; + case CALL_POST_NO_CHECKING: + fprintf(stderr, "CALL_POST_NO_CHECKING"); + break; +#ifdef DEPTH_LIMIT + case CALL_DEPTH_MINOR: + fprintf(stderr, "CALL_DEPTH_MINOR"); + break; + case CALL_DEPTH_MOFPRED: + fprintf(stderr, "CALL_DEPTH_MOFPRED"); + break; + case CALL_DEPTH_END: + fprintf(stderr, "CALL_DEPTH_END"); + break; +#endif + case CALL_END_END: + fprintf(stderr, "CALL_END_END"); + break; + case PROCCEED_INSTINIT: + fprintf(stderr, "PROCCEED_INSTINIT"); + break; +#ifdef DEPTH_LIMIT + case PROCCEED_DEPTH: + fprintf(stderr, "PROCCEED_DEPTH"); + break; +#endif + case PROCCEED_END: + fprintf(stderr, "PROCCEED_END"); + break; + case ALLOCATE_INSTINIT: + fprintf(stderr, "ALLOCATE_INSTINIT"); + break; +#ifdef DEPTH_LIMIT + case ALLOCATE_DEPTH: + fprintf(stderr, "ALLOCATE_DEPTH"); + break; +#endif + case ALLOCATE_END: + fprintf(stderr, "ALLOCATE_END"); + break; + case DEALLOCATE_INSTINIT: + fprintf(stderr, "DEALLOCATE_INSTINIT"); + break; + case DEALLOCATE_POST_CHECK: + fprintf(stderr, "DEALLOCATE_POST_CHECK"); + break; +#ifdef DEPTH_LIMIT + case DEALLOCATE_DEPTH: + fprintf(stderr, "DEALLOCATE_DEPTH"); + break; +#endif + case DEALLOCATE_FROZEN: + fprintf(stderr, "DEALLOCATE_FROZEN"); + break; + case DEALLOCATE_POST_FROZEN: + fprintf(stderr, "DEALLOCATE_POST_FROZEN"); + break; + case DEALLOCATE_END: + fprintf(stderr, "DEALLOCATE_END"); + break; + case GET_X_VAR_INSTINIT: + fprintf(stderr, "GET_X_VAR_INSTINIT"); + break; + case GET_Y_VAR_INSTINIT: + fprintf(stderr, "GET_Y_VAR_INSTINIT"); + break; + case GET_YY_VAR_INSTINIT: + fprintf(stderr, "GET_YY_VAR_INSTINIT"); + break; + case GET_X_VAL_INSTINIT: + fprintf(stderr, "GET_X_VAL_INSTINIT"); + break; + case GET_X_VAL_GVALX_NONVAR: + fprintf(stderr, "GET_X_VAL_GVALX_NONVAR"); + break; + case GET_X_VAL_GVALX_NONVAR_NONVAR: + fprintf(stderr, "GET_X_VAL_GVALX_NONVAR_NONVAR"); + break; + case GET_X_VAL_GVALX_NONVAR_UNK: + fprintf(stderr, "GET_X_VAL_GVALX_NONVAR_UNK"); + break; + case GET_X_VAL_GVALX_UNK: + fprintf(stderr, "GET_X_VAL_GVALX_UNK"); + break; + case GET_X_VAL_GVALX_VAR_NONVAR: + fprintf(stderr, "GET_X_VAL_GVALX_VAR_NONVAR"); + break; + case GET_X_VAL_GVALX_VAR_UNK: + fprintf(stderr, "GET_X_VAL_GVALX_VAR_UNK"); + break; + case GET_Y_VAL_INSTINIT: + fprintf(stderr, "GET_Y_VAL_INSTINIT"); + break; + case GET_Y_VAL_GVALY_NONVAR: + fprintf(stderr, "GET_Y_VAL_GVALY_NONVAR"); + break; + case GET_Y_VAL_GVALY_NONVAR_NONVAR: + fprintf(stderr, "GET_Y_VAL_GVALY_NONVAR_NONVAR"); + break; + case GET_Y_VAL_GVALY_NONVAR_UNK: + fprintf(stderr, "GET_Y_VAL_GVALY_NONVAR_UNK"); + break; + case GET_Y_VAL_GVALY_UNK: + fprintf(stderr, "GET_Y_VAL_GVALY_UNK"); + break; + case GET_Y_VAL_GVALY_VAR_NONVAR: + fprintf(stderr, "GET_Y_VAL_GVALY_VAR_NONVAR"); + break; + case GET_Y_VAL_GVALY_VAR_UNK: + fprintf(stderr, "GET_Y_VAL_GVALY_VAR_UNK"); + break; + case GET_ATOM_INSTINIT: + fprintf(stderr, "GET_ATOM_INSTINIT"); + break; + case GET_ATOM_GATOM_NONVAR: + fprintf(stderr, "GET_ATOM_GATOM_NONVAR"); + break; + case GET_ATOM_GATOM_UNK: + fprintf(stderr, "GET_ATOM_GATOM_UNK"); + break; + case GET_2ATOMS_INSTINIT: + fprintf(stderr, "GET_2ATOMS_INSTINIT"); + break; + case GET_2ATOMS_GATOM_2UNK: + fprintf(stderr, "GET_2ATOMS_GATOM_2UNK"); + break; + case GET_2ATOMS_GATOM_2B: + fprintf(stderr, "GET_2ATOMS_GATOM_2B"); + break; + case GET_2ATOMS_GATOM_2BNONVAR: + fprintf(stderr, "GET_2ATOMS_GATOM_2BNONVAR"); + break; + case GET_2ATOMS_GATOM_2BUNK: + fprintf(stderr, "GET_2ATOMS_GATOM_2BUNK"); + break; + case GET_3ATOMS_INSTINIT: + fprintf(stderr, "GET_3ATOMS_INSTINIT"); + break; + case GET_3ATOMS_GATOM_3UNK: + fprintf(stderr, "GET_3ATOMS_GATOM_3UNK"); + break; + case GET_3ATOMS_GATOM_3B: + fprintf(stderr, "GET_3ATOMS_GATOM_3B"); + break; + case GET_3ATOMS_GATOM_3BUNK: + fprintf(stderr, "GET_3ATOMS_GATOM_3BUNK"); + break; + case GET_3ATOMS_GATOM_3C: + fprintf(stderr, "GET_3ATOMS_GATOM_3C"); + break; + case GET_3ATOMS_GATOM_3CNONVAR: + fprintf(stderr, "GET_3ATOMS_GATOM_3CNONVAR"); + break; + case GET_3ATOMS_GATOM_3CUNK: + fprintf(stderr, "GET_3ATOMS_GATOM_3CUNK"); + break; + case GET_4ATOMS_INSTINIT: + fprintf(stderr, "GET_4ATOMS_INSTINIT"); + break; + case GET_4ATOMS_GATOM_4UNK: + fprintf(stderr, "GET_4ATOMS_GATOM_4UNK"); + break; + case GET_4ATOMS_GATOM_4B: + fprintf(stderr, "GET_4ATOMS_GATOM_4B"); + break; + case GET_4ATOMS_GATOM_4BUNK: + fprintf(stderr, "GET_4ATOMS_GATOM_4BUNK"); + break; + case GET_4ATOMS_GATOM_4C: + fprintf(stderr, "GET_4ATOMS_GATOM_4C"); + break; + case GET_4ATOMS_GATOM_4CUNK: + fprintf(stderr, "GET_4ATOMS_GATOM_4CUNK"); + break; + case GET_4ATOMS_GATOM_4D: + fprintf(stderr, "GET_4ATOMS_GATOM_4D"); + break; + case GET_4ATOMS_GATOM_4DNONVAR: + fprintf(stderr, "GET_4ATOMS_GATOM_4DNONVAR"); + break; + case GET_4ATOMS_GATOM_4DUNK: + fprintf(stderr, "GET_4ATOMS_GATOM_4DUNK"); + break; + case GET_5ATOMS_INSTINIT: + fprintf(stderr, "GET_5ATOMS_INSTINIT"); + break; + case GET_5ATOMS_GATOM_5UNK: + fprintf(stderr, "GET_5ATOMS_GATOM_5UNK"); + break; + case GET_5ATOMS_GATOM_5B: + fprintf(stderr, "GET_5ATOMS_GATOM_5B"); + break; + case GET_5ATOMS_GATOM_5BUNK: + fprintf(stderr, "GET_5ATOMS_GATOM_5BUNK"); + break; + case GET_5ATOMS_GATOM_5C: + fprintf(stderr, "GET_5ATOMS_GATOM_5C"); + break; + case GET_5ATOMS_GATOM_5CUNK: + fprintf(stderr, "GET_5ATOMS_GATOM_5CUNK"); + break; + case GET_5ATOMS_GATOM_5D: + fprintf(stderr, "GET_5ATOMS_GATOM_5D"); + break; + case GET_5ATOMS_GATOM_5DUNK: + fprintf(stderr, "GET_5ATOMS_GATOM_5DUNK"); + break; + case GET_5ATOMS_GATOM_5E: + fprintf(stderr, "GET_5ATOMS_GATOM_5E"); + break; + case GET_5ATOMS_GATOM_5ENONVAR: + fprintf(stderr, "GET_5ATOMS_GATOM_5ENONVAR"); + break; + case GET_5ATOMS_GATOM_5EUNK: + fprintf(stderr, "GET_5ATOMS_GATOM_5EUNK"); + break; + case GET_6ATOMS_INSTINIT: + fprintf(stderr, "GET_6ATOMS_INSTINIT"); + break; + case GET_6ATOMS_GATOM_6UNK: + fprintf(stderr, "GET_6ATOMS_GATOM_6UNK"); + break; + case GET_6ATOMS_GATOM_6B: + fprintf(stderr, "GET_6ATOMS_GATOM_6B"); + break; + case GET_6ATOMS_GATOM_6BUNK: + fprintf(stderr, "GET_6ATOMS_GATOM_6BUNK"); + break; + case GET_6ATOMS_GATOM_6C: + fprintf(stderr, "GET_6ATOMS_GATOM_6C"); + break; + case GET_6ATOMS_GATOM_6CUNK: + fprintf(stderr, "GET_6ATOMS_GATOM_6CUNK"); + break; + case GET_6ATOMS_GATOM_6D: + fprintf(stderr, "GET_6ATOMS_GATOM_6D"); + break; + case GET_6ATOMS_GATOM_6DUNK: + fprintf(stderr, "GET_6ATOMS_GATOM_6DUNK"); + break; + case GET_6ATOMS_GATOM_6E: + fprintf(stderr, "GET_6ATOMS_GATOM_6E"); + break; + case GET_6ATOMS_GATOM_6EUNK: + fprintf(stderr, "GET_6ATOMS_GATOM_6EUNK"); + break; + case GET_6ATOMS_GATOM_6F: + fprintf(stderr, "GET_6ATOMS_GATOM_6F"); + break; + case GET_6ATOMS_GATOM_6FNONVAR: + fprintf(stderr, "GET_6ATOMS_GATOM_6FNONVAR"); + break; + case GET_6ATOMS_GATOM_6FUNK: + fprintf(stderr, "GET_6ATOMS_GATOM_6FUNK"); + break; + case GET_LIST_INSTINIT: + fprintf(stderr, "GET_LIST_INSTINIT"); + break; + case GET_LIST_GLIST_NONVAR: + fprintf(stderr, "GET_LIST_GLIST_NONVAR"); + break; + case GET_LIST_GLIST_UNK: + fprintf(stderr, "GET_LIST_GLIST_UNK"); + break; + case GET_STRUCT_INSTINIT: + fprintf(stderr, "GET_STRUCT_INSTINIT"); + break; + case GET_STRUCT_GSTRUCT_NONVAR: + fprintf(stderr, "GET_STRUCT_GSTRUCT_NONVAR"); + break; + case GET_STRUCT_GSTRUCT_UNK: + fprintf(stderr, "GET_STRUCT_GSTRUCT_UNK"); + break; + case GET_FLOAT_INSTINIT: + fprintf(stderr, "GET_FLOAT_INSTINIT"); + break; + case GET_FLOAT_GFLOAT_NONVAR: + fprintf(stderr, "GET_FLOAT_GFLOAT_NONVAR"); + break; + case GET_FLOAT_GFLOAT_UNK: + fprintf(stderr, "GET_FLOAT_GFLOAT_UNK"); + break; + case GET_LONGINT_INSTINIT: + fprintf(stderr, "GET_LONGINT_INSTINIT"); + break; + case GET_LONGINT_GLONGINT_NONVAR: + fprintf(stderr, "GET_LONGINT_GLONGINT_NONVAR"); + break; + case GET_LONGINT_GLONGINT_UNK: + fprintf(stderr, "GET_LONGINT_GLONGINT_UNK"); + break; +#ifdef USE_GMP + case GET_BIGINT_INSTINIT: + fprintf(stderr, "GET_BIGINT_INSTINIT"); + break; + case GET_BIGINT_GBIGINT_NONVAR: + fprintf(stderr, "GET_BIGINT_GBIGINT_NONVAR"); + break; + case GET_BIGINT_GBIGINT_UNK: + fprintf(stderr, "GET_BIGINT_GBIGINT_UNK"); + break; +#endif + case GET_DBTERM_INSTINIT: + fprintf(stderr, "GET_DBTERM_INSTINIT"); + break; + case GET_DBTERM_GDBTERM_NONVAR: + fprintf(stderr, "GET_DBTERM_GDBTERM_NONVAR"); + break; + case GET_DBTERM_GDBTERM_UNK: + fprintf(stderr, "GET_DBTERM_GDBTERM_UNK"); + break; + case GLIST_VALX_INSTINIT: + fprintf(stderr, "GLIST_VALX_INSTINIT"); + break; + case GLIST_VALX_GLIST_VALX_READ: + fprintf(stderr, "GLIST_VALX_GLIST_VALX_READ"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR: + fprintf(stderr, "GLIST_VALX_GLIST_VALX_NONVAR"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR_NONVAR: + fprintf(stderr, "GLIST_VALX_GLIST_VALX_NONVAR_NONVAR"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR_UNK: + fprintf(stderr, "GLIST_VALX_GLIST_VALX_NONVAR_UNK"); + break; + case GLIST_VALX_GLIST_VALX_UNK: + fprintf(stderr, "GLIST_VALX_GLIST_VALX_UNK"); + break; + case GLIST_VALX_GLIST_VALX_VAR_NONVAR: + fprintf(stderr, "GLIST_VALX_GLIST_VALX_VAR_NONVAR"); + break; + case GLIST_VALX_GLIST_VALX_VAR_UNK: + fprintf(stderr, "GLIST_VALX_GLIST_VALX_VAR_UNK"); + break; + case GLIST_VALX_GLIST_VALX_WRITE: + fprintf(stderr, "GLIST_VALX_GLIST_VALX_WRITE"); + break; + case GLIST_VALY_INSTINIT: + fprintf(stderr, "GLIST_VALY_INSTINIT"); + break; + case GLIST_VALY_GLIST_VALY_READ: + fprintf(stderr, "GLIST_VALY_GLIST_VALY_READ"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR: + fprintf(stderr, "GLIST_VALY_GLIST_VALY_NONVAR"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR_NONVAR: + fprintf(stderr, "GLIST_VALY_GLIST_VALY_NONVAR_NONVAR"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR_UNK: + fprintf(stderr, "GLIST_VALY_GLIST_VALY_NONVAR_UNK"); + break; + case GLIST_VALY_GLIST_VALY_UNK: + fprintf(stderr, "GLIST_VALY_GLIST_VALY_UNK"); + break; + case GLIST_VALY_GLIST_VALY_VAR_NONVAR: + fprintf(stderr, "GLIST_VALY_GLIST_VALY_VAR_NONVAR"); + break; + case GLIST_VALY_GLIST_VALY_VAR_UNK: + fprintf(stderr, "GLIST_VALY_GLIST_VALY_VAR_UNK"); + break; + case GLIST_VALY_GLIST_VALY_WRITE: + fprintf(stderr, "GLIST_VALY_GLIST_VALY_WRITE"); + break; + case GL_VOID_VARX_INSTINIT: + fprintf(stderr, "GL_VOID_VARX_INSTINIT"); + break; + case GL_VOID_VARX_GLIST_VOID_VARX_READ: + fprintf(stderr, "GL_VOID_VARX_GLIST_VOID_VARX_READ"); + break; + case GL_VOID_VARX_GLIST_VOID_VAR_WRITE: + fprintf(stderr, "GL_VOID_VARX_GLIST_VOID_VAR_WRITE"); + break; + case GL_VOID_VARY_INSTINIT: + fprintf(stderr, "GL_VOID_VARY_INSTINIT"); + break; + case GL_VOID_VARY_GLIST_VOID_VARY_READ: + fprintf(stderr, "GL_VOID_VARY_GLIST_VOID_VARY_READ"); + break; + case GL_VOID_VARY_GLIST_VOID_VARY_WRITE: + fprintf(stderr, "GL_VOID_VARY_GLIST_VOID_VARY_WRITE"); + break; + case GL_VOID_VALX_INSTINIT: + fprintf(stderr, "GL_VOID_VALX_INSTINIT"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_READ: + fprintf(stderr, "GL_VOID_VALX_GLIST_VOID_VALX_READ"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR: + fprintf(stderr, "GL_VOID_VALX_GLIST_VOID_VALX_NONVAR"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR: + fprintf(stderr, "GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK: + fprintf(stderr, "GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_UNK: + fprintf(stderr, "GL_VOID_VALX_GLIST_VOID_VALX_UNK"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR: + fprintf(stderr, "GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK: + fprintf(stderr, "GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_WRITE: + fprintf(stderr, "GL_VOID_VALX_GLIST_VOID_VALX_WRITE"); + break; + case GL_VOID_VALY_INSTINIT: + fprintf(stderr, "GL_VOID_VALY_INSTINIT"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_READ: + fprintf(stderr, "GL_VOID_VALY_GLIST_VOID_VALY_READ"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR: + fprintf(stderr, "GL_VOID_VALY_GLIST_VOID_VALY_NONVAR"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR: + fprintf(stderr, "GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK: + fprintf(stderr, "GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_UNK: + fprintf(stderr, "GL_VOID_VALY_GLIST_VOID_VALY_UNK"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR: + fprintf(stderr, "GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK: + fprintf(stderr, "GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_WRITE: + fprintf(stderr, "GL_VOID_VALY_GLIST_VOID_VALY_WRITE"); + break; + case UNIFY_X_VAR_INSTINIT: + fprintf(stderr, "UNIFY_X_VAR_INSTINIT"); + break; +#ifdef YAPOR_SBA + case UNIFY_X_VAR_YAPOR_SBA: + fprintf(stderr, "UNIFY_X_VAR_YAPOR_SBA"); + break; +#endif + case UNIFY_X_VAR_END: + fprintf(stderr, "UNIFY_X_VAR_END"); + break; + case UNIFY_X_VAR_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_X_VAR_WRITE_INSTINIT"); + break; + case UNIFY_L_X_VAR_INSTINIT: + fprintf(stderr, "UNIFY_L_X_VAR_INSTINIT"); + break; +#ifdef YAPOR_SBA + case UNIFY_L_X_VAR_YAPOR_SBA: + fprintf(stderr, "UNIFY_L_X_VAR_YAPOR_SBA"); + break; +#endif + case UNIFY_L_X_VAR_END: + fprintf(stderr, "UNIFY_L_X_VAR_END"); + break; + case UNIFY_L_X_VAR_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_X_VAR_WRITE_INSTINIT"); + break; + case UNIFY_X_VAR2_INSTINIT: + fprintf(stderr, "UNIFY_X_VAR2_INSTINIT"); + break; +#ifdef YAPOR_SBA + case UNIFY_X_VAR2_YAPOR_SBA: + fprintf(stderr, "UNIFY_X_VAR2_YAPOR_SBA"); + break; +#endif + case UNIFY_X_VAR2_END: + fprintf(stderr, "UNIFY_X_VAR2_END"); + break; + case UNIFY_X_VAR2_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_X_VAR2_WRITE_INSTINIT"); + break; + case UNIFY_L_X_VAR2_INSTINIT: + fprintf(stderr, "UNIFY_L_X_VAR2_INSTINIT"); + break; + case UNIFY_L_X_VAR2_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_X_VAR2_WRITE_INSTINIT"); + break; + case UNIFY_Y_VAR_INSTINIT: + fprintf(stderr, "UNIFY_Y_VAR_INSTINIT"); + break; + case UNIFY_Y_VAR_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_Y_VAR_WRITE_INSTINIT"); + break; + case UNIFY_L_Y_VAR_INSTINIT: + fprintf(stderr, "UNIFY_L_Y_VAR_INSTINIT"); + break; + case UNIFY_L_Y_VAR_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_Y_VAR_WRITE_INSTINIT"); + break; + case UNIFY_X_VAL_INSTINIT: + fprintf(stderr, "UNIFY_X_VAL_INSTINIT"); + break; + case UNIFY_X_VAL_UVALX_NONVAR: + fprintf(stderr, "UNIFY_X_VAL_UVALX_NONVAR"); + break; + case UNIFY_X_VAL_UVALX_NONVAR_NONVAR: + fprintf(stderr, "UNIFY_X_VAL_UVALX_NONVAR_NONVAR"); + break; + case UNIFY_X_VAL_UVALX_NONVAR_UNK: + fprintf(stderr, "UNIFY_X_VAL_UVALX_NONVAR_UNK"); + break; + case UNIFY_X_VAL_UVALX_UNK: + fprintf(stderr, "UNIFY_X_VAL_UVALX_UNK"); + break; + case UNIFY_X_VAL_UVALX_VAR_NONVAR: + fprintf(stderr, "UNIFY_X_VAL_UVALX_VAR_NONVAR"); + break; + case UNIFY_X_VAL_UVALX_VAR_UNK: + fprintf(stderr, "UNIFY_X_VAL_UVALX_VAR_UNK"); + break; + case UNIFY_X_VAL_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_X_VAL_WRITE_INSTINIT"); + break; + case UNIFY_L_X_VAL_INSTINIT: + fprintf(stderr, "UNIFY_L_X_VAL_INSTINIT"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR: + fprintf(stderr, "UNIFY_L_X_VAL_ULVALX_NONVAR"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR: + fprintf(stderr, "UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR_UNK: + fprintf(stderr, "UNIFY_L_X_VAL_ULVALX_NONVAR_UNK"); + break; + case UNIFY_L_X_VAL_ULVALX_UNK: + fprintf(stderr, "UNIFY_L_X_VAL_ULVALX_UNK"); + break; + case UNIFY_L_X_VAL_ULVALX_VAR_NONVAR: + fprintf(stderr, "UNIFY_L_X_VAL_ULVALX_VAR_NONVAR"); + break; + case UNIFY_L_X_VAL_ULVALX_VAR_UNK: + fprintf(stderr, "UNIFY_L_X_VAL_ULVALX_VAR_UNK"); + break; + case UNIFY_L_X_VAL_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_X_VAL_WRITE_INSTINIT"); + break; + case UNIFY_Y_VAL_INSTINIT: + fprintf(stderr, "UNIFY_Y_VAL_INSTINIT"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR: + fprintf(stderr, "UNIFY_Y_VAL_UVALY_NONVAR"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR_NONVAR: + fprintf(stderr, "UNIFY_Y_VAL_UVALY_NONVAR_NONVAR"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR_UNK: + fprintf(stderr, "UNIFY_Y_VAL_UVALY_NONVAR_UNK"); + break; + case UNIFY_Y_VAL_UVALY_UNK: + fprintf(stderr, "UNIFY_Y_VAL_UVALY_UNK"); + break; + case UNIFY_Y_VAL_UVALY_VAR_NONVAR: + fprintf(stderr, "UNIFY_Y_VAL_UVALY_VAR_NONVAR"); + break; + case UNIFY_Y_VAL_UVALY_VAR_UNK: + fprintf(stderr, "UNIFY_Y_VAL_UVALY_VAR_UNK"); + break; + case UNIFY_Y_VAL_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_Y_VAL_WRITE_INSTINIT"); + break; + case UNIFY_L_Y_VAL_INSTINIT: + fprintf(stderr, "UNIFY_L_Y_VAL_INSTINIT"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR: + fprintf(stderr, "UNIFY_L_Y_VAL_ULVALY_NONVAR"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR: + fprintf(stderr, "UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK: + fprintf(stderr, "UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK"); + break; + case UNIFY_L_Y_VAL_ULVALY_UNK: + fprintf(stderr, "UNIFY_L_Y_VAL_ULVALY_UNK"); + break; + case UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR: + fprintf(stderr, "UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR"); + break; + case UNIFY_L_Y_VAL_ULVALY_VAR_UNK: + fprintf(stderr, "UNIFY_L_Y_VAL_ULVALY_VAR_UNK"); + break; + case UNIFY_L_Y_VAL_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_Y_VAL_WRITE_INSTINIT"); + break; + case UNIFY_X_LOC_INSTINIT: + fprintf(stderr, "UNIFY_X_LOC_INSTINIT"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR: + fprintf(stderr, "UNIFY_X_LOC_UVALX_LOC_NONVAR"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR: + fprintf(stderr, "UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK: + fprintf(stderr, "UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK"); + break; + case UNIFY_X_LOC_UVALX_LOC_UNK: + fprintf(stderr, "UNIFY_X_LOC_UVALX_LOC_UNK"); + break; + case UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR: + fprintf(stderr, "UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR"); + break; + case UNIFY_X_LOC_UVALX_LOC_VAR_UNK: + fprintf(stderr, "UNIFY_X_LOC_UVALX_LOC_VAR_UNK"); + break; + case UNIFY_X_LOC_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_X_LOC_WRITE_INSTINIT"); + break; + case UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR: + fprintf(stderr, "UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR"); + break; + case UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK: + fprintf(stderr, "UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK"); + break; + case UNIFY_L_X_LOC_INSTINIT: + fprintf(stderr, "UNIFY_L_X_LOC_INSTINIT"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR: + fprintf(stderr, "UNIFY_L_X_LOC_ULVALX_LOC_NONVAR"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR: + fprintf(stderr, "UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK: + fprintf(stderr, "UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_UNK: + fprintf(stderr, "UNIFY_L_X_LOC_ULVALX_LOC_UNK"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR: + fprintf(stderr, "UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK: + fprintf(stderr, "UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK"); + break; + case UNIFY_L_X_LOC_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_X_LOC_WRITE_INSTINIT"); + break; + case UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR: + fprintf(stderr, "UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR"); + break; + case UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK: + fprintf(stderr, "UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK"); + break; + case UNIFY_Y_LOC_INSTINIT: + fprintf(stderr, "UNIFY_Y_LOC_INSTINIT"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR: + fprintf(stderr, "UNIFY_Y_LOC_UVALY_LOC_NONVAR"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR: + fprintf(stderr, "UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK: + fprintf(stderr, "UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK"); + break; + case UNIFY_Y_LOC_UVALY_LOC_UNK: + fprintf(stderr, "UNIFY_Y_LOC_UVALY_LOC_UNK"); + break; + case UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR: + fprintf(stderr, "UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR"); + break; + case UNIFY_Y_LOC_UVALY_LOC_VAR_UNK: + fprintf(stderr, "UNIFY_Y_LOC_UVALY_LOC_VAR_UNK"); + break; + case UNIFY_Y_LOC_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_Y_LOC_WRITE_INSTINIT"); + break; + case UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR: + fprintf(stderr, "UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR"); + break; + case UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK: + fprintf(stderr, "UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK"); + break; + case UNIFY_L_Y_LOC_INSTINIT: + fprintf(stderr, "UNIFY_L_Y_LOC_INSTINIT"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR: + fprintf(stderr, "UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR: + fprintf(stderr, "UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK: + fprintf(stderr, "UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_UNK: + fprintf(stderr, "UNIFY_L_Y_LOC_ULVALY_LOC_UNK"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR: + fprintf(stderr, "UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK: + fprintf(stderr, "UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK"); + break; + case UNIFY_L_Y_LOC_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_Y_LOC_WRITE_INSTINIT"); + break; + case UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR: + fprintf(stderr, "UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR"); + break; + case UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK: + fprintf(stderr, "UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK"); + break; + case UNIFY_VOID_INSTINIT: + fprintf(stderr, "UNIFY_VOID_INSTINIT"); + break; + case UNIFY_VOID_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_VOID_WRITE_INSTINIT"); + break; + case UNIFY_L_VOID_INSTINIT: + fprintf(stderr, "UNIFY_L_VOID_INSTINIT"); + break; + case UNIFY_L_VOID_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_VOID_WRITE_INSTINIT"); + break; + case UNIFY_N_VOIDS_INSTINIT: + fprintf(stderr, "UNIFY_N_VOIDS_INSTINIT"); + break; + case UNIFY_N_VOIDS_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_N_VOIDS_WRITE_INSTINIT"); + break; + case UNIFY_L_N_VOIDS_INSTINIT: + fprintf(stderr, "UNIFY_L_N_VOIDS_INSTINIT"); + break; + case UNIFY_L_N_VOIDS_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_N_VOIDS_WRITE_INSTINIT"); + break; + case UNIFY_ATOM_INSTINIT: + fprintf(stderr, "UNIFY_ATOM_INSTINIT"); + break; + case UNIFY_ATOM_UATOM_NONVAR: + fprintf(stderr, "UNIFY_ATOM_UATOM_NONVAR"); + break; + case UNIFY_ATOM_UATOM_UNK: + fprintf(stderr, "UNIFY_ATOM_UATOM_UNK"); + break; + case UNIFY_ATOM_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_ATOM_WRITE_INSTINIT"); + break; + case UNIFY_L_ATOM_INSTINIT: + fprintf(stderr, "UNIFY_L_ATOM_INSTINIT"); + break; + case UNIFY_L_ATOM_ULATOM_NONVAR: + fprintf(stderr, "UNIFY_L_ATOM_ULATOM_NONVAR"); + break; + case UNIFY_L_ATOM_ULATOM_UNK: + fprintf(stderr, "UNIFY_L_ATOM_ULATOM_UNK"); + break; + case UNIFY_L_ATOM_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_ATOM_WRITE_INSTINIT"); + break; + case UNIFY_N_ATOMS_INSTINIT: + fprintf(stderr, "UNIFY_N_ATOMS_INSTINIT"); + break; + case UNIFY_N_ATOMS_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_N_ATOMS_WRITE_INSTINIT"); + break; + case UNIFY_FLOAT_INSTINIT: + fprintf(stderr, "UNIFY_FLOAT_INSTINIT"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_INIT: + fprintf(stderr, "UNIFY_FLOAT_UFLOAT_NONVAR_INIT"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR: + fprintf(stderr, "UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_END: + fprintf(stderr, "UNIFY_FLOAT_UFLOAT_NONVAR_END"); + break; + case UNIFY_FLOAT_UFLOAT_UNK: + fprintf(stderr, "UNIFY_FLOAT_UFLOAT_UNK"); + break; + case UNIFY_FLOAT_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_FLOAT_WRITE_INSTINIT"); + break; + case UNIFY_L_FLOAT_INSTINIT: + fprintf(stderr, "UNIFY_L_FLOAT_INSTINIT"); + break; + case UNIFY_L_FLOAT_D0ISAPPL: + fprintf(stderr, "UNIFY_L_FLOAT_D0ISAPPL"); + break; + case UNIFY_L_FLOAT_D0ISFUNC: + fprintf(stderr, "UNIFY_L_FLOAT_D0ISFUNC"); + break; + case UNIFY_L_FLOAT_EQUALS: + fprintf(stderr, "UNIFY_L_FLOAT_EQUALS"); + break; + case UNIFY_L_FLOAT_ULFLOAT_UNK: + fprintf(stderr, "UNIFY_L_FLOAT_ULFLOAT_UNK"); + break; + case UNIFY_L_FLOAT_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_FLOAT_WRITE_INSTINIT"); + break; + case UNIFY_LONGINT_INSTINIT: + fprintf(stderr, "UNIFY_LONGINT_INSTINIT"); + break; + case UNIFY_LONGINT_D0ISAPPL: + fprintf(stderr, "UNIFY_LONGINT_D0ISAPPL"); + break; + case UNIFY_LONGINT_D0ISFUNC: + fprintf(stderr, "UNIFY_LONGINT_D0ISFUNC"); + break; + case UNIFY_LONGINT_EQUALS: + fprintf(stderr, "UNIFY_LONGINT_EQUALS"); + break; + case UNIFY_LONGINT_ULONGINT_UNK: + fprintf(stderr, "UNIFY_LONGINT_ULONGINT_UNK"); + break; + case UNIFY_LONGINT_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_LONGINT_WRITE_INSTINIT"); + break; + case UNIFY_L_LONGINT_INSTINIT: + fprintf(stderr, "UNIFY_L_LONGINT_INSTINIT"); + break; + case UNIFY_L_LONGINT_D0ISAPPL: + fprintf(stderr, "UNIFY_L_LONGINT_D0ISAPPL"); + break; + case UNIFY_L_LONGINT_D0ISFUNC: + fprintf(stderr, "UNIFY_L_LONGINT_D0ISFUNC"); + break; + case UNIFY_L_LONGINT_EQUALS: + fprintf(stderr, "UNIFY_L_LONGINT_EQUALS"); + break; + case UNIFY_L_LONGINT_ULLONGINT_UNK: + fprintf(stderr, "UNIFY_L_LONGINT_ULLONGINT_UNK"); + break; + case UNIFY_L_LONGINT_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_LONGINT_WRITE_INSTINIT"); + break; +#ifdef USE_GMP + case UNIFY_BIGINT_INSTINIT: + fprintf(stderr, "UNIFY_BIGINT_INSTINIT"); + break; + case UNIFY_BIGINT_D0ISAPPL: + fprintf(stderr, "UNIFY_BIGINT_D0ISAPPL"); + break; + case UNIFY_BIGINT_D1ISFUNC_GMP: + fprintf(stderr, "UNIFY_BIGINT_D1ISFUNC_GMP"); + break; + case UNIFY_BIGINT_UBIGINT_UNK: + fprintf(stderr, "UNIFY_BIGINT_UBIGINT_UNK"); + break; + case UNIFY_L_BIGINT_INSTINIT: + fprintf(stderr, "UNIFY_L_BIGINT_INSTINIT"); + break; + case UNIFY_L_BIGINT_D0ISAPPL: + fprintf(stderr, "UNIFY_L_BIGINT_D0ISAPPL"); + break; + case UNIFY_L_BIGINT_D0ISFUNC_GMP: + fprintf(stderr, "UNIFY_L_BIGINT_D0ISFUNC_GMP"); + break; + case UNIFY_L_BIGINT_ULBIGINT_UNK: + fprintf(stderr, "UNIFY_L_BIGINT_ULBIGINT_UNK"); + break; +#endif + case UNIFY_DBTERM_INSTINIT: + fprintf(stderr, "UNIFY_DBTERM_INSTINIT"); + break; + case UNIFY_DBTERM_UDBTERM_NONVAR: + fprintf(stderr, "UNIFY_DBTERM_UDBTERM_NONVAR"); + break; + case UNIFY_DBTERM_UDBTERM_UNK: + fprintf(stderr, "UNIFY_DBTERM_UDBTERM_UNK"); + break; + case UNIFY_L_DBTERM_INSTINIT: + fprintf(stderr, "UNIFY_L_DBTERM_INSTINIT"); + break; + case UNIFY_L_DBTERM_ULDBTERM_NONVAR: + fprintf(stderr, "UNIFY_L_DBTERM_ULDBTERM_NONVAR"); + break; + case UNIFY_L_DBTERM_ULDBTERM_UNK: + fprintf(stderr, "UNIFY_L_DBTERM_ULDBTERM_UNK"); + break; + case UNIFY_LIST_INSTINIT: + fprintf(stderr, "UNIFY_LIST_INSTINIT"); + break; + case UNIFY_LIST_READMODE: + fprintf(stderr, "UNIFY_LIST_READMODE"); + break; + case UNIFY_LIST_WRITEMODE: + fprintf(stderr, "UNIFY_LIST_WRITEMODE"); + break; + case UNIFY_LIST_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_LIST_WRITE_INSTINIT"); + break; + case UNIFY_L_LIST_INSTINIT: + fprintf(stderr, "UNIFY_L_LIST_INSTINIT"); + break; + case UNIFY_L_LIST_READMODE: + fprintf(stderr, "UNIFY_L_LIST_READMODE"); + break; + case UNIFY_L_LIST_WRITEMODE: + fprintf(stderr, "UNIFY_L_LIST_WRITEMODE"); + break; + case UNIFY_L_LIST_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_LIST_WRITE_INSTINIT"); + break; + case UNIFY_STRUCT_INSTINIT: + fprintf(stderr, "UNIFY_STRUCT_INSTINIT"); + break; + case UNIFY_STRUCT_READMODE: + fprintf(stderr, "UNIFY_STRUCT_READMODE"); + break; + case UNIFY_STRUCT_WRITEMODE: + fprintf(stderr, "UNIFY_STRUCT_WRITEMODE"); + break; + case UNIFY_STRUCT_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_STRUCT_WRITE_INSTINIT"); + break; + case UNIFY_L_STRUC_INSTINIT: + fprintf(stderr, "UNIFY_L_STRUC_INSTINIT"); + break; + case UNIFY_L_STRUC_READMODE: + fprintf(stderr, "UNIFY_L_STRUC_READMODE"); + break; + case UNIFY_L_STRUC_WRITEMODE: + fprintf(stderr, "UNIFY_L_STRUC_WRITEMODE"); + break; + case UNIFY_L_STRUC_WRITE_INSTINIT: + fprintf(stderr, "UNIFY_L_STRUC_WRITE_INSTINIT"); + break; + case PUT_X_VAR_INSTINIT: + fprintf(stderr, "PUT_X_VAR_INSTINIT"); + break; + case PUT_Y_VAR_INSTINIT: + fprintf(stderr, "PUT_Y_VAR_INSTINIT"); + break; + case PUT_X_VAL_INSTINIT: + fprintf(stderr, "PUT_X_VAL_INSTINIT"); + break; + case PUT_XX_VAL_INSTINIT: + fprintf(stderr, "PUT_XX_VAL_INSTINIT"); + break; + case PUT_Y_VAL_INSTINIT: + fprintf(stderr, "PUT_Y_VAL_INSTINIT"); + break; + case PUT_Y_VALS_INSTINIT: + fprintf(stderr, "PUT_Y_VALS_INSTINIT"); + break; + case PUT_UNSAFE_INSTINIT: + fprintf(stderr, "PUT_UNSAFE_INSTINIT"); + break; + case PUT_UNSAFE_PUNSAFE_NONVAR: + fprintf(stderr, "PUT_UNSAFE_PUNSAFE_NONVAR"); + break; + case PUT_UNSAFE_PUNSAFE_UNK: + fprintf(stderr, "PUT_UNSAFE_PUNSAFE_UNK"); + break; + case PUT_ATOM_INSTINIT: + fprintf(stderr, "PUT_ATOM_INSTINIT"); + break; + case PUT_DBTERM_INSTINIT: + fprintf(stderr, "PUT_DBTERM_INSTINIT"); + break; + case PUT_BIGINT_INSTINIT: + fprintf(stderr, "PUT_BIGINT_INSTINIT"); + break; + case PUT_FLOAT_INSTINIT: + fprintf(stderr, "PUT_FLOAT_INSTINIT"); + break; + case PUT_LONGINT_INSTINIT: + fprintf(stderr, "PUT_LONGINT_INSTINIT"); + break; + case PUT_LIST_INSTINIT: + fprintf(stderr, "PUT_LIST_INSTINIT"); + break; + case PUT_STRUCT_INSTINIT: + fprintf(stderr, "PUT_STRUCT_INSTINIT"); + break; + case WRITE_X_VAR_INSTINIT: + fprintf(stderr, "WRITE_X_VAR_INSTINIT"); + break; + case WRITE_VOID_INSTINIT: + fprintf(stderr, "WRITE_VOID_INSTINIT"); + break; + case WRITE_N_VOIDS_INSTINIT: + fprintf(stderr, "WRITE_N_VOIDS_INSTINIT"); + break; + case WRITE_Y_VAR_INSTINIT: + fprintf(stderr, "WRITE_Y_VAR_INSTINIT"); + break; + case WRITE_X_VAL_INSTINIT: + fprintf(stderr, "WRITE_X_VAL_INSTINIT"); + break; + case WRITE_X_LOC_INSTINIT: + fprintf(stderr, "WRITE_X_LOC_INSTINIT"); + break; + case WRITE_X_LOC_W_X_BOUND: + fprintf(stderr, "WRITE_X_LOC_W_X_BOUND"); + break; + case WRITE_X_LOC_W_X_UNK: + fprintf(stderr, "WRITE_X_LOC_W_X_UNK"); + break; + case WRITE_Y_VAL_INSTINIT: + fprintf(stderr, "WRITE_Y_VAL_INSTINIT"); + break; + case WRITE_Y_LOC_INSTINIT: + fprintf(stderr, "WRITE_Y_LOC_INSTINIT"); + break; + case WRITE_Y_LOC_W_Y_BOUND: + fprintf(stderr, "WRITE_Y_LOC_W_Y_BOUND"); + break; + case WRITE_Y_LOC_W_Y_UNK: + fprintf(stderr, "WRITE_Y_LOC_W_Y_UNK"); + break; + case WRITE_ATOM_INSTINIT: + fprintf(stderr, "WRITE_ATOM_INSTINIT"); + break; + case WRITE_BIGINT_INSTINIT: + fprintf(stderr, "WRITE_BIGINT_INSTINIT"); + break; + case WRITE_DBTERM_INSTINIT: + fprintf(stderr, "WRITE_DBTERM_INSTINIT"); + break; + case WRITE_FLOAT_INSTINIT: + fprintf(stderr, "WRITE_FLOAT_INSTINIT"); + break; + case WRITE_LONGIT_INSTINIT: + fprintf(stderr, "WRITE_LONGIT_INSTINIT"); + break; + case WRITE_N_ATOMS_INSTINIT: + fprintf(stderr, "WRITE_N_ATOMS_INSTINIT"); + break; + case WRITE_LIST_INSTINIT: + fprintf(stderr, "WRITE_LIST_INSTINIT"); + break; + case WRITE_L_LIST_INSTINIT: + fprintf(stderr, "WRITE_L_LIST_INSTINIT"); + break; + case WRITE_STRUCT_INSTINIT: + fprintf(stderr, "WRITE_STRUCT_INSTINIT"); + break; + case WRITE_L_STRUC_INSTINIT: + fprintf(stderr, "WRITE_L_STRUC_INSTINIT"); + break; + case SAVE_PAIR_X_INSTINIT: + fprintf(stderr, "SAVE_PAIR_X_INSTINIT"); + break; + case SAVE_PAIR_X_WRITE_INSTINIT: + fprintf(stderr, "SAVE_PAIR_X_WRITE_INSTINIT"); + break; + case SAVE_PAIR_Y_INSTINIT: + fprintf(stderr, "SAVE_PAIR_Y_INSTINIT"); + break; + case SAVE_PAIR_Y_WRITE_INSTINIT: + fprintf(stderr, "SAVE_PAIR_Y_WRITE_INSTINIT"); + break; + case SAVE_APPL_X_INSTINIT: + fprintf(stderr, "SAVE_APPL_X_INSTINIT"); + break; + case SAVE_APPL_X_WRITE_INSTINIT: + fprintf(stderr, "SAVE_APPL_X_WRITE_INSTINIT"); + break; + case SAVE_APPL_Y_INSTINIT: + fprintf(stderr, "SAVE_APPL_Y_INSTINIT"); + break; + case SAVE_APPL_Y_WRITE_INSTINIT: + fprintf(stderr, "SAVE_APPL_Y_WRITE_INSTINIT"); + break; + case JUMP_INSTINIT: + fprintf(stderr, "JUMP_INSTINIT"); + break; + case MOVE_BACK_INSTINIT: + fprintf(stderr, "MOVE_BACK_INSTINIT"); + break; + case SKIP_INSTINIT: + fprintf(stderr, "SKIP_INSTINIT"); + break; + case EITHER_INSTINIT: + fprintf(stderr, "EITHER_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case EITHER_LOW_LEVEL_TRACER: + fprintf(stderr, "EITHER_LOW_LEVEL_TRACER"); + break; +#endif + case EITHER_POST_COROUTINING: + fprintf(stderr, "EITHER_POST_COROUTINING"); + break; + case EITHER_FROZEN_YSBA: + fprintf(stderr, "EITHER_FROZEN_YSBA"); + break; + case EITHER_POST_FROZEN_YSBA: + fprintf(stderr, "EITHER_POST_FROZEN_YSBA"); + break; +#ifdef YAPOR + case EITHER_YAPOR: + fprintf(stderr, "EITHER_YAPOR"); + break; +#endif + case EITHER_END: + fprintf(stderr, "EITHER_END"); + break; + case OR_ELSE_INSTINIT: + fprintf(stderr, "OR_ELSE_INSTINIT"); + break; +#ifdef DEPTH_LIMIT + case OR_ELSE_DEPTH: + fprintf(stderr, "OR_ELSE_DEPTH"); + break; +#endif + case OR_ELSE_POST_DEPTH: + fprintf(stderr, "OR_ELSE_POST_DEPTH"); + break; +#ifdef YAPOR + case OR_ELSE_YAPOR: + fprintf(stderr, "OR_ELSE_YAPOR"); + break; +#endif + case OR_ELSE_END: + fprintf(stderr, "OR_ELSE_END"); + break; + case OR_LAST_INSTINIT: + fprintf(stderr, "OR_LAST_INSTINIT"); + break; +#ifdef YAPOR + case OR_LAST_IFOK_INIT: + fprintf(stderr, "OR_LAST_IFOK_INIT"); + break; +#ifdef DEPTH_LIMIT + case OR_LAST_IFOK_DEPTH: + fprintf(stderr, "OR_LAST_IFOK_DEPTH"); + break; +#endif + case OR_LAST_IFOK_END: + fprintf(stderr, "OR_LAST_IFOK_END"); + break; +#endif + case OR_LAST_NOIF_INIT: + fprintf(stderr, "OR_LAST_NOIF_INIT"); + break; +#ifdef DEPTH_LIMIT + case OR_LAST_NOIF_DEPTH: + fprintf(stderr, "OR_LAST_NOIF_DEPTH"); + break; +#endif + case OR_LAST_NOIF_END: + fprintf(stderr, "OR_LAST_NOIF_END"); + break; +#ifdef YAPOR + case OR_LAST_YAPOR: + fprintf(stderr, "OR_LAST_YAPOR"); + break; +#else + case OR_LAST_NOYAPOR: + fprintf(stderr, "OR_LAST_NOYAPOR"); + break; +#endif + case OR_LAST_END: + fprintf(stderr, "OR_LAST_END"); + break; + case POP_N_INSTINIT: + fprintf(stderr, "POP_N_INSTINIT"); + break; + case POP_N_END: + fprintf(stderr, "POP_N_END"); + break; + case POP_INSTINIT: + fprintf(stderr, "POP_INSTINIT"); + break; + case POP_END: + fprintf(stderr, "POP_END"); + break; + case CALL_CPRED_INSTINIT: + fprintf(stderr, "CALL_CPRED_INSTINIT"); + break; + case CALL_CPRED_TEST_STACK: + fprintf(stderr, "CALL_CPRED_TEST_STACK"); + break; +#ifdef FROZEN_STACKS + case CALL_CPRED_FROZEN_INIT: + fprintf(stderr, "CALL_CPRED_FROZEN_INIT"); + break; + case CALL_CPRED_TOPB: + fprintf(stderr, "CALL_CPRED_TOPB"); + break; +#else + case CALL_CPRED_NOFROZEN: + fprintf(stderr, "CALL_CPRED_NOFROZEN"); + break; +#endif +#ifdef LOW_LEVEL_TRACER + case CALL_CPRED_LOW_LEVEL_TRACER: + fprintf(stderr, "CALL_CPRED_LOW_LEVEL_TRACER"); + break; +#endif + case CALL_CPRED_POST_LOW_LEVEL_TRACER: + fprintf(stderr, "CALL_CPRED_POST_LOW_LEVEL_TRACER"); + break; +#ifdef SHADOW_S + case CALL_CPRED_SETSREG: + fprintf(stderr, "CALL_CPRED_SETSREG"); + break; +#endif + case CALL_CPRED_END: + fprintf(stderr, "CALL_CPRED_END"); + break; + case EXECUTE_CPRED_INSTINIT: + fprintf(stderr, "EXECUTE_CPRED_INSTINIT"); + break; + case EXECUTE_CPRED_POST_CHECK_TRAIL: + fprintf(stderr, "EXECUTE_CPRED_POST_CHECK_TRAIL"); + break; +#ifdef FROZEN_STACKS + case EXECUTE_CPRED_FROZEN: + fprintf(stderr, "EXECUTE_CPRED_FROZEN"); + break; + case EXECUTE_CPRED_TOPB: + fprintf(stderr, "EXECUTE_CPRED_TOPB"); + break; +#else + case EXECUTE_CPRED_NOFROZEN: + fprintf(stderr, "EXECUTE_CPRED_NOFROZEN"); + break; +#endif + case EXECUTE_CPRED_POST_FROZEN: + fprintf(stderr, "EXECUTE_CPRED_POST_FROZEN"); + break; +#ifdef LOW_LEVEL_TRACER + case EXECUTE_CPRED_LOW_LEVEL_TRACER: + fprintf(stderr, "EXECUTE_CPRED_LOW_LEVEL_TRACER"); + break; +#endif + case EXECUTE_CPRED_POST_LOW_LEVEL_TRACER: + fprintf(stderr, "EXECUTE_CPRED_POST_LOW_LEVEL_TRACER"); + break; + case EXECUTE_CPRED_SAVE_PC: + fprintf(stderr, "EXECUTE_CPRED_SAVE_PC"); + break; +#ifdef DEPTH_LIMIT + case EXECUTE_CPRED_DEPTH_MINOR: + fprintf(stderr, "EXECUTE_CPRED_DEPTH_MINOR"); + break; + case EXECUTE_CPRED_DEPTH_MOFPRED: + fprintf(stderr, "EXECUTE_CPRED_DEPTH_MOFPRED"); + break; + case EXECUTE_CPRED_DEPTH_END: + fprintf(stderr, "EXECUTE_CPRED_DEPTH_END"); + break; +#endif + case EXECUTE_CPRED_END: + fprintf(stderr, "EXECUTE_CPRED_END"); + break; + case CALL_USERCPRED_INSTINIT: + fprintf(stderr, "CALL_USERCPRED_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case CALL_USERCPRED_LOW_LEVEL_TRACER: + fprintf(stderr, "CALL_USERCPRED_LOW_LEVEL_TRACER"); + break; +#endif + case CALL_USERCPRED_FROZEN: + fprintf(stderr, "CALL_USERCPRED_FROZEN"); + break; + case CALL_USERCPRED_POST_FROZEN: + fprintf(stderr, "CALL_USERCPRED_POST_FROZEN"); + break; + case CALL_USERCPRED_END: + fprintf(stderr, "CALL_USERCPRED_END"); + break; + case LOCK_PRED_INSTINIT: + fprintf(stderr, "LOCK_PRED_INSTINIT"); + break; + case LOCK_PRED_FIRSTIFOK: + fprintf(stderr, "LOCK_PRED_FIRSTIFOK"); + break; + case LOCK_PRED_SECONDTIFOK: + fprintf(stderr, "LOCK_PRED_SECONDTIFOK"); + break; + case LOCK_PRED_END: + fprintf(stderr, "LOCK_PRED_END"); + break; + case INDEX_PRED_INSTINIT: + fprintf(stderr, "INDEX_PRED_INSTINIT"); + break; + case INDEX_PRED_END: + fprintf(stderr, "INDEX_PRED_END"); + break; +#if THREADS + case THREAD_LOCAL_INSTINIT: + fprintf(stderr, "THREAD_LOCAL_INSTINIT"); + break; +#endif + case EXPAND_INDEX_INSTINIT: + fprintf(stderr, "EXPAND_INDEX_INSTINIT"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_INDEX_YAPOR_THREADS_NOPP: + fprintf(stderr, "EXPAND_INDEX_YAPOR_THREADS_NOPP"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT: + fprintf(stderr, "EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK: + fprintf(stderr, "EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_END: + fprintf(stderr, "EXPAND_INDEX_YAPOR_THREADS_IFOK_END"); + break; +#endif +#ifdef SHADOW_S + case EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS: + fprintf(stderr, "EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS"); + break; +#endif + case EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS: + fprintf(stderr, "EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS"); + break; +#ifdef SHADOW_S + case EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG: + fprintf(stderr, "EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG"); + break; +#endif + case EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG: + fprintf(stderr, "EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_INDEX_UNLOCK: + fprintf(stderr, "EXPAND_INDEX_UNLOCK"); + break; +#endif + case EXPAND_INDEX_END: + fprintf(stderr, "EXPAND_INDEX_END"); + break; + case EXPAND_CLAUSES_INSTINIT: + fprintf(stderr, "EXPAND_CLAUSES_INSTINIT"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_CLAUSES_YAPOR_THREADS_NOPP: + fprintf(stderr, "EXPAND_CLAUSES_YAPOR_THREADS_NOPP"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT: + fprintf(stderr, "EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK: + fprintf(stderr, "EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END: + fprintf(stderr, "EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END"); + break; +#endif + case EXPAND_CLAUSES_NOYAPOR_NOTHREADS: + fprintf(stderr, "EXPAND_CLAUSES_NOYAPOR_NOTHREADS"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_CLAUSES_UNLOCK: + fprintf(stderr, "EXPAND_CLAUSES_UNLOCK"); + break; +#endif + case EXPAND_CLAUSES_END: + fprintf(stderr, "EXPAND_CLAUSES_END"); + break; + case UNDEF_P_INSTINIT: + fprintf(stderr, "UNDEF_P_INSTINIT"); + break; + case UNDEF_P_END: + fprintf(stderr, "UNDEF_P_END"); + break; + case SPY_PRED_INSTINIT: + fprintf(stderr, "SPY_PRED_INSTINIT"); + break; + case SPY_PRED_FIRSTIFOK: + fprintf(stderr, "SPY_PRED_FIRSTIFOK"); + break; + case SPY_PRED_SECONDIFOK_INIT: + fprintf(stderr, "SPY_PRED_SECONDIFOK_INIT"); + break; + case SPY_PRED_SECONDIFOK_FIRSTIFOK: + fprintf(stderr, "SPY_PRED_SECONDIFOK_FIRSTIFOK"); + break; + case SPY_PRED_SECONDIFOK_POST_FIRSTIF: + fprintf(stderr, "SPY_PRED_SECONDIFOK_POST_FIRSTIF"); + break; + case SPY_PRED_SECONDIFOK_SECONDIFOK: + fprintf(stderr, "SPY_PRED_SECONDIFOK_SECONDIFOK"); + break; + case SPY_PRED_SECONDIFOK_THIRDIFOK: + fprintf(stderr, "SPY_PRED_SECONDIFOK_THIRDIFOK"); + break; + case SPY_PRED_THIRDIFOK_INIT: + fprintf(stderr, "SPY_PRED_THIRDIFOK_INIT"); + break; + case SPY_PRED_THIRDIFOK_FIRSTIFOK: + fprintf(stderr, "SPY_PRED_THIRDIFOK_FIRSTIFOK"); + break; + case SPY_PRED_FOURTHIFOK: + fprintf(stderr, "SPY_PRED_FOURTHIFOK"); + break; + case SPY_PRED_POST_FOURTHIF: + fprintf(stderr, "SPY_PRED_POST_FOURTHIF"); + break; + case SPY_PRED_D0ISZERO: + fprintf(stderr, "SPY_PRED_D0ISZERO"); + break; + case SPY_PRED_D0ISNOZERO_INIT: + fprintf(stderr, "SPY_PRED_D0ISNOZERO_INIT"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT: + fprintf(stderr, "SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR: + fprintf(stderr, "SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR: + fprintf(stderr, "SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR: + fprintf(stderr, "SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR"); + break; + case SPY_PRED_POST_IFS: + fprintf(stderr, "SPY_PRED_POST_IFS"); + break; +#ifdef THREADS + case SPY_PRED_THREADS_LOCK: + fprintf(stderr, "SPY_PRED_THREADS_LOCK"); + break; +#endif + case SPY_PRED_POST_LOCK: + fprintf(stderr, "SPY_PRED_POST_LOCK"); + break; +#ifdef THREADS + case SPY_PRED_THREADS_UNLOCK: + fprintf(stderr, "SPY_PRED_THREADS_UNLOCK"); + break; +#endif + case SPY_PRED_POST_UNLOCK: + fprintf(stderr, "SPY_PRED_POST_UNLOCK"); + break; +#ifdef LOW_LEVEL_TRACER + case SPY_PRED_LOW_LEVEL_TRACER: + fprintf(stderr, "SPY_PRED_LOW_LEVEL_TRACER"); + break; +#endif + case SPY_PRED_END: + fprintf(stderr, "SPY_PRED_END"); + break; + case TRY_CLAUSE_INSTINIT: + fprintf(stderr, "TRY_CLAUSE_INSTINIT"); + break; +#ifdef YAPOR + case TRY_CLAUSE_YAPOR: + fprintf(stderr, "TRY_CLAUSE_YAPOR"); + break; +#endif + case TRY_CLAUSE_END: + fprintf(stderr, "TRY_CLAUSE_END"); + break; + case TRY_CLAUSE2_INSTINIT: + fprintf(stderr, "TRY_CLAUSE2_INSTINIT"); + break; +#ifdef YAPOR + case TRY_CLAUSE2_YAPOR: + fprintf(stderr, "TRY_CLAUSE2_YAPOR"); + break; +#endif + case TRY_CLAUSE2_END: + fprintf(stderr, "TRY_CLAUSE2_END"); + break; + case TRY_CLAUSE3_INSTINIT: + fprintf(stderr, "TRY_CLAUSE3_INSTINIT"); + break; +#ifdef YAPOR + case TRY_CLAUSE3_YAPOR: + fprintf(stderr, "TRY_CLAUSE3_YAPOR"); + break; +#endif + case TRY_CLAUSE3_END: + fprintf(stderr, "TRY_CLAUSE3_END"); + break; + case TRY_CLAUSE4_INSTINIT: + fprintf(stderr, "TRY_CLAUSE4_INSTINIT"); + break; +#ifdef YAPOR + case TRY_CLAUSE4_YAPOR: + fprintf(stderr, "TRY_CLAUSE4_YAPOR"); + break; +#endif + case TRY_CLAUSE4_END: + fprintf(stderr, "TRY_CLAUSE4_END"); + break; + case RETRY_INSTINIT: + fprintf(stderr, "RETRY_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY_FROZEN: + fprintf(stderr, "RETRY_FROZEN"); + break; +#else + case RETRY_NOFROZEN: + fprintf(stderr, "RETRY_NOFROZEN"); + break; +#endif + case RETRY_END: + fprintf(stderr, "RETRY_END"); + break; + case RETRY2_INSTINIT: + fprintf(stderr, "RETRY2_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY2_FROZEN: + fprintf(stderr, "RETRY2_FROZEN"); + break; +#else + case RETRY2_NOFROZEN: + fprintf(stderr, "RETRY2_NOFROZEN"); + break; +#endif + case RETRY2_END: + fprintf(stderr, "RETRY2_END"); + break; + case RETRY3_INSTINIT: + fprintf(stderr, "RETRY3_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY3_FROZEN: + fprintf(stderr, "RETRY3_FROZEN"); + break; +#else + case RETRY3_NOFROZEN: + fprintf(stderr, "RETRY3_NOFROZEN"); + break; +#endif + case RETRY3_END: + fprintf(stderr, "RETRY3_END"); + break; + case RETRY4_INSTINIT: + fprintf(stderr, "RETRY4_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY4_FROZEN: + fprintf(stderr, "RETRY4_FROZEN"); + break; +#else + case RETRY4_NOFROZEN: + fprintf(stderr, "RETRY4_NOFROZEN"); + break; +#endif + case RETRY4_END: + fprintf(stderr, "RETRY4_END"); + break; + case TRUST_INSTINIT: + fprintf(stderr, "TRUST_INSTINIT"); + break; +#ifdef YAPOR + case TRUST_IFOK_INIT: + fprintf(stderr, "TRUST_IFOK_INIT"); + break; +#ifdef FROZEN_STACKS + case TRUST_IFOK_FROZEN: + fprintf(stderr, "TRUST_IFOK_FROZEN"); + break; +#endif + case TRUST_IFOK_END: + fprintf(stderr, "TRUST_IFOK_END"); + break; +#endif + case TRUST_NOIF_INIT: + fprintf(stderr, "TRUST_NOIF_INIT"); + break; +#ifdef FROZEN_STACKS + case TRUST_NOIF_FROZEN: + fprintf(stderr, "TRUST_NOIF_FROZEN"); + break; +#endif + case TRUST_END: + fprintf(stderr, "TRUST_END"); + break; + case TRY_IN_INSTINIT: + fprintf(stderr, "TRY_IN_INSTINIT"); + break; + case TRY_IN_END: + fprintf(stderr, "TRY_IN_END"); + break; + case USER_SWITCH_INSTINIT: + fprintf(stderr, "USER_SWITCH_INSTINIT"); + break; + case USER_SWITCH_END: + fprintf(stderr, "USER_SWITCH_END"); + break; + case SWITCH_ON_TYPE_INSTINIT: + fprintf(stderr, "SWITCH_ON_TYPE_INSTINIT"); + break; + case SWITCH_ON_TYPE_END: + fprintf(stderr, "SWITCH_ON_TYPE_END"); + break; + case SWITCH_LIST_NL_INSTINIT: + fprintf(stderr, "SWITCH_LIST_NL_INSTINIT"); + break; + case SWITCH_LIST_NL_END: + fprintf(stderr, "SWITCH_LIST_NL_END"); + break; + case SWITCH_ON_ARG_TYPE_INSTINIT: + fprintf(stderr, "SWITCH_ON_ARG_TYPE_INSTINIT"); + break; + case SWITCH_ON_ARG_TYPE_END: + fprintf(stderr, "SWITCH_ON_ARG_TYPE_END"); + break; + case SWITCH_ON_SUB_ARG_TYPE_INSTINIT: + fprintf(stderr, "SWITCH_ON_SUB_ARG_TYPE_INSTINIT"); + break; + case SWITCH_ON_SUB_ARG_TYPE_END: + fprintf(stderr, "SWITCH_ON_SUB_ARG_TYPE_END"); + break; + case JUMP_IF_VAR_INSTINIT: + fprintf(stderr, "JUMP_IF_VAR_INSTINIT"); + break; + case JUMP_IF_VAR_END: + fprintf(stderr, "JUMP_IF_VAR_END"); + break; + case JUMP_IF_NONVAR_INSTINIT: + fprintf(stderr, "JUMP_IF_NONVAR_INSTINIT"); + break; + case JUMP_IF_NONVAR_END: + fprintf(stderr, "JUMP_IF_NONVAR_END"); + break; + case IF_NOT_THEN_INSTINIT: + fprintf(stderr, "IF_NOT_THEN_INSTINIT"); + break; + case IF_NOT_THEN_END: + fprintf(stderr, "IF_NOT_THEN_END"); + break; + case SWITCH_ON_FUNC_INSTINIT: + fprintf(stderr, "SWITCH_ON_FUNC_INSTINIT"); + break; + case SWITCH_ON_FUNC_END: + fprintf(stderr, "SWITCH_ON_FUNC_END"); + break; + case SWITCH_ON_CONS_INSTINIT: + fprintf(stderr, "SWITCH_ON_CONS_INSTINIT"); + break; + case SWITCH_ON_CONS_END: + fprintf(stderr, "SWITCH_ON_CONS_END"); + break; + case GO_ON_FUNC_INSTINIT: + fprintf(stderr, "GO_ON_FUNC_INSTINIT"); + break; + case GO_ON_FUNC_END: + fprintf(stderr, "GO_ON_FUNC_END"); + break; + case GO_ON_CONS_INSTINIT: + fprintf(stderr, "GO_ON_CONS_INSTINIT"); + break; + case GO_ON_CONS_END: + fprintf(stderr, "GO_ON_CONS_END"); + break; + case IF_FUNC_INSTINIT: + fprintf(stderr, "IF_FUNC_INSTINIT"); + break; + case IF_FUNC_END: + fprintf(stderr, "IF_FUNC_END"); + break; + case IF_CONS_INSTINIT: + fprintf(stderr, "IF_CONS_INSTINIT"); + break; + case IF_CONS_END: + fprintf(stderr, "IF_CONS_END"); + break; + case INDEX_DBREF_INSTINIT: + fprintf(stderr, "INDEX_DBREF_INSTINIT"); + break; + case INDEX_DBREF_END: + fprintf(stderr, "INDEX_DBREF_END"); + break; + case INDEX_BLOB_INSTINIT: + fprintf(stderr, "INDEX_BLOB_INSTINIT"); + break; + case INDEX_BLOB_END: + fprintf(stderr, "INDEX_BLOB_END"); + break; + case INDEX_LONG_INSTINIT: + fprintf(stderr, "INDEX_LONG_INSTINIT"); + break; + case INDEX_LONG_END: + fprintf(stderr, "INDEX_LONG_END"); + break; + case JIT_HANDLER_INSTINIT: + fprintf(stderr, "JIT_HANDLER_INSTINIT"); + break; + case P_ATOM_X_INSTINIT: + fprintf(stderr, "P_ATOM_X_INSTINIT"); + break; + case P_ATOM_X_ATOM: + fprintf(stderr, "P_ATOM_X_ATOM"); + break; + case P_ATOM_X_NOATOM: + fprintf(stderr, "P_ATOM_X_NOATOM"); + break; + case P_ATOM_Y_INSTINIT: + fprintf(stderr, "P_ATOM_Y_INSTINIT"); + break; + case P_ATOM_Y_IFOK: + fprintf(stderr, "P_ATOM_Y_IFOK"); + break; + case P_ATOM_Y_NOIF: + fprintf(stderr, "P_ATOM_Y_NOIF"); + break; + case P_ATOM_Y_END: + fprintf(stderr, "P_ATOM_Y_END"); + break; + case P_ATOMIC_X_INSTINIT: + fprintf(stderr, "P_ATOMIC_X_INSTINIT"); + break; + case P_ATOMIC_X_NONVAR: + fprintf(stderr, "P_ATOMIC_X_NONVAR"); + break; + case P_ATOMIC_X_VAR: + fprintf(stderr, "P_ATOMIC_X_VAR"); + break; + case P_ATOMIC_X_END: + fprintf(stderr, "P_ATOMIC_X_END"); + break; + case P_ATOMIC_Y_INSTINIT: + fprintf(stderr, "P_ATOMIC_Y_INSTINIT"); + break; + case P_ATOMIC_Y_NONVAR: + fprintf(stderr, "P_ATOMIC_Y_NONVAR"); + break; + case P_ATOMIC_Y_VAR: + fprintf(stderr, "P_ATOMIC_Y_VAR"); + break; + case P_ATOMIC_Y_END: + fprintf(stderr, "P_ATOMIC_Y_END"); + break; + case P_INTEGER_X_INSTINIT: + fprintf(stderr, "P_INTEGER_X_INSTINIT"); + break; + case P_INTEGER_X_INTEGER_X_NVAR_OK: + fprintf(stderr, "P_INTEGER_X_INTEGER_X_NVAR_OK"); + break; + case P_INTEGER_X_INTEGER_X_NVAR_NOOK: + fprintf(stderr, "P_INTEGER_X_INTEGER_X_NVAR_NOOK"); + break; + case P_INTEGER_X_INTEGER_X_UNK: + fprintf(stderr, "P_INTEGER_X_INTEGER_X_UNK"); + break; + case P_INTEGER_Y_INSTINIT: + fprintf(stderr, "P_INTEGER_Y_INSTINIT"); + break; + case P_INTEGER_Y_INTEGER_Y_NVAR_OK: + fprintf(stderr, "P_INTEGER_Y_INTEGER_Y_NVAR_OK"); + break; + case P_INTEGER_Y_INTEGER_Y_NVAR_NOOK: + fprintf(stderr, "P_INTEGER_Y_INTEGER_Y_NVAR_NOOK"); + break; + case P_INTEGER_Y_INTEGER_Y_UNK: + fprintf(stderr, "P_INTEGER_Y_INTEGER_Y_UNK"); + break; + case P_NONVAR_X_INSTINIT: + fprintf(stderr, "P_NONVAR_X_INSTINIT"); + break; + case P_NONVAR_X_NONVAR: + fprintf(stderr, "P_NONVAR_X_NONVAR"); + break; + case P_NONVAR_X_NONONVAR: + fprintf(stderr, "P_NONVAR_X_NONONVAR"); + break; + case P_NONVAR_Y_INSTINIT: + fprintf(stderr, "P_NONVAR_Y_INSTINIT"); + break; + case P_NONVAR_Y_NONVAR: + fprintf(stderr, "P_NONVAR_Y_NONVAR"); + break; + case P_NONVAR_Y_NONONVAR: + fprintf(stderr, "P_NONVAR_Y_NONONVAR"); + break; + case P_NUMBER_X_INSTINIT: + fprintf(stderr, "P_NUMBER_X_INSTINIT"); + break; + case P_NUMBER_X_INT: + fprintf(stderr, "P_NUMBER_X_INT"); + break; + case P_NUMBER_X_FUNCTORINT: + fprintf(stderr, "P_NUMBER_X_FUNCTORINT"); + break; + case P_NUMBER_X_FUNCTORDEFAULT: + fprintf(stderr, "P_NUMBER_X_FUNCTORDEFAULT"); + break; + case P_NUMBER_X_POST_IF: + fprintf(stderr, "P_NUMBER_X_POST_IF"); + break; + case P_NUMBER_X_NUMBER_X_UNK: + fprintf(stderr, "P_NUMBER_X_NUMBER_X_UNK"); + break; + case P_NUMBER_Y_INSTINIT: + fprintf(stderr, "P_NUMBER_Y_INSTINIT"); + break; + case P_NUMBER_Y_INT: + fprintf(stderr, "P_NUMBER_Y_INT"); + break; + case P_NUMBER_Y_FUNCTORINT: + fprintf(stderr, "P_NUMBER_Y_FUNCTORINT"); + break; + case P_NUMBER_Y_FUNCTORDEFAULT: + fprintf(stderr, "P_NUMBER_Y_FUNCTORDEFAULT"); + break; + case P_NUMBER_Y_POST_IF: + fprintf(stderr, "P_NUMBER_Y_POST_IF"); + break; + case P_NUMBER_Y_NUMBER_Y_UNK: + fprintf(stderr, "P_NUMBER_Y_NUMBER_Y_UNK"); + break; + case P_VAR_X_INSTINIT: + fprintf(stderr, "P_VAR_X_INSTINIT"); + break; + case P_VAR_X_NONVAR: + fprintf(stderr, "P_VAR_X_NONVAR"); + break; + case P_VAR_X_VAR: + fprintf(stderr, "P_VAR_X_VAR"); + break; + case P_VAR_Y_INSTINIT: + fprintf(stderr, "P_VAR_Y_INSTINIT"); + break; + case P_VAR_Y_NONVAR: + fprintf(stderr, "P_VAR_Y_NONVAR"); + break; + case P_VAR_Y_VAR: + fprintf(stderr, "P_VAR_Y_VAR"); + break; + case P_DB_REF_X_INSTINIT: + fprintf(stderr, "P_DB_REF_X_INSTINIT"); + break; + case P_DB_REF_X_DBREF: + fprintf(stderr, "P_DB_REF_X_DBREF"); + break; + case P_DB_REF_X_NODBREF: + fprintf(stderr, "P_DB_REF_X_NODBREF"); + break; + case P_DB_REF_X_DBREF_X_UNK: + fprintf(stderr, "P_DB_REF_X_DBREF_X_UNK"); + break; + case P_DB_REF_Y_INSTINIT: + fprintf(stderr, "P_DB_REF_Y_INSTINIT"); + break; + case P_DB_REF_Y_DBREF: + fprintf(stderr, "P_DB_REF_Y_DBREF"); + break; + case P_DB_REF_Y_NODBREF: + fprintf(stderr, "P_DB_REF_Y_NODBREF"); + break; + case P_DB_REF_Y_DBREF_Y_UNK: + fprintf(stderr, "P_DB_REF_Y_DBREF_Y_UNK"); + break; + case P_PRIMITIVE_X_INSTINIT: + fprintf(stderr, "P_PRIMITIVE_X_INSTINIT"); + break; + case P_PRIMITIVE_X_PRIMITIVE: + fprintf(stderr, "P_PRIMITIVE_X_PRIMITIVE"); + break; + case P_PRIMITIVE_X_NOPRIMITIVE: + fprintf(stderr, "P_PRIMITIVE_X_NOPRIMITIVE"); + break; + case P_PRIMITIVE_X_PRIMI_X_UNK: + fprintf(stderr, "P_PRIMITIVE_X_PRIMI_X_UNK"); + break; + case P_PRIMITIVE_Y_INSTINIT: + fprintf(stderr, "P_PRIMITIVE_Y_INSTINIT"); + break; + case P_PRIMITIVE_Y_PRIMITIVE: + fprintf(stderr, "P_PRIMITIVE_Y_PRIMITIVE"); + break; + case P_PRIMITIVE_Y_NOPRIMITIVE: + fprintf(stderr, "P_PRIMITIVE_Y_NOPRIMITIVE"); + break; + case P_PRIMITIVE_Y_PRIMI_Y_UNK: + fprintf(stderr, "P_PRIMITIVE_Y_PRIMI_Y_UNK"); + break; + case P_COMPOUND_X_INSTINIT: + fprintf(stderr, "P_COMPOUND_X_INSTINIT"); + break; + case P_COMPOUND_X_PAIR: + fprintf(stderr, "P_COMPOUND_X_PAIR"); + break; + case P_COMPOUND_X_APPL_IFOK: + fprintf(stderr, "P_COMPOUND_X_APPL_IFOK"); + break; + case P_COMPOUND_X_APPL: + fprintf(stderr, "P_COMPOUND_X_APPL"); + break; + case P_COMPOUND_X_NOAPPL: + fprintf(stderr, "P_COMPOUND_X_NOAPPL"); + break; + case P_COMPOUND_X_COMPOUND_X_UNK: + fprintf(stderr, "P_COMPOUND_X_COMPOUND_X_UNK"); + break; + case P_COMPOUND_Y_INSTINIT: + fprintf(stderr, "P_COMPOUND_Y_INSTINIT"); + break; + case P_COMPOUND_Y_PAIR: + fprintf(stderr, "P_COMPOUND_Y_PAIR"); + break; + case P_COMPOUND_Y_APPL_IFOK: + fprintf(stderr, "P_COMPOUND_Y_APPL_IFOK"); + break; + case P_COMPOUND_Y_APPL: + fprintf(stderr, "P_COMPOUND_Y_APPL"); + break; + case P_COMPOUND_Y_NOAPPL: + fprintf(stderr, "P_COMPOUND_Y_NOAPPL"); + break; + case P_COMPOUND_Y_COMPOUND_Y_UNK: + fprintf(stderr, "P_COMPOUND_Y_COMPOUND_Y_UNK"); + break; + case P_FLOAT_X_INSTINIT: + fprintf(stderr, "P_FLOAT_X_INSTINIT"); + break; + case P_FLOAT_X_FLOAT: + fprintf(stderr, "P_FLOAT_X_FLOAT"); + break; + case P_FLOAT_X_POST_IF: + fprintf(stderr, "P_FLOAT_X_POST_IF"); + break; + case P_FLOAT_X_FLOAT_X_UNK: + fprintf(stderr, "P_FLOAT_X_FLOAT_X_UNK"); + break; + case P_FLOAT_Y_INSTINIT: + fprintf(stderr, "P_FLOAT_Y_INSTINIT"); + break; + case P_FLOAT_Y_FLOAT: + fprintf(stderr, "P_FLOAT_Y_FLOAT"); + break; + case P_FLOAT_Y_POST_IF: + fprintf(stderr, "P_FLOAT_Y_POST_IF"); + break; + case P_FLOAT_Y_FLOAT_Y_UNK: + fprintf(stderr, "P_FLOAT_Y_FLOAT_Y_UNK"); + break; + case P_PLUS_VV_INSTINIT: + fprintf(stderr, "P_PLUS_VV_INSTINIT"); + break; + case P_PLUS_VV_PLUS_VV_NVAR: + fprintf(stderr, "P_PLUS_VV_PLUS_VV_NVAR"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT: + fprintf(stderr, "P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT: + fprintf(stderr, "P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT"); + break; + case P_PLUS_VV_PLUS_VV_UNK: + fprintf(stderr, "P_PLUS_VV_PLUS_VV_UNK"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_UNK: + fprintf(stderr, "P_PLUS_VV_PLUS_VV_NVAR_UNK"); + break; + case P_PLUS_VC_INSTINIT: + fprintf(stderr, "P_PLUS_VC_INSTINIT"); + break; + case P_PLUS_VC_PLUS_VC_NVAR_INT: + fprintf(stderr, "P_PLUS_VC_PLUS_VC_NVAR_INT"); + break; + case P_PLUS_VC_PLUS_VC_NVAR_NOINT: + fprintf(stderr, "P_PLUS_VC_PLUS_VC_NVAR_NOINT"); + break; + case P_PLUS_VC_PLUS_VC_UNK: + fprintf(stderr, "P_PLUS_VC_PLUS_VC_UNK"); + break; + case P_PLUS_Y_VV_INSTINIT: + fprintf(stderr, "P_PLUS_Y_VV_INSTINIT"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR: + fprintf(stderr, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT: + fprintf(stderr, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT: + fprintf(stderr, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_UNK: + fprintf(stderr, "P_PLUS_Y_VV_PLUS_Y_VV_UNK"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK: + fprintf(stderr, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK"); + break; + case P_PLUS_Y_VC_INSTINIT: + fprintf(stderr, "P_PLUS_Y_VC_INSTINIT"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT: + fprintf(stderr, "P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT: + fprintf(stderr, "P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_UNK: + fprintf(stderr, "P_PLUS_Y_VC_PLUS_Y_VC_UNK"); + break; + case P_MINUS_VV_INSTINIT: + fprintf(stderr, "P_MINUS_VV_INSTINIT"); + break; + case P_MINUS_VV_MINUS_VV_NVAR: + fprintf(stderr, "P_MINUS_VV_MINUS_VV_NVAR"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT: + fprintf(stderr, "P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT: + fprintf(stderr, "P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT"); + break; + case P_MINUS_VV_MINUS_VV_UNK: + fprintf(stderr, "P_MINUS_VV_MINUS_VV_UNK"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_UNK: + fprintf(stderr, "P_MINUS_VV_MINUS_VV_NVAR_UNK"); + break; + case P_MINUS_CV_INSTINIT: + fprintf(stderr, "P_MINUS_CV_INSTINIT"); + break; + case P_MINUS_CV_MINUS_CV_NVAR_INT: + fprintf(stderr, "P_MINUS_CV_MINUS_CV_NVAR_INT"); + break; + case P_MINUS_CV_MINUS_CV_NVAR_NOINT: + fprintf(stderr, "P_MINUS_CV_MINUS_CV_NVAR_NOINT"); + break; + case P_MINUS_CV_MINUS_CV_UNK: + fprintf(stderr, "P_MINUS_CV_MINUS_CV_UNK"); + break; + case P_MINUS_Y_VV_INSTINIT: + fprintf(stderr, "P_MINUS_Y_VV_INSTINIT"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_NVAR: + fprintf(stderr, "P_MINUS_Y_VV_MINUS_Y_VV_NVAR"); + break; + case P_MINUS_Y_VV_INTTERM: + fprintf(stderr, "P_MINUS_Y_VV_INTTERM"); + break; + case P_MINUS_Y_VV_NOINTTERM: + fprintf(stderr, "P_MINUS_Y_VV_NOINTTERM"); + break; + case P_MINUS_Y_VV_D0EQUALS0L: + fprintf(stderr, "P_MINUS_Y_VV_D0EQUALS0L"); + break; + case P_MINUS_Y_VV_NVAR_END: + fprintf(stderr, "P_MINUS_Y_VV_NVAR_END"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_UNK: + fprintf(stderr, "P_MINUS_Y_VV_MINUS_Y_VV_UNK"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK: + fprintf(stderr, "P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK"); + break; + case P_MINUS_Y_CV_INSTINIT: + fprintf(stderr, "P_MINUS_Y_CV_INSTINIT"); + break; + case P_MINUS_Y_CV_MINUS_Y_CV_NVAR: + fprintf(stderr, "P_MINUS_Y_CV_MINUS_Y_CV_NVAR"); + break; + case P_MINUS_Y_CV_INTTERM: + fprintf(stderr, "P_MINUS_Y_CV_INTTERM"); + break; + case P_MINUS_Y_CV_NOINTTERM: + fprintf(stderr, "P_MINUS_Y_CV_NOINTTERM"); + break; + case P_MINUS_Y_CV_D0EQUALS0L: + fprintf(stderr, "P_MINUS_Y_CV_D0EQUALS0L"); + break; + case P_MINUS_Y_CV_NVAR_END: + fprintf(stderr, "P_MINUS_Y_CV_NVAR_END"); + break; + case P_MINUS_Y_CV_MINUS_Y_CV_UNK: + fprintf(stderr, "P_MINUS_Y_CV_MINUS_Y_CV_UNK"); + break; + case P_TIMES_VV_INSTINIT: + fprintf(stderr, "P_TIMES_VV_INSTINIT"); + break; + case P_TIMES_VV_TIMES_VV_NVAR: + fprintf(stderr, "P_TIMES_VV_TIMES_VV_NVAR"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT: + fprintf(stderr, "P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT: + fprintf(stderr, "P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT"); + break; + case P_TIMES_VV_TIMES_VV_UNK: + fprintf(stderr, "P_TIMES_VV_TIMES_VV_UNK"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_UNK: + fprintf(stderr, "P_TIMES_VV_TIMES_VV_NVAR_UNK"); + break; + case P_TIMES_VC_INSTINIT: + fprintf(stderr, "P_TIMES_VC_INSTINIT"); + break; + case P_TIMES_VC_TIMES_VC_NVAR_INT: + fprintf(stderr, "P_TIMES_VC_TIMES_VC_NVAR_INT"); + break; + case P_TIMES_VC_TIMES_VC_NVAR_NOINT: + fprintf(stderr, "P_TIMES_VC_TIMES_VC_NVAR_NOINT"); + break; + case P_TIMES_VC_TIMES_VC_UNK: + fprintf(stderr, "P_TIMES_VC_TIMES_VC_UNK"); + break; + case P_TIMES_Y_VV_INSTINIT: + fprintf(stderr, "P_TIMES_Y_VV_INSTINIT"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_NVAR: + fprintf(stderr, "P_TIMES_Y_VV_TIMES_Y_VV_NVAR"); + break; + case P_TIMES_Y_VV_INTTERM: + fprintf(stderr, "P_TIMES_Y_VV_INTTERM"); + break; + case P_TIMES_Y_VV_NOINTTERM: + fprintf(stderr, "P_TIMES_Y_VV_NOINTTERM"); + break; + case P_TIMES_Y_VV_D0EQUALS0L: + fprintf(stderr, "P_TIMES_Y_VV_D0EQUALS0L"); + break; + case P_TIMES_Y_VV_NVAR_END: + fprintf(stderr, "P_TIMES_Y_VV_NVAR_END"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_UNK: + fprintf(stderr, "P_TIMES_Y_VV_TIMES_Y_VV_UNK"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK: + fprintf(stderr, "P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK"); + break; + case P_TIMES_Y_VC_INSTINIT: + fprintf(stderr, "P_TIMES_Y_VC_INSTINIT"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT: + fprintf(stderr, "P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT: + fprintf(stderr, "P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT"); + break; + case P_TIMES_Y_VC_NVAR_END: + fprintf(stderr, "P_TIMES_Y_VC_NVAR_END"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_UNK: + fprintf(stderr, "P_TIMES_Y_VC_TIMES_Y_VC_UNK"); + break; + case P_DIV_VV_INSTINIT: + fprintf(stderr, "P_DIV_VV_INSTINIT"); + break; + case P_DIV_VV_DIV_VV_NVAR: + fprintf(stderr, "P_DIV_VV_DIV_VV_NVAR"); + break; + case P_DIV_VV_DIV_VV_NVAR_NVAR_INT: + fprintf(stderr, "P_DIV_VV_DIV_VV_NVAR_NVAR_INT"); + break; + case P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT: + fprintf(stderr, "P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT"); + break; + case P_DIV_VV_DIV_VV_UNK: + fprintf(stderr, "P_DIV_VV_DIV_VV_UNK"); + break; + case P_DIV_VV_DIV_VV_NVAR_UNK: + fprintf(stderr, "P_DIV_VV_DIV_VV_NVAR_UNK"); + break; + case P_DIV_VC_INSTINIT: + fprintf(stderr, "P_DIV_VC_INSTINIT"); + break; + case P_DIV_VC_DIV_VC_NVAR: + fprintf(stderr, "P_DIV_VC_DIV_VC_NVAR"); + break; + case P_DIV_VC_INTTERM: + fprintf(stderr, "P_DIV_VC_INTTERM"); + break; + case P_DIV_VC_NOINTTERM: + fprintf(stderr, "P_DIV_VC_NOINTTERM"); + break; + case P_DIV_VC_D0EQUALS0L: + fprintf(stderr, "P_DIV_VC_D0EQUALS0L"); + break; + case P_DIV_VC_NVAR_END: + fprintf(stderr, "P_DIV_VC_NVAR_END"); + break; + case P_DIV_VC_DIV_VC_UNK: + fprintf(stderr, "P_DIV_VC_DIV_VC_UNK"); + break; + case P_DIV_CV_INSTINIT: + fprintf(stderr, "P_DIV_CV_INSTINIT"); + break; + case P_DIV_CV_DIV_CV_NVAR: + fprintf(stderr, "P_DIV_CV_DIV_CV_NVAR"); + break; + case P_DIV_CV_INTTERM_INIT: + fprintf(stderr, "P_DIV_CV_INTTERM_INIT"); + break; + case P_DIV_CV_INTTERM_DIVEQUALS0: + fprintf(stderr, "P_DIV_CV_INTTERM_DIVEQUALS0"); + break; + case P_DIV_CV_INTTERM_END: + fprintf(stderr, "P_DIV_CV_INTTERM_END"); + break; + case P_DIV_CV_NOINTTERM: + fprintf(stderr, "P_DIV_CV_NOINTTERM"); + break; + case P_DIV_CV_D0EQUALS0L: + fprintf(stderr, "P_DIV_CV_D0EQUALS0L"); + break; + case P_DIV_CV_NVAR_END: + fprintf(stderr, "P_DIV_CV_NVAR_END"); + break; + case P_DIV_CV_DIV_CV_UNK: + fprintf(stderr, "P_DIV_CV_DIV_CV_UNK"); + break; + case P_DIV_Y_VV_INSTINIT: + fprintf(stderr, "P_DIV_Y_VV_INSTINIT"); + break; + case P_DIV_Y_VV_DIV_Y_VV_NVAR: + fprintf(stderr, "P_DIV_Y_VV_DIV_Y_VV_NVAR"); + break; + case P_DIV_Y_VV_INTTERM_INIT: + fprintf(stderr, "P_DIV_Y_VV_INTTERM_INIT"); + break; + case P_DIV_Y_VV_INTTERM_DIVEQUALS0: + fprintf(stderr, "P_DIV_Y_VV_INTTERM_DIVEQUALS0"); + break; + case P_DIV_Y_VV_INTTERM_END: + fprintf(stderr, "P_DIV_Y_VV_INTTERM_END"); + break; + case P_DIV_Y_VV_NOINTTERM: + fprintf(stderr, "P_DIV_Y_VV_NOINTTERM"); + break; + case P_DIV_Y_VV_D0EQUALS0L: + fprintf(stderr, "P_DIV_Y_VV_D0EQUALS0L"); + break; + case P_DIV_Y_VV_NVAR_END: + fprintf(stderr, "P_DIV_Y_VV_NVAR_END"); + break; + case P_DIV_Y_VV_DIV_Y_VV_UNK: + fprintf(stderr, "P_DIV_Y_VV_DIV_Y_VV_UNK"); + break; + case P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK: + fprintf(stderr, "P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK"); + break; + case P_DIV_Y_VC_INSTINIT: + fprintf(stderr, "P_DIV_Y_VC_INSTINIT"); + break; + case P_DIV_Y_VC_DIV_Y_VC_NVAR: + fprintf(stderr, "P_DIV_Y_VC_DIV_Y_VC_NVAR"); + break; + case P_DIV_Y_VC_INTTERM: + fprintf(stderr, "P_DIV_Y_VC_INTTERM"); + break; + case P_DIV_Y_VC_NOINTTERM: + fprintf(stderr, "P_DIV_Y_VC_NOINTTERM"); + break; + case P_DIV_Y_VC_D0EQUALS0L: + fprintf(stderr, "P_DIV_Y_VC_D0EQUALS0L"); + break; + case P_DIV_Y_VC_NVAR_END: + fprintf(stderr, "P_DIV_Y_VC_NVAR_END"); + break; + case P_DIV_Y_VC_DIV_Y_VC_UNK: + fprintf(stderr, "P_DIV_Y_VC_DIV_Y_VC_UNK"); + break; + case P_DIV_Y_CV_INSTINIT: + fprintf(stderr, "P_DIV_Y_CV_INSTINIT"); + break; + case P_DIV_Y_CV_DIV_Y_CV_NVAR: + fprintf(stderr, "P_DIV_Y_CV_DIV_Y_CV_NVAR"); + break; + case P_DIV_Y_CV_INTTERM_INIT: + fprintf(stderr, "P_DIV_Y_CV_INTTERM_INIT"); + break; + case P_DIV_Y_CV_INTTERM_DIVEQUALS0: + fprintf(stderr, "P_DIV_Y_CV_INTTERM_DIVEQUALS0"); + break; + case P_DIV_Y_CV_INTTERM_END: + fprintf(stderr, "P_DIV_Y_CV_INTTERM_END"); + break; + case P_DIV_Y_CV_NOINTTERM: + fprintf(stderr, "P_DIV_Y_CV_NOINTTERM"); + break; + case P_DIV_Y_CV_D0EQUALS0L: + fprintf(stderr, "P_DIV_Y_CV_D0EQUALS0L"); + break; + case P_DIV_Y_CV_NVAR_END: + fprintf(stderr, "P_DIV_Y_CV_NVAR_END"); + break; + case P_DIV_Y_CV_DIV_Y_CV_UNK: + fprintf(stderr, "P_DIV_Y_CV_DIV_Y_CV_UNK"); + break; + case P_AND_VV_INSTINIT: + fprintf(stderr, "P_AND_VV_INSTINIT"); + break; + case P_AND_VV_AND_VV_NVAR: + fprintf(stderr, "P_AND_VV_AND_VV_NVAR"); + break; + case P_AND_VV_AND_VV_NVAR_NVAR_INT: + fprintf(stderr, "P_AND_VV_AND_VV_NVAR_NVAR_INT"); + break; + case P_AND_VV_AND_VV_NVAR_NVAR_NOINT: + fprintf(stderr, "P_AND_VV_AND_VV_NVAR_NVAR_NOINT"); + break; + case P_AND_VV_AND_VV_UNK: + fprintf(stderr, "P_AND_VV_AND_VV_UNK"); + break; + case P_AND_VV_AND_VV_NVAR_UNK: + fprintf(stderr, "P_AND_VV_AND_VV_NVAR_UNK"); + break; + case P_AND_VC_INSTINIT: + fprintf(stderr, "P_AND_VC_INSTINIT"); + break; + case P_AND_VC_AND_VC_NVAR_INT: + fprintf(stderr, "P_AND_VC_AND_VC_NVAR_INT"); + break; + case P_AND_VC_AND_VC_NVAR_NOINT: + fprintf(stderr, "P_AND_VC_AND_VC_NVAR_NOINT"); + break; + case P_AND_VC_AND_VC_UNK: + fprintf(stderr, "P_AND_VC_AND_VC_UNK"); + break; + case P_AND_Y_VV_INSTINIT: + fprintf(stderr, "P_AND_Y_VV_INSTINIT"); + break; + case P_AND_Y_VV_AND_Y_VV_NVAR: + fprintf(stderr, "P_AND_Y_VV_AND_Y_VV_NVAR"); + break; + case P_AND_Y_VV_INTTERM: + fprintf(stderr, "P_AND_Y_VV_INTTERM"); + break; + case P_AND_Y_VV_NOINTTERM: + fprintf(stderr, "P_AND_Y_VV_NOINTTERM"); + break; + case P_AND_Y_VV_D0EQUALS0L: + fprintf(stderr, "P_AND_Y_VV_D0EQUALS0L"); + break; + case P_AND_Y_VV_NVAR_END: + fprintf(stderr, "P_AND_Y_VV_NVAR_END"); + break; + case P_AND_Y_VV_AND_Y_VV_UNK: + fprintf(stderr, "P_AND_Y_VV_AND_Y_VV_UNK"); + break; + case P_AND_Y_VV_AND_Y_VV_NVAR_UNK: + fprintf(stderr, "P_AND_Y_VV_AND_Y_VV_NVAR_UNK"); + break; + case P_AND_Y_VC_INSTINIT: + fprintf(stderr, "P_AND_Y_VC_INSTINIT"); + break; + case P_AND_Y_VC_AND_Y_VC_NVAR: + fprintf(stderr, "P_AND_Y_VC_AND_Y_VC_NVAR"); + break; + case P_AND_Y_VC_INTTERM: + fprintf(stderr, "P_AND_Y_VC_INTTERM"); + break; + case P_AND_Y_VC_NOINTTERM: + fprintf(stderr, "P_AND_Y_VC_NOINTTERM"); + break; + case P_AND_Y_VC_D0EQUALS0L: + fprintf(stderr, "P_AND_Y_VC_D0EQUALS0L"); + break; + case P_AND_Y_VC_NVAR_END: + fprintf(stderr, "P_AND_Y_VC_NVAR_END"); + break; + case P_AND_Y_VC_AND_Y_VC_UNK: + fprintf(stderr, "P_AND_Y_VC_AND_Y_VC_UNK"); + break; + case P_OR_VV_INSTINIT: + fprintf(stderr, "P_OR_VV_INSTINIT"); + break; + case P_OR_VV_OR_VV_NVAR: + fprintf(stderr, "P_OR_VV_OR_VV_NVAR"); + break; + case P_OR_VV_INTTERM: + fprintf(stderr, "P_OR_VV_INTTERM"); + break; + case P_OR_VV_NOINTTERM: + fprintf(stderr, "P_OR_VV_NOINTTERM"); + break; + case P_OR_VV_D0EQUALS0L: + fprintf(stderr, "P_OR_VV_D0EQUALS0L"); + break; + case P_OR_VV_NVAR_END: + fprintf(stderr, "P_OR_VV_NVAR_END"); + break; + case P_OR_VV_OR_VV_UNK: + fprintf(stderr, "P_OR_VV_OR_VV_UNK"); + break; + case P_OR_VV_OR_VV_NVAR_UNK: + fprintf(stderr, "P_OR_VV_OR_VV_NVAR_UNK"); + break; + case P_OR_VC_INSTINIT: + fprintf(stderr, "P_OR_VC_INSTINIT"); + break; + case P_OR_VC_OR_VC_NVAR: + fprintf(stderr, "P_OR_VC_OR_VC_NVAR"); + break; + case P_OR_VC_INTTERM: + fprintf(stderr, "P_OR_VC_INTTERM"); + break; + case P_OR_VC_NOINTTERM: + fprintf(stderr, "P_OR_VC_NOINTTERM"); + break; + case P_OR_VC_D0EQUALS0L: + fprintf(stderr, "P_OR_VC_D0EQUALS0L"); + break; + case P_OR_VC_NVAR_END: + fprintf(stderr, "P_OR_VC_NVAR_END"); + break; + case P_OR_VC_OR_VC_UNK: + fprintf(stderr, "P_OR_VC_OR_VC_UNK"); + break; + case P_OR_Y_VV_INSTINIT: + fprintf(stderr, "P_OR_Y_VV_INSTINIT"); + break; + case P_OR_Y_VV_OR_Y_VV_NVAR: + fprintf(stderr, "P_OR_Y_VV_OR_Y_VV_NVAR"); + break; + case P_OR_Y_VV_INTTERM: + fprintf(stderr, "P_OR_Y_VV_INTTERM"); + break; + case P_OR_Y_VV_NOINTTERM: + fprintf(stderr, "P_OR_Y_VV_NOINTTERM"); + break; + case P_OR_Y_VV_D0EQUALS0L: + fprintf(stderr, "P_OR_Y_VV_D0EQUALS0L"); + break; + case P_OR_Y_VV_NVAR_END: + fprintf(stderr, "P_OR_Y_VV_NVAR_END"); + break; + case P_OR_Y_VV_OR_Y_VV_UNK: + fprintf(stderr, "P_OR_Y_VV_OR_Y_VV_UNK"); + break; + case P_OR_Y_VV_OR_Y_VV_NVAR_UNK: + fprintf(stderr, "P_OR_Y_VV_OR_Y_VV_NVAR_UNK"); + break; + case P_OR_Y_VC_INSTINIT: + fprintf(stderr, "P_OR_Y_VC_INSTINIT"); + break; + case P_OR_Y_VC_OR_Y_VC_NVAR: + fprintf(stderr, "P_OR_Y_VC_OR_Y_VC_NVAR"); + break; + case P_OR_Y_VC_INTTERM: + fprintf(stderr, "P_OR_Y_VC_INTTERM"); + break; + case P_OR_Y_VC_NOINTTERM: + fprintf(stderr, "P_OR_Y_VC_NOINTTERM"); + break; + case P_OR_Y_VC_D0EQUALS0L: + fprintf(stderr, "P_OR_Y_VC_D0EQUALS0L"); + break; + case P_OR_Y_VC_NVAR_END: + fprintf(stderr, "P_OR_Y_VC_NVAR_END"); + break; + case P_OR_Y_VC_OR_Y_VC_UNK: + fprintf(stderr, "P_OR_Y_VC_OR_Y_VC_UNK"); + break; + case P_SLL_VV_INSTINIT: + fprintf(stderr, "P_SLL_VV_INSTINIT"); + break; + case P_SLL_VV_SLL_VV_NVAR: + fprintf(stderr, "P_SLL_VV_SLL_VV_NVAR"); + break; + case P_SLL_VV_INTTERM_INIT: + fprintf(stderr, "P_SLL_VV_INTTERM_INIT"); + break; + case P_SLL_VV_INTTERM_LESS: + fprintf(stderr, "P_SLL_VV_INTTERM_LESS"); + break; + case P_SLL_VV_INTTERM_GREATER: + fprintf(stderr, "P_SLL_VV_INTTERM_GREATER"); + break; + case P_SLL_VV_NOINTTERM: + fprintf(stderr, "P_SLL_VV_NOINTTERM"); + break; + case P_SLL_VV_D0EQUALS0L: + fprintf(stderr, "P_SLL_VV_D0EQUALS0L"); + break; + case P_SLL_VV_NVAR_END: + fprintf(stderr, "P_SLL_VV_NVAR_END"); + break; + case P_SLL_VV_SLL_VV_UNK: + fprintf(stderr, "P_SLL_VV_SLL_VV_UNK"); + break; + case P_SLL_VV_SLL_VV_NVAR_UNK: + fprintf(stderr, "P_SLL_VV_SLL_VV_NVAR_UNK"); + break; + case P_SLL_VC_INSTINIT: + fprintf(stderr, "P_SLL_VC_INSTINIT"); + break; + case P_SLL_VC_SLL_VC_NVAR: + fprintf(stderr, "P_SLL_VC_SLL_VC_NVAR"); + break; + case P_SLL_VC_INTTERM: + fprintf(stderr, "P_SLL_VC_INTTERM"); + break; + case P_SLL_VC_NOINTTERM: + fprintf(stderr, "P_SLL_VC_NOINTTERM"); + break; + case P_SLL_VC_D0EQUALS0L: + fprintf(stderr, "P_SLL_VC_D0EQUALS0L"); + break; + case P_SLL_VC_NVAR_END: + fprintf(stderr, "P_SLL_VC_NVAR_END"); + break; + case P_SLL_VC_SLL_VC_UNK: + fprintf(stderr, "P_SLL_VC_SLL_VC_UNK"); + break; + case P_SLL_CV_INSTINIT: + fprintf(stderr, "P_SLL_CV_INSTINIT"); + break; + case P_SLL_CV_SLL_CV_NVAR_INT: + fprintf(stderr, "P_SLL_CV_SLL_CV_NVAR_INT"); + break; + case P_SLL_CV_SLL_CV_NVAR_NOINT: + fprintf(stderr, "P_SLL_CV_SLL_CV_NVAR_NOINT"); + break; + case P_SLL_CV_SLL_CV_UNK: + fprintf(stderr, "P_SLL_CV_SLL_CV_UNK"); + break; + case P_SLL_Y_VV_INSTINIT: + fprintf(stderr, "P_SLL_Y_VV_INSTINIT"); + break; + case P_SLL_Y_VV_SLL_Y_VV_NVAR: + fprintf(stderr, "P_SLL_Y_VV_SLL_Y_VV_NVAR"); + break; + case P_SLL_Y_VV_INTTERM_INIT: + fprintf(stderr, "P_SLL_Y_VV_INTTERM_INIT"); + break; + case P_SLL_Y_VV_INTERM_LESS: + fprintf(stderr, "P_SLL_Y_VV_INTERM_LESS"); + break; + case P_SLL_Y_VV_INTTERM_GREATER: + fprintf(stderr, "P_SLL_Y_VV_INTTERM_GREATER"); + break; + case P_SLL_Y_VV_NOINTTERM: + fprintf(stderr, "P_SLL_Y_VV_NOINTTERM"); + break; + case P_SLL_Y_VV_D0EQUALS0L: + fprintf(stderr, "P_SLL_Y_VV_D0EQUALS0L"); + break; + case P_SLL_Y_VV_NVAR_END: + fprintf(stderr, "P_SLL_Y_VV_NVAR_END"); + break; + case P_SLL_Y_VV_SLL_Y_VV_UNK: + fprintf(stderr, "P_SLL_Y_VV_SLL_Y_VV_UNK"); + break; + case P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK: + fprintf(stderr, "P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK"); + break; + case P_SLL_Y_VC_INSTINIT: + fprintf(stderr, "P_SLL_Y_VC_INSTINIT"); + break; + case P_SLL_Y_VC_SLL_Y_VC_NVAR: + fprintf(stderr, "P_SLL_Y_VC_SLL_Y_VC_NVAR"); + break; + case P_SLL_Y_VC_INTTERM: + fprintf(stderr, "P_SLL_Y_VC_INTTERM"); + break; + case P_SLL_Y_VC_NOINTTERM: + fprintf(stderr, "P_SLL_Y_VC_NOINTTERM"); + break; + case P_SLL_Y_VC_D0EQUALS0L: + fprintf(stderr, "P_SLL_Y_VC_D0EQUALS0L"); + break; + case P_SLL_Y_VC_NVAR_END: + fprintf(stderr, "P_SLL_Y_VC_NVAR_END"); + break; + case P_SLL_Y_VC_SLL_Y_VC_UNK: + fprintf(stderr, "P_SLL_Y_VC_SLL_Y_VC_UNK"); + break; + case P_SLL_Y_CV_INSTINIT: + fprintf(stderr, "P_SLL_Y_CV_INSTINIT"); + break; + case P_SLL_Y_CV_SLL_Y_CV_NVAR: + fprintf(stderr, "P_SLL_Y_CV_SLL_Y_CV_NVAR"); + break; + case P_SLL_Y_CV_INTTERM_INIT: + fprintf(stderr, "P_SLL_Y_CV_INTTERM_INIT"); + break; + case P_SLL_Y_CV_INTTERM_LESS: + fprintf(stderr, "P_SLL_Y_CV_INTTERM_LESS"); + break; + case P_SLL_Y_CV_INTTERM_GREATER: + fprintf(stderr, "P_SLL_Y_CV_INTTERM_GREATER"); + break; + case P_SLL_Y_CV_NOINTTERM: + fprintf(stderr, "P_SLL_Y_CV_NOINTTERM"); + break; + case P_SLL_Y_CV_D0EQUALS0L: + fprintf(stderr, "P_SLL_Y_CV_D0EQUALS0L"); + break; + case P_SLL_Y_CV_NVAR_END: + fprintf(stderr, "P_SLL_Y_CV_NVAR_END"); + break; + case P_SLL_Y_CV_SLL_Y_CV_UNK: + fprintf(stderr, "P_SLL_Y_CV_SLL_Y_CV_UNK"); + break; + case P_SLR_VV_INSTINIT: + fprintf(stderr, "P_SLR_VV_INSTINIT"); + break; + case P_SLR_VV_SLR_VV_NVAR: + fprintf(stderr, "P_SLR_VV_SLR_VV_NVAR"); + break; + case P_SLR_VV_INTTERM_INIT: + fprintf(stderr, "P_SLR_VV_INTTERM_INIT"); + break; + case P_SLR_VV_INTTERM_LESS: + fprintf(stderr, "P_SLR_VV_INTTERM_LESS"); + break; + case P_SLR_VV_INTTERM_GREATER: + fprintf(stderr, "P_SLR_VV_INTTERM_GREATER"); + break; + case P_SLR_VV_NOINTTERM: + fprintf(stderr, "P_SLR_VV_NOINTTERM"); + break; + case P_SLR_VV_D0EQUALS0L: + fprintf(stderr, "P_SLR_VV_D0EQUALS0L"); + break; + case P_SLR_VV_NVAR_END: + fprintf(stderr, "P_SLR_VV_NVAR_END"); + break; + case P_SLR_VV_SRL_VV_UNK: + fprintf(stderr, "P_SLR_VV_SRL_VV_UNK"); + break; + case P_SLR_VV_SRL_VV_NVAR_UNK: + fprintf(stderr, "P_SLR_VV_SRL_VV_NVAR_UNK"); + break; + case P_SLR_VC_INSTINIT: + fprintf(stderr, "P_SLR_VC_INSTINIT"); + break; + case P_SLR_VC_SLR_VC_NVAR_INT: + fprintf(stderr, "P_SLR_VC_SLR_VC_NVAR_INT"); + break; + case P_SLR_VC_SLR_VC_NVAR_NOINT: + fprintf(stderr, "P_SLR_VC_SLR_VC_NVAR_NOINT"); + break; + case P_SLR_VC_SRL_VC_UNK: + fprintf(stderr, "P_SLR_VC_SRL_VC_UNK"); + break; + case P_SLR_CV_INSTINIT: + fprintf(stderr, "P_SLR_CV_INSTINIT"); + break; + case P_SLR_CV_SLR_CV_NVAR: + fprintf(stderr, "P_SLR_CV_SLR_CV_NVAR"); + break; + case P_SLR_CV_INTTERM_INIT: + fprintf(stderr, "P_SLR_CV_INTTERM_INIT"); + break; + case P_SLR_CV_INTTERM_LESS: + fprintf(stderr, "P_SLR_CV_INTTERM_LESS"); + break; + case P_SLR_CV_INTTERM_GREATER: + fprintf(stderr, "P_SLR_CV_INTTERM_GREATER"); + break; + case P_SLR_CV_NOINTTERM: + fprintf(stderr, "P_SLR_CV_NOINTTERM"); + break; + case P_SLR_CV_D0EQUALS0L: + fprintf(stderr, "P_SLR_CV_D0EQUALS0L"); + break; + case P_SLR_CV_NVAR_END: + fprintf(stderr, "P_SLR_CV_NVAR_END"); + break; + case P_SLR_CV_SLR_CV_UNK: + fprintf(stderr, "P_SLR_CV_SLR_CV_UNK"); + break; + case P_SLR_Y_VV_INSTINIT: + fprintf(stderr, "P_SLR_Y_VV_INSTINIT"); + break; + case P_SLR_Y_VV_SLR_Y_VV_NVAR: + fprintf(stderr, "P_SLR_Y_VV_SLR_Y_VV_NVAR"); + break; + case P_SLR_Y_VV_INTTERM_INIT: + fprintf(stderr, "P_SLR_Y_VV_INTTERM_INIT"); + break; + case P_SLR_Y_VV_INTTERM_LESS: + fprintf(stderr, "P_SLR_Y_VV_INTTERM_LESS"); + break; + case P_SLR_Y_VV_INTTERM_GREATER: + fprintf(stderr, "P_SLR_Y_VV_INTTERM_GREATER"); + break; + case P_SLR_Y_VV_NOINTTERM: + fprintf(stderr, "P_SLR_Y_VV_NOINTTERM"); + break; + case P_SLR_Y_VV_D0EQUALS0L: + fprintf(stderr, "P_SLR_Y_VV_D0EQUALS0L"); + break; + case P_SLR_Y_VV_NVAR_END: + fprintf(stderr, "P_SLR_Y_VV_NVAR_END"); + break; + case P_SLR_Y_VV_SLR_Y_VV_UNK: + fprintf(stderr, "P_SLR_Y_VV_SLR_Y_VV_UNK"); + break; + case P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK: + fprintf(stderr, "P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK"); + break; + case P_SLR_Y_VC_INSTINIT: + fprintf(stderr, "P_SLR_Y_VC_INSTINIT"); + break; + case P_SLR_Y_VC_SLR_Y_VC_NVAR: + fprintf(stderr, "P_SLR_Y_VC_SLR_Y_VC_NVAR"); + break; + case P_SLR_Y_VC_INTTERM: + fprintf(stderr, "P_SLR_Y_VC_INTTERM"); + break; + case P_SLR_Y_VC_NOINTTERM: + fprintf(stderr, "P_SLR_Y_VC_NOINTTERM"); + break; + case P_SLR_Y_VC_D0EQUALS0L: + fprintf(stderr, "P_SLR_Y_VC_D0EQUALS0L"); + break; + case P_SLR_Y_VC_NVAR_END: + fprintf(stderr, "P_SLR_Y_VC_NVAR_END"); + break; + case P_SLR_Y_VC_SLR_Y_VC_UNK: + fprintf(stderr, "P_SLR_Y_VC_SLR_Y_VC_UNK"); + break; + case P_SLR_Y_CV_INSTINIT: + fprintf(stderr, "P_SLR_Y_CV_INSTINIT"); + break; + case P_SLR_Y_CV_SLR_Y_CV_NVAR: + fprintf(stderr, "P_SLR_Y_CV_SLR_Y_CV_NVAR"); + break; + case P_SLR_Y_CV_INTTERM_INIT: + fprintf(stderr, "P_SLR_Y_CV_INTTERM_INIT"); + break; + case P_SLR_Y_CV_INTTERM_LESS: + fprintf(stderr, "P_SLR_Y_CV_INTTERM_LESS"); + break; + case P_SLR_Y_CV_INTTERM_GREATER: + fprintf(stderr, "P_SLR_Y_CV_INTTERM_GREATER"); + break; + case P_SLR_Y_CV_NOINTTERM: + fprintf(stderr, "P_SLR_Y_CV_NOINTTERM"); + break; + case P_SLR_Y_CV_D0EQUALS0L: + fprintf(stderr, "P_SLR_Y_CV_D0EQUALS0L"); + break; + case P_SLR_Y_CV_NVAR_END: + fprintf(stderr, "P_SLR_Y_CV_NVAR_END"); + break; + case P_SLR_Y_CV_SLR_Y_CV_UNK: + fprintf(stderr, "P_SLR_Y_CV_SLR_Y_CV_UNK"); + break; + case CALL_BFUNC_XX_INSTINIT: + fprintf(stderr, "CALL_BFUNC_XX_INSTINIT"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR: + fprintf(stderr, "CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT: + fprintf(stderr, "CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT: + fprintf(stderr, "CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX_UNK: + fprintf(stderr, "CALL_BFUNC_XX_CALL_BFUNC_XX_UNK"); + break; + case CALL_BFUNC_YX_INSTINIT: + fprintf(stderr, "CALL_BFUNC_YX_INSTINIT"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT: + fprintf(stderr, "CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT: + fprintf(stderr, "CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX_UNK: + fprintf(stderr, "CALL_BFUNC_YX_CALL_BFUNC_YX_UNK"); + break; + case CALL_BFUNC_XY_INSTINIT: + fprintf(stderr, "CALL_BFUNC_XY_INSTINIT"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT: + fprintf(stderr, "CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT: + fprintf(stderr, "CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY_UNK: + fprintf(stderr, "CALL_BFUNC_XY_CALL_BFUNC_XY_UNK"); + break; + case CALL_BFUNC_YY_INSTINIT: + fprintf(stderr, "CALL_BFUNC_YY_INSTINIT"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT: + fprintf(stderr, "CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT: + fprintf(stderr, "CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY_UNK: + fprintf(stderr, "CALL_BFUNC_YY_CALL_BFUNC_YY_UNK"); + break; + case P_EQUAL_INSTINIT: + fprintf(stderr, "P_EQUAL_INSTINIT"); + break; + case P_EQUAL_END: + fprintf(stderr, "P_EQUAL_END"); + break; + case P_DIF_INSTINIT: + fprintf(stderr, "P_DIF_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_DIF_LOW_LEVEL_TRACER: + fprintf(stderr, "P_DIF_LOW_LEVEL_TRACER"); + break; +#endif + case P_DIF_POST_LOW_LEVEL_TRACER: + fprintf(stderr, "P_DIF_POST_LOW_LEVEL_TRACER"); + break; + case P_DIF_DIF_NVAR1: + fprintf(stderr, "P_DIF_DIF_NVAR1"); + break; + case P_DIF_DIF_NVAR1_NVAR2: + fprintf(stderr, "P_DIF_DIF_NVAR1_NVAR2"); + break; + break; + case P_DIF_DIF_UNK1: + fprintf(stderr, "P_DIF_DIF_UNK1"); + break; + case P_DIF_DIF_NVAR1_UNK2: + fprintf(stderr, "P_DIF_DIF_NVAR1_UNK2"); + break; + case P_EQ_INSTINIT: + fprintf(stderr, "P_EQ_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_EQ_LOW_LEVEL_TRACER: + fprintf(stderr, "P_EQ_LOW_LEVEL_TRACER"); + break; +#endif + case P_EQ_POST_LOW_LEVEL_TRACER: + fprintf(stderr, "P_EQ_POST_LOW_LEVEL_TRACER"); + break; + case P_EQ_P_EQ_NVAR1: + fprintf(stderr, "P_EQ_P_EQ_NVAR1"); + break; + case P_EQ_P_EQ_NVAR1_NVAR2: + fprintf(stderr, "P_EQ_P_EQ_NVAR1_NVAR2"); + break; + case P_EQ_P_EQ_NVAR1_UNK2: + fprintf(stderr, "P_EQ_P_EQ_NVAR1_UNK2"); + break; + case P_EQ_P_EQ_UNK1: + fprintf(stderr, "P_EQ_P_EQ_UNK1"); + break; + case P_EQ_P_EQ_VAR1_NVAR2: + fprintf(stderr, "P_EQ_P_EQ_VAR1_NVAR2"); + break; + case P_EQ_P_EQ_VAR1_UNK2_END: + fprintf(stderr, "P_EQ_P_EQ_VAR1_UNK2_END"); + break; + case P_ARG_VV_INSTINIT: + fprintf(stderr, "P_ARG_VV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_VV_LOW_LEVEL_TRACER: + fprintf(stderr, "P_ARG_VV_LOW_LEVEL_TRACER"); + break; +#endif + case P_ARG_VV_TEST_D0: + fprintf(stderr, "P_ARG_VV_TEST_D0"); + break; + case P_ARG_VV_ARG_ARG1_NVAR: + fprintf(stderr, "P_ARG_VV_ARG_ARG1_NVAR"); + break; + case P_ARG_VV_TEST_D1: + fprintf(stderr, "P_ARG_VV_TEST_D1"); + break; + case P_ARG_VV_ARG_ARG2_NVAR: + fprintf(stderr, "P_ARG_VV_ARG_ARG2_NVAR"); + break; + case P_ARG_VV_ARG_ARG2_UNK: + fprintf(stderr, "P_ARG_VV_ARG_ARG2_UNK"); + break; + case P_ARG_VV_ARG_ARG1_UNK: + fprintf(stderr, "P_ARG_VV_ARG_ARG1_UNK"); + break; + case P_ARG_CV_INSTINIT: + fprintf(stderr, "P_ARG_CV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_CV_LOW_LEVEL_TRACER: + fprintf(stderr, "P_ARG_CV_LOW_LEVEL_TRACER"); + break; +#endif + case P_ARG_CV_TEST_D1: + fprintf(stderr, "P_ARG_CV_TEST_D1"); + break; + case P_ARG_CV_ARG_ARG2_VC_NVAR: + fprintf(stderr, "P_ARG_CV_ARG_ARG2_VC_NVAR"); + break; + case P_ARG_CV_ARG_ARG2_VC_UNK: + fprintf(stderr, "P_ARG_CV_ARG_ARG2_VC_UNK"); + break; + case P_ARG_Y_VV_INSTINIT: + fprintf(stderr, "P_ARG_Y_VV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_Y_VV_LOW_LEVEL_TRACER: + fprintf(stderr, "P_ARG_Y_VV_LOW_LEVEL_TRACER"); + break; +#endif + case P_ARG_Y_VV_TEST_D0: + fprintf(stderr, "P_ARG_Y_VV_TEST_D0"); + break; + case P_ARG_Y_VV_ARG_Y_ARG1_NVAR: + fprintf(stderr, "P_ARG_Y_VV_ARG_Y_ARG1_NVAR"); + break; + case P_ARG_Y_VV_TEST_D1: + fprintf(stderr, "P_ARG_Y_VV_TEST_D1"); + break; + case P_ARG_Y_VV_ARG_Y_ARG2_NVAR: + fprintf(stderr, "P_ARG_Y_VV_ARG_Y_ARG2_NVAR"); + break; + case P_ARG_Y_VV_ARG_Y_ARG2_UNK: + fprintf(stderr, "P_ARG_Y_VV_ARG_Y_ARG2_UNK"); + break; + case P_ARG_Y_VV_ARG_Y_ARG1_UNK: + fprintf(stderr, "P_ARG_Y_VV_ARG_Y_ARG1_UNK"); + break; + case P_ARG_Y_CV_INSTINIT: + fprintf(stderr, "P_ARG_Y_CV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_Y_CV_LOW_LEVEL_TRACER: + fprintf(stderr, "P_ARG_Y_CV_LOW_LEVEL_TRACER"); + break; +#endif + case P_ARG_Y_CV_TEST_D1: + fprintf(stderr, "P_ARG_Y_CV_TEST_D1"); + break; + case P_ARG_Y_CV_D1APPL_INIT: + fprintf(stderr, "P_ARG_Y_CV_D1APPL_INIT"); + break; + case P_ARG_Y_CV_D1APPL_END: + fprintf(stderr, "P_ARG_Y_CV_D1APPL_END"); + break; + case P_ARG_Y_CV_D1PAIR_INIT: + fprintf(stderr, "P_ARG_Y_CV_D1PAIR_INIT"); + break; + case P_ARG_Y_CV_D1PAIR_LESS0: + fprintf(stderr, "P_ARG_Y_CV_D1PAIR_LESS0"); + break; + case P_ARG_Y_CV_D1PAIR_END: + fprintf(stderr, "P_ARG_Y_CV_D1PAIR_END"); + break; + case P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK: + fprintf(stderr, "P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK"); + break; + case P_FUNCTOR_INSTINIT: + fprintf(stderr, "P_FUNCTOR_INSTINIT"); + break; + case P_FUNCTOR_END: + fprintf(stderr, "P_FUNCTOR_END"); + break; + case P_FUNC2S_VV_INSTINIT: + fprintf(stderr, "P_FUNC2S_VV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_VV_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2S_VV_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_TEST_D0: + fprintf(stderr, "P_FUNC2S_TEST_D0"); + break; + case P_FUNC2S_VV_TEST_D1: + fprintf(stderr, "P_FUNC2S_VV_TEST_D1"); + break; + case P_FUNC2S_VV_D1INT: + fprintf(stderr, "P_FUNC2S_VV_D1INT"); + break; + case P_FUNC2S_VV_D1NOTINT: + fprintf(stderr, "P_FUNC2S_VV_D1NOTINT"); + break; + case P_FUNC2S_VV_D1BIGINT: + fprintf(stderr, "P_FUNC2S_VV_D1BIGINT"); + break; + case P_FUNC2S_VV_D1NOTBIGINT: + fprintf(stderr, "P_FUNC2S_VV_D1NOTBIGINT"); + break; + case P_FUNC2S_VV_D1NOTINT_END: + fprintf(stderr, "P_FUNC2S_VV_D1NOTINT_END"); + break; + case P_FUNC2S_VV_D0NOTATOMIC: + fprintf(stderr, "P_FUNC2S_VV_D0NOTATOMIC"); + break; + case P_FUNC2S_VV_FIRSTIFOK: + fprintf(stderr, "P_FUNC2S_VV_FIRSTIFOK"); + break; + case P_FUNC2S_VV_SECONDIFOK_D0NOTATOM: + fprintf(stderr, "P_FUNC2S_VV_SECONDIFOK_D0NOTATOM"); + break; + case P_FUNC2S_VV_SECONDIFOK_D0ATOM: + fprintf(stderr, "P_FUNC2S_VV_SECONDIFOK_D0ATOM"); + break; + case P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM: + fprintf(stderr, "P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT: + fprintf(stderr, "P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK: + fprintf(stderr, "P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF: + fprintf(stderr, "P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF"); + break; + case P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE: + fprintf(stderr, "P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE"); + break; + case P_FUNC2S_VV_SECONDIFOK_END: + fprintf(stderr, "P_FUNC2S_VV_SECONDIFOK_END"); + break; + case P_FUNC2S_VV_THIRDIFOK: + fprintf(stderr, "P_FUNC2S_VV_THIRDIFOK"); + break; + case P_FUNC2S_VV_ELSE: + fprintf(stderr, "P_FUNC2S_VV_ELSE"); + break; + case P_FUNC2S_VV_FUNC2S_UNK2: + fprintf(stderr, "P_FUNC2S_VV_FUNC2S_UNK2"); + break; + case P_FUNC2S_VV_FUNC2S_UNK: + fprintf(stderr, "P_FUNC2S_VV_FUNC2S_UNK"); + break; + case P_FUNC2S_CV_INSTINIT: + fprintf(stderr, "P_FUNC2S_CV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_CV_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2S_CV_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_CV_TEST_D1: + fprintf(stderr, "P_FUNC2S_CV_TEST_D1"); + break; + case P_FUNC2S_CV_D1INT: + fprintf(stderr, "P_FUNC2S_CV_D1INT"); + break; + case P_FUNC2S_CV_D1NOTINT: + fprintf(stderr, "P_FUNC2S_CV_D1NOTINT"); + break; + case P_FUNC2S_CV_D1NOINT_D1BIGINT: + fprintf(stderr, "P_FUNC2S_CV_D1NOINT_D1BIGINT"); + break; + case P_FUNC2S_CV_D1NOTBIGINT: + fprintf(stderr, "P_FUNC2S_CV_D1NOTBIGINT"); + break; + case P_FUNC2S_CV_POST_IF: + fprintf(stderr, "P_FUNC2S_CV_POST_IF"); + break; + case P_FUNC2S_CV_FIRSTIFOK: + fprintf(stderr, "P_FUNC2S_CV_FIRSTIFOK"); + break; + case P_FUNC2S_CV_D1GREATER_D0NOTATOM: + fprintf(stderr, "P_FUNC2S_CV_D1GREATER_D0NOTATOM"); + break; + case P_FUNC2S_CV_D1GREATER_D0ATOM: + fprintf(stderr, "P_FUNC2S_CV_D1GREATER_D0ATOM"); + break; + case P_FUNC2S_CV_D1GREATER_POST_IF: + fprintf(stderr, "P_FUNC2S_CV_D1GREATER_POST_IF"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_INIT: + fprintf(stderr, "P_FUNC2S_CV_D1GREATER_IFOK_INIT"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_IFOK: + fprintf(stderr, "P_FUNC2S_CV_D1GREATER_IFOK_IFOK"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_NOIF: + fprintf(stderr, "P_FUNC2S_CV_D1GREATER_IFOK_NOIF"); + break; + case P_FUNC2S_CV_D1GREATER_INSIDEWHILE: + fprintf(stderr, "P_FUNC2S_CV_D1GREATER_INSIDEWHILE"); + break; + case P_FUNC2S_CV_D1GREATER_END: + fprintf(stderr, "P_FUNC2S_CV_D1GREATER_END"); + break; + case P_FUNC2S_CV_D1ISZERO: + fprintf(stderr, "P_FUNC2S_CV_D1ISZERO"); + break; + case P_FUNC2S_CV_ELSE: + fprintf(stderr, "P_FUNC2S_CV_ELSE"); + break; + case P_FUNC2S_CV_END: + fprintf(stderr, "P_FUNC2S_CV_END"); + break; + case P_FUNC2S_VC_INSTINIT: + fprintf(stderr, "P_FUNC2S_VC_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_VC_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2S_VC_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_VC_TEST_D0: + fprintf(stderr, "P_FUNC2S_VC_TEST_D0"); + break; + case P_FUNC2S_VC_FUNC2S_NVAR_VC: + fprintf(stderr, "P_FUNC2S_VC_FUNC2S_NVAR_VC"); + break; + case P_FUNC2S_VC_D0NOATOMIC: + fprintf(stderr, "P_FUNC2S_VC_D0NOATOMIC"); + break; + case P_FUNC2S_VC_EQUALS: + fprintf(stderr, "P_FUNC2S_VC_EQUALS"); + break; + case P_FUNC2S_VC_D1ISZERO: + fprintf(stderr, "P_FUNC2S_VC_D1ISZERO"); + break; + case P_FUNC2S_VC_D0NOATOM: + fprintf(stderr, "P_FUNC2S_VC_D0NOATOM"); + break; + case P_FUNC2S_VC_D0ATOM: + fprintf(stderr, "P_FUNC2S_VC_D0ATOM"); + break; + case P_FUNC2S_VC_POST_ELSE: + fprintf(stderr, "P_FUNC2S_VC_POST_ELSE"); + break; + case P_FUNC2S_VC_IFOK_INIT: + fprintf(stderr, "P_FUNC2S_VC_IFOK_INIT"); + break; + case P_FUNC2S_VC_IFOK_IFOK: + fprintf(stderr, "P_FUNC2S_VC_IFOK_IFOK"); + break; + case P_FUNC2S_VC_IFOK_NOIF: + fprintf(stderr, "P_FUNC2S_VC_IFOK_NOIF"); + break; + case P_FUNC2S_VC_INSIDEWHILE: + fprintf(stderr, "P_FUNC2S_VC_INSIDEWHILE"); + break; + case P_FUNC2S_VC_END1: + fprintf(stderr, "P_FUNC2S_VC_END1"); + break; + case P_FUNC2S_VC_END2: + fprintf(stderr, "P_FUNC2S_VC_END2"); + break; + case P_FUNC2S_Y_VV_INSTINIT: + fprintf(stderr, "P_FUNC2S_Y_VV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_VV_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2S_Y_VV_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_Y_VV_TEST_D0: + fprintf(stderr, "P_FUNC2S_Y_VV_TEST_D0"); + break; + case P_FUNC2S_Y_VV_TEST_D1: + fprintf(stderr, "P_FUNC2S_Y_VV_TEST_D1"); + break; + case P_FUNC2S_Y_VV_D1INT: + fprintf(stderr, "P_FUNC2S_Y_VV_D1INT"); + break; + case P_FUNC2S_Y_VV_D1NOTINT: + fprintf(stderr, "P_FUNC2S_Y_VV_D1NOTINT"); + break; + case P_FUNC2S_Y_VV_D1BIGINT: + fprintf(stderr, "P_FUNC2S_Y_VV_D1BIGINT"); + break; + case P_FUNC2S_Y_VV_D1NOTBIGINT: + fprintf(stderr, "P_FUNC2S_Y_VV_D1NOTBIGINT"); + break; + case P_FUNC2S_Y_VV_POST_IF: + fprintf(stderr, "P_FUNC2S_Y_VV_POST_IF"); + break; + case P_FUNC2S_Y_VV_D0NOATOMIC: + fprintf(stderr, "P_FUNC2S_Y_VV_D0NOATOMIC"); + break; + case P_FUNC2S_Y_VV_EQUALS: + fprintf(stderr, "P_FUNC2S_Y_VV_EQUALS"); + break; + case P_FUNC2S_Y_VV_D1GREATER_D0NOATOM: + fprintf(stderr, "P_FUNC2S_Y_VV_D1GREATER_D0NOATOM"); + break; + case P_FUNC2S_Y_VV_D1GREATER_D0ATOM: + fprintf(stderr, "P_FUNC2S_Y_VV_D1GREATER_D0ATOM"); + break; + case P_FUNC2S_Y_VV_D1GREATER_POST_ELSE: + fprintf(stderr, "P_FUNC2S_Y_VV_D1GREATER_POST_ELSE"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT: + fprintf(stderr, "P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK: + fprintf(stderr, "P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF: + fprintf(stderr, "P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF"); + break; + case P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE: + fprintf(stderr, "P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE"); + break; + case P_FUNC2S_Y_VV_D1GREATER_END: + fprintf(stderr, "P_FUNC2S_Y_VV_D1GREATER_END"); + break; + case P_FUNC2S_Y_VV_D1ISZERO: + fprintf(stderr, "P_FUNC2S_Y_VV_D1ISZERO"); + break; + case P_FUNC2S_Y_VV_ELSE: + fprintf(stderr, "P_FUNC2S_Y_VV_ELSE"); + break; + case P_FUNC2S_Y_VV_END1: + fprintf(stderr, "P_FUNC2S_Y_VV_END1"); + break; + case P_FUNC2S_Y_VV_END2: + fprintf(stderr, "P_FUNC2S_Y_VV_END2"); + break; + case P_FUNC2S_Y_CV_INSTINIT: + fprintf(stderr, "P_FUNC2S_Y_CV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_CV_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2S_Y_CV_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_Y_CV_TEST_D1: + fprintf(stderr, "P_FUNC2S_Y_CV_TEST_D1"); + break; + case P_FUNC2S_Y_CV_D1INT: + fprintf(stderr, "P_FUNC2S_Y_CV_D1INT"); + break; + case P_FUNC2S_Y_CV_D1NOTINT: + fprintf(stderr, "P_FUNC2S_Y_CV_D1NOTINT"); + break; + case P_FUNC2S_Y_CV_D1BIGINT: + fprintf(stderr, "P_FUNC2S_Y_CV_D1BIGINT"); + break; + case P_FUNC2S_Y_CV_D1NOTBIGINT: + fprintf(stderr, "P_FUNC2S_Y_CV_D1NOTBIGINT"); + break; + case P_FUNC2S_Y_CV_POST_IF: + fprintf(stderr, "P_FUNC2S_Y_CV_POST_IF"); + break; + case P_FUNC2S_Y_CV_EQUALS: + fprintf(stderr, "P_FUNC2S_Y_CV_EQUALS"); + break; + case P_FUNC2S_Y_CV_D1GREATER_D0NOATOM: + fprintf(stderr, "P_FUNC2S_Y_CV_D1GREATER_D0NOATOM"); + break; + case P_FUNC2S_Y_CV_D1GREATER_D0ATOM: + fprintf(stderr, "P_FUNC2S_Y_CV_D1GREATER_D0ATOM"); + break; + case P_FUNC2S_Y_CV_D1GREATER_POST_ELSE: + fprintf(stderr, "P_FUNC2S_Y_CV_D1GREATER_POST_ELSE"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT: + fprintf(stderr, "P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK: + fprintf(stderr, "P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF: + fprintf(stderr, "P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF"); + break; + case P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE: + fprintf(stderr, "P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE"); + break; + case P_FUNC2S_Y_CV_D1GREATER_END: + fprintf(stderr, "P_FUNC2S_Y_CV_D1GREATER_END"); + break; + case P_FUNC2S_Y_CV_D1ISZERO: + fprintf(stderr, "P_FUNC2S_Y_CV_D1ISZERO"); + break; + case P_FUNC2S_Y_CV_ELSE: + fprintf(stderr, "P_FUNC2S_Y_CV_ELSE"); + break; + case P_FUNC2S_Y_CV_END: + fprintf(stderr, "P_FUNC2S_Y_CV_END"); + break; + case P_FUNC2S_Y_VC_INSTINIT: + fprintf(stderr, "P_FUNC2S_Y_VC_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_VC_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2S_Y_VC_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_Y_VC_TEST_D0: + fprintf(stderr, "P_FUNC2S_Y_VC_TEST_D0"); + break; + case P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC: + fprintf(stderr, "P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC"); + break; + case P_FUNC2S_Y_VC_D0NOATOMIC: + fprintf(stderr, "P_FUNC2S_Y_VC_D0NOATOMIC"); + break; + case P_FUNC2S_Y_VC_EQUALS: + fprintf(stderr, "P_FUNC2S_Y_VC_EQUALS"); + break; + case P_FUNC2S_Y_VC_D1ISZERO: + fprintf(stderr, "P_FUNC2S_Y_VC_D1ISZERO"); + break; + case P_FUNC2S_Y_VC_D0NOATOM1: + fprintf(stderr, "P_FUNC2S_Y_VC_D0NOATOM1"); + break; + case P_FUNC2S_Y_VC_D0NOATOM2: + fprintf(stderr, "P_FUNC2S_Y_VC_D0NOATOM2"); + break; + case P_FUNC2S_Y_VC_D0ATOM: + fprintf(stderr, "P_FUNC2S_Y_VC_D0ATOM"); + break; + case P_FUNC2S_Y_VC_POST_ELSE: + fprintf(stderr, "P_FUNC2S_Y_VC_POST_ELSE"); + break; + case P_FUNC2S_Y_VC_IFOK_INIT: + fprintf(stderr, "P_FUNC2S_Y_VC_IFOK_INIT"); + break; + case P_FUNC2S_Y_VC_IFOK_IFOK: + fprintf(stderr, "P_FUNC2S_Y_VC_IFOK_IFOK"); + break; + case P_FUNC2S_Y_VC_IFOK_NOIF: + fprintf(stderr, "P_FUNC2S_Y_VC_IFOK_NOIF"); + break; + case P_FUNC2S_Y_VC_INSIDEWHILE: + fprintf(stderr, "P_FUNC2S_Y_VC_INSIDEWHILE"); + break; + case P_FUNC2S_Y_VC_END1: + fprintf(stderr, "P_FUNC2S_Y_VC_END1"); + break; + case P_FUNC2S_Y_VC_END2: + fprintf(stderr, "P_FUNC2S_Y_VC_END2"); + break; + case P_FUNC2F_XX_INSTINIT: + fprintf(stderr, "P_FUNC2F_XX_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_XX_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2F_XX_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2F_XX_TEST_D0: + fprintf(stderr, "P_FUNC2F_XX_TEST_D0"); + break; + case P_FUNC2F_XX_D0APPL: + fprintf(stderr, "P_FUNC2F_XX_D0APPL"); + break; + case P_FUNC2F_XX_D0APPL_D1EXTFUNC: + fprintf(stderr, "P_FUNC2F_XX_D0APPL_D1EXTFUNC"); + break; + case P_FUNC2F_XX_D0APPL_END: + fprintf(stderr, "P_FUNC2F_XX_D0APPL_END"); + break; + case P_FUNC2F_XX_D0PAIR: + fprintf(stderr, "P_FUNC2F_XX_D0PAIR"); + break; + case P_FUNC2F_XX_D0NOCOMPOUND: + fprintf(stderr, "P_FUNC2F_XX_D0NOCOMPOUND"); + break; + case P_FUNC2F_XX_END: + fprintf(stderr, "P_FUNC2F_XX_END"); + break; + case P_FUNC2F_XY_INSTINIT: + fprintf(stderr, "P_FUNC2F_XY_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_XY_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2F_XY_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2F_XY_TEST_D0: + fprintf(stderr, "P_FUNC2F_XY_TEST_D0"); + break; + case P_FUNC2F_XY_D0APPL: + fprintf(stderr, "P_FUNC2F_XY_D0APPL"); + break; + case P_FUNC2F_XY_D0APPL_D1EXTFUNC: + fprintf(stderr, "P_FUNC2F_XY_D0APPL_D1EXTFUNC"); + break; + case P_FUNC2F_XY_D0APPL_END: + fprintf(stderr, "P_FUNC2F_XY_D0APPL_END"); + break; + case P_FUNC2F_XY_D0PAIR: + fprintf(stderr, "P_FUNC2F_XY_D0PAIR"); + break; + case P_FUNC2F_XY_D0NOCOMPOUND: + fprintf(stderr, "P_FUNC2F_XY_D0NOCOMPOUND"); + break; + case P_FUNC2F_XY_END: + fprintf(stderr, "P_FUNC2F_XY_END"); + break; + case P_FUNC2F_YX_INSTINIT: + fprintf(stderr, "P_FUNC2F_YX_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_YX_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2F_YX_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2F_YX_TEST_D0: + fprintf(stderr, "P_FUNC2F_YX_TEST_D0"); + break; + case P_FUNC2F_YX_D0APPL: + fprintf(stderr, "P_FUNC2F_YX_D0APPL"); + break; + case P_FUNC2F_YX_D0APPL_D1EXTFUNC: + fprintf(stderr, "P_FUNC2F_YX_D0APPL_D1EXTFUNC"); + break; + case P_FUNC2F_YX_D0APPL_END: + fprintf(stderr, "P_FUNC2F_YX_D0APPL_END"); + break; + case P_FUNC2F_YX_D0PAIR: + fprintf(stderr, "P_FUNC2F_YX_D0PAIR"); + break; + case P_FUNC2F_YX_D0NOCOMPOUND: + fprintf(stderr, "P_FUNC2F_YX_D0NOCOMPOUND"); + break; + case P_FUNC2F_YX_END: + fprintf(stderr, "P_FUNC2F_YX_END"); + break; + case P_FUNC2F_YY_INSTINIT: + fprintf(stderr, "P_FUNC2F_YY_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_YY_LOW_LEVEL_TRACER: + fprintf(stderr, "P_FUNC2F_YY_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2F_YY_TEST_D0: + fprintf(stderr, "P_FUNC2F_YY_TEST_D0"); + break; + case P_FUNC2F_YY_D0APPL: + fprintf(stderr, "P_FUNC2F_YY_D0APPL"); + break; + case P_FUNC2F_YY_D0APPL_D1EXTFUNC: + fprintf(stderr, "P_FUNC2F_YY_D0APPL_D1EXTFUNC"); + break; + case P_FUNC2F_YY_D0APPL_END: + fprintf(stderr, "P_FUNC2F_YY_D0APPL_END"); + break; + case P_FUNC2F_YY_D0PAIR: + fprintf(stderr, "P_FUNC2F_YY_D0PAIR"); + break; + case P_FUNC2F_YY_D0NOCOMPOUND: + fprintf(stderr, "P_FUNC2F_YY_D0NOCOMPOUND"); + break; + case P_FUNC2F_YY_END: + fprintf(stderr, "P_FUNC2F_YY_END"); + break; + } +} diff --git a/JIT/HPP/indexing_ext.h b/JIT/HPP/indexing_ext.h new file mode 100644 index 000000000..b202cc3e9 --- /dev/null +++ b/JIT/HPP/indexing_ext.h @@ -0,0 +1,545 @@ +#define USER_SWITCH_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + yamop *new = Yap_udi_search((*_PREG)->u.lp.p); \ + if (!new) { \ + (*_PREG) = (*_PREG)->u.lp.l; \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = new; \ + JMPNext(); \ + } \ + } + +#define USER_SWITCH_END \ + BLOCK = (CELL)USER_SWITCH_END; + +#define SWITCH_ON_TYPE_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = CACHED_A1(); \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.llll.l4); \ + (*_PREG) = (*_PREG)->u.llll.l4; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (IsPairTerm(d0)) { \ + (*_SREG) = RepPair(d0); \ + copy_jmp_address((*_PREG)->u.llll.l1); \ + (*_PREG) = (*_PREG)->u.llll.l1; \ + JMPNext(); \ + } \ + else if (!IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.llll.l2); \ + (*_PREG) = (*_PREG)->u.llll.l2; \ + I_R = d0; \ + JMPNext(); \ + } \ + else { \ + copy_jmp_address((*_PREG)->u.llll.l3); \ + (*_PREG) = (*_PREG)->u.llll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } \ + } + +#define SWITCH_ON_TYPE_END \ + BLOCK = (CELL)SWITCH_ON_TYPE_END; + +#if UNIQUE_TAG_FOR_PAIRS +#define SWITCH_LIST_NL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + ALWAYS_LOOKAHEAD((*_PREG)->u.ollll.pop); \ + d0 = CACHED_A1(); \ + Int nonvar = 0; \ + Int pair = 1; \ + if (!IsPairTerm(d0)) { \ + pair = 0; \ + do { \ + if (!IsVarTerm(d0)) { \ + if (d0 == TermNil) { \ + (*_PREG) = (*_PREG)->u.ollll.l2; \ + JMPNext(); \ + } \ + else { \ + if (IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.ollll.l3); \ + (*_PREG) = (*_PREG)->u.ollll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } else { \ + copy_jmp_address((*_PREG)->u.ollll.l3); \ + (*_PREG) = (*_PREG)->u.ollll.l3; \ + I_R = d0; \ + JMPNext(); \ + } \ + } \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(pt0); \ + if (Unsigned(pt0) == (d0)) break; \ + if (IsPairTerm(d0)) { \ + pair = 1; \ + break; \ + } \ + } while (TRUE); \ + if (!nonvar && !pair) { \ + copy_jmp_address((*_PREG)->u.ollll.l4); \ + (*_PREG) = (*_PREG)->u.ollll.l4; \ + JMPNext(); \ + } \ + } \ + if (!nonvar && pair) { \ + copy_jmp_address((*_PREG)->u.ollll.l1); \ + (*_PREG) = (*_PREG)->u.ollll.l1; \ + (*_SREG) = RepPair(d0); \ + ALWAYS_GONext(); \ + } +#else +#define SWITCH_LIST_NL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + ALWAYS_LOOKAHEAD((*_PREG)->u.ollll.pop); \ + d0 = CACHED_A1(); \ + Int nonvar = 0; \ + if (IsVarTerm(d0)) { \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.ollll.l4); \ + (*_PREG) = (*_PREG)->u.ollll.l4; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (__builtin_expect(IsPairTerm(d0),1)) { \ + copy_jmp_address((*_PREG)->u.ollll.l1); \ + (*_PREG) = (*_PREG)->u.ollll.l1; \ + (*_SREG) = RepPair(d0); \ + ALWAYS_GONext(); \ + } \ + if (d0 == TermNil) { \ + (*_PREG) = (*_PREG)->u.ollll.l2; \ + JMPNext(); \ + } \ + else { \ + if (IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.ollll.l3); \ + (*_PREG) = (*_PREG)->u.ollll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } else { \ + copy_jmp_address((*_PREG)->u.ollll.l3); \ + (*_PREG) = (*_PREG)->u.ollll.l3; \ + I_R = d0; \ + JMPNext(); \ + } \ + } \ + } +#endif + +#define SWITCH_LIST_NL_END \ + BLOCK = (CELL)SWITCH_LIST_NL_END; + +#define SWITCH_ON_ARG_TYPE_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xllll.x); \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.xllll.l4); \ + (*_PREG) = (*_PREG)->u.xllll.l4; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (IsPairTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.xllll.l1); \ + (*_PREG) = (*_PREG)->u.xllll.l1; \ + (*_SREG) = RepPair(d0); \ + JMPNext(); \ + } \ + else if (!IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.xllll.l2); \ + (*_PREG) = (*_PREG)->u.xllll.l2; \ + I_R = d0; \ + JMPNext(); \ + } \ + else { \ + copy_jmp_address((*_PREG)->u.xllll.l3); \ + (*_PREG) = (*_PREG)->u.xllll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } \ + } + +#define SWITCH_ON_ARG_TYPE_END \ + BLOCK = (CELL)SWITCH_ON_ARG_TYPE_END; + +#define SWITCH_ON_SUB_ARG_TYPE_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = (*_SREG)[(*_PREG)->u.sllll.s]; \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.sllll.l4); \ + (*_PREG) = (*_PREG)->u.sllll.l4; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (IsPairTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.sllll.l1); \ + (*_PREG) = (*_PREG)->u.sllll.l1; \ + (*_SREG) = RepPair(d0); \ + JMPNext(); \ + } \ + else if (!IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.sllll.l2); \ + (*_PREG) = (*_PREG)->u.sllll.l2; \ + I_R = d0; \ + JMPNext(); \ + } \ + else { \ + copy_jmp_address((*_PREG)->u.sllll.l3); \ + (*_PREG) = (*_PREG)->u.sllll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } \ + } + +#define SWITCH_ON_SUB_ARG_TYPE_END \ + BLOCK = (CELL)SWITCH_ON_SUB_ARG_TYPE_END; + +#define JUMP_IF_VAR_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = CACHED_A1(); \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.l.l); \ + (*_PREG) = (*_PREG)->u.l.l; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + JMPNext(); \ + } + +#define JUMP_IF_VAR_END \ + BLOCK = (CELL)JUMP_IF_VAR_END; + +#define JUMP_IF_NONVAR_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xll.x); \ + Int nonvar = 0; \ + if (IsVarTerm(d0)) { \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + (*_PREG) = NEXTOP((*_PREG), xll); \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + copy_jmp_address((*_PREG)->u.xll.l1); \ + (*_PREG) = (*_PREG)->u.xll.l1; \ + JMPNext(); \ + } + +#define JUMP_IF_NONVAR_END \ + BLOCK = (CELL)JUMP_IF_NONVAR_END; + +#define IF_NOT_THEN_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = CACHED_A1(); \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.clll.l3); \ + (*_PREG) = (*_PREG)->u.clll.l3; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (d0 == (*_PREG)->u.clll.c) { \ + copy_jmp_address((*_PREG)->u.clll.l2); \ + (*_PREG) = (*_PREG)->u.clll.l2; \ + JMPNext(); \ + } \ + else { \ + copy_jmp_address((*_PREG)->u.clll.l1); \ + (*_PREG) = (*_PREG)->u.clll.l1; \ + JMPNext(); \ + } \ + } + +#define IF_NOT_THEN_END \ + BLOCK = (CELL)IF_NOT_THEN_END; + +#define HRASH_SHIFT 6 + +#define SWITCH_ON_FUNC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d1 = *(*_SREG)++; \ + { \ + CELL \ + Mask = ((*_PREG)->u.sssl.s - 1) << 1, \ + hash = d1 >> (HRASH_SHIFT - 1) & Mask; \ + CELL *base; \ + base = (CELL *)(*_PREG)->u.sssl.l; \ + pt0 = base + hash; \ + d0 = pt0[0]; \ + if (d0 == d1 || d0 == 0) { \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) (pt0[1]); \ + JMPNext(); \ + } \ + else { \ + register CELL d = ((d1 | 1) << 1) & Mask; \ + while (1) { \ + hash = (hash + d) & Mask; \ + pt0 = base + hash; \ + d0 = pt0[0]; \ + if (d0 == d1 || d0 == 0) { \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) pt0[1]; \ + break; \ + } \ + } \ + } \ + } + +#define SWITCH_ON_FUNC_END \ + BLOCK = (CELL)SWITCH_ON_FUNC_END; + +#define SWITCH_ON_CONS_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d1 = I_R; \ + { \ + CELL \ + Mask = ((*_PREG)->u.sssl.s - 1) << 1, \ + hash = d1 >> (HRASH_SHIFT - 1) & Mask; \ + CELL *base; \ + base = (CELL *)(*_PREG)->u.sssl.l; \ + pt0 = base + hash; \ + d0 = pt0[0]; \ + if (d0 == d1 || d0 == 0) { \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) (pt0[1]); \ + JMPNext(); \ + } \ + else { \ + register CELL d = ((d1 | 1) << 1) & Mask; \ + while (1) { \ + hash = (hash + d) & Mask; \ + pt0 = base + hash; \ + d0 = pt0[0]; \ + if (d0 == d1 || d0 == 0) { \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) pt0[1]; \ + break; \ + } \ + } \ + } \ + } + +#define SWITCH_ON_CONS_END \ + BLOCK = (CELL)SWITCH_ON_CONS_END; + +#define GO_ON_FUNC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + { \ + CELL *pt = (CELL *)((*_PREG)->u.sssl.l); \ + d0 = *(*_SREG)++; \ + if (d0 == pt[0]) { \ + copy_jmp_addressa(pt+1); \ + (*_PREG) = (yamop *) pt[1]; \ + JMPNext(); \ + } else { \ + copy_jmp_addressa(pt+3); \ + (*_PREG) = (yamop *) pt[3]; \ + JMPNext(); \ + } \ + } + +#define GO_ON_FUNC_END \ + BLOCK = (CELL)GO_ON_FUNC_END; + +#define GO_ON_CONS_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + { \ + CELL *pt = (CELL *)((*_PREG)->u.sssl.l); \ + d0 = I_R; \ + if (d0 == pt[0]) { \ + copy_jmp_addressa(pt+1); \ + (*_PREG) = (yamop *) pt[1]; \ + JMPNext(); \ + } else { \ + copy_jmp_addressa(pt+3); \ + (*_PREG) = (yamop *) pt[3]; \ + JMPNext(); \ + } \ + } + +#define GO_ON_CONS_END \ + BLOCK = (CELL)GO_ON_CONS_END; + +#define IF_FUNC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d1; \ + register CELL *pt0; \ + pt0 = (CELL *) (*_PREG)->u.sssl.l; \ + d1 = *(*_SREG)++; \ + while (pt0[0] != d1 && pt0[0] != (CELL)NULL ) { \ + pt0 += 2; \ + } \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) (pt0[1]); \ + JMPNext(); + +#define IF_FUNC_END \ + BLOCK = (CELL)IF_FUNC_END; + +#define IF_CONS_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d1; \ + register CELL *pt0; \ + pt0 = (CELL *) (*_PREG)->u.sssl.l; \ + d1 = I_R; \ + while (pt0[0] != d1 && pt0[0] != 0L ) { \ + pt0 += 2; \ + } \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) (pt0[1]); \ + JMPNext(); + +#define IF_CONS_END \ + BLOCK = (CELL)IF_CONS_END; + +#define INDEX_DBREF_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + I_R = AbsAppl((*_SREG)-1); \ + GONext(); + +#define INDEX_DBREF_END \ + BLOCK = (CELL)INDEX_DBREF_END; + +#define INDEX_BLOB_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + I_R = Yap_DoubleP_key((*_SREG)); \ + GONext(); + +#define INDEX_BLOB_END \ + BLOCK = (CELL)INDEX_BLOB_END; + +#define INDEX_LONG_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + I_R = Yap_IntP_key((*_SREG)); \ + GONext(); + +#define INDEX_LONG_END \ + BLOCK = (CELL)INDEX_LONG_INSTINIT; + diff --git a/JIT/HPP/indexing_ext_d.h b/JIT/HPP/indexing_ext_d.h new file mode 100644 index 000000000..5fd3f23ca --- /dev/null +++ b/JIT/HPP/indexing_ext_d.h @@ -0,0 +1,563 @@ +#define USER_SWITCH_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + yamop *new = Yap_udi_search((*_PREG)->u.lp.p); \ + if (!new) { \ + (*_PREG) = (*_PREG)->u.lp.l; \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = new; \ + JMPNext(); \ + } \ + } + +#define USER_SWITCH_END \ + BLOCK = (CELL)USER_SWITCH_END; + +#define SWITCH_ON_TYPE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = CACHED_A1(); \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.llll.l4); \ + (*_PREG) = (*_PREG)->u.llll.l4; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (IsPairTerm(d0)) { \ + (*_SREG) = RepPair(d0); \ + copy_jmp_address((*_PREG)->u.llll.l1); \ + (*_PREG) = (*_PREG)->u.llll.l1; \ + JMPNext(); \ + } \ + else if (!IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.llll.l2); \ + (*_PREG) = (*_PREG)->u.llll.l2; \ + I_R = d0; \ + JMPNext(); \ + } \ + else { \ + copy_jmp_address((*_PREG)->u.llll.l3); \ + (*_PREG) = (*_PREG)->u.llll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } \ + } + +#define SWITCH_ON_TYPE_END \ + BLOCK = (CELL)SWITCH_ON_TYPE_END; + +#if UNIQUE_TAG_FOR_PAIRS +#define SWITCH_LIST_NL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + ALWAYS_LOOKAHEAD((*_PREG)->u.ollll.pop); \ + d0 = CACHED_A1(); \ + Int nonvar = 0; \ + Int pair = 1; \ + if (!IsPairTerm(d0)) { \ + pair = 0; \ + do { \ + if (!IsVarTerm(d0)) { \ + if (d0 == TermNil) { \ + (*_PREG) = (*_PREG)->u.ollll.l2; \ + JMPNext(); \ + } \ + else { \ + if (IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.ollll.l3); \ + (*_PREG) = (*_PREG)->u.ollll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } else { \ + copy_jmp_address((*_PREG)->u.ollll.l3); \ + (*_PREG) = (*_PREG)->u.ollll.l3; \ + I_R = d0; \ + JMPNext(); \ + } \ + } \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(pt0); \ + if (Unsigned(pt0) == (d0)) break; \ + if (IsPairTerm(d0)) { \ + pair = 1; \ + break; \ + } \ + } while (TRUE); \ + if (!nonvar && !pair) { \ + copy_jmp_address((*_PREG)->u.ollll.l4); \ + (*_PREG) = (*_PREG)->u.ollll.l4; \ + JMPNext(); \ + } \ + } \ + if (!nonvar && pair) { \ + copy_jmp_address((*_PREG)->u.ollll.l1); \ + (*_PREG) = (*_PREG)->u.ollll.l1; \ + (*_SREG) = RepPair(d0); \ + ALWAYS_GONext(); \ + } +#else +#define SWITCH_LIST_NL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + ALWAYS_LOOKAHEAD((*_PREG)->u.ollll.pop); \ + d0 = CACHED_A1(); \ + Int nonvar = 0; \ + if (IsVarTerm(d0)) { \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.ollll.l4); \ + (*_PREG) = (*_PREG)->u.ollll.l4; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (__builtin_expect(IsPairTerm(d0),1)) { \ + copy_jmp_address((*_PREG)->u.ollll.l1); \ + (*_PREG) = (*_PREG)->u.ollll.l1; \ + (*_SREG) = RepPair(d0); \ + ALWAYS_GONext(); \ + } \ + if (d0 == TermNil) { \ + (*_PREG) = (*_PREG)->u.ollll.l2; \ + JMPNext(); \ + } \ + else { \ + if (IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.ollll.l3); \ + (*_PREG) = (*_PREG)->u.ollll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } else { \ + copy_jmp_address((*_PREG)->u.ollll.l3); \ + (*_PREG) = (*_PREG)->u.ollll.l3; \ + I_R = d0; \ + JMPNext(); \ + } \ + } \ + } +#endif + +#define SWITCH_LIST_NL_END \ + BLOCK = (CELL)SWITCH_LIST_NL_END; + +#define SWITCH_ON_ARG_TYPE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xllll.x); \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.xllll.l4); \ + (*_PREG) = (*_PREG)->u.xllll.l4; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (IsPairTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.xllll.l1); \ + (*_PREG) = (*_PREG)->u.xllll.l1; \ + (*_SREG) = RepPair(d0); \ + JMPNext(); \ + } \ + else if (!IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.xllll.l2); \ + (*_PREG) = (*_PREG)->u.xllll.l2; \ + I_R = d0; \ + JMPNext(); \ + } \ + else { \ + copy_jmp_address((*_PREG)->u.xllll.l3); \ + (*_PREG) = (*_PREG)->u.xllll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } \ + } + +#define SWITCH_ON_ARG_TYPE_END \ + BLOCK = (CELL)SWITCH_ON_ARG_TYPE_END; + +#define SWITCH_ON_SUB_ARG_TYPE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = (*_SREG)[(*_PREG)->u.sllll.s]; \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.sllll.l4); \ + (*_PREG) = (*_PREG)->u.sllll.l4; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (IsPairTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.sllll.l1); \ + (*_PREG) = (*_PREG)->u.sllll.l1; \ + (*_SREG) = RepPair(d0); \ + JMPNext(); \ + } \ + else if (!IsApplTerm(d0)) { \ + copy_jmp_address((*_PREG)->u.sllll.l2); \ + (*_PREG) = (*_PREG)->u.sllll.l2; \ + I_R = d0; \ + JMPNext(); \ + } \ + else { \ + copy_jmp_address((*_PREG)->u.sllll.l3); \ + (*_PREG) = (*_PREG)->u.sllll.l3; \ + (*_SREG) = RepAppl(d0); \ + JMPNext(); \ + } \ + } + +#define SWITCH_ON_SUB_ARG_TYPE_END \ + BLOCK = (CELL)SWITCH_ON_SUB_ARG_TYPE_END; + +#define JUMP_IF_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = CACHED_A1(); \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.l.l); \ + (*_PREG) = (*_PREG)->u.l.l; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + JMPNext(); \ + } + +#define JUMP_IF_VAR_END \ + BLOCK = (CELL)JUMP_IF_VAR_END; + +#define JUMP_IF_NONVAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xll.x); \ + Int nonvar = 0; \ + if (IsVarTerm(d0)) { \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + (*_PREG) = NEXTOP((*_PREG), xll); \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + copy_jmp_address((*_PREG)->u.xll.l1); \ + (*_PREG) = (*_PREG)->u.xll.l1; \ + JMPNext(); \ + } + +#define JUMP_IF_NONVAR_END \ + BLOCK = (CELL)JUMP_IF_NONVAR_END; + +#define IF_NOT_THEN_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = CACHED_A1(); \ + Int nonvar = 1; \ + if (IsVarTerm(d0)) { \ + nonvar = 0; \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + if (!nonvar) { \ + copy_jmp_address((*_PREG)->u.clll.l3); \ + (*_PREG) = (*_PREG)->u.clll.l3; \ + JMPNext(); \ + } \ + } \ + if (nonvar) { \ + if (d0 == (*_PREG)->u.clll.c) { \ + copy_jmp_address((*_PREG)->u.clll.l2); \ + (*_PREG) = (*_PREG)->u.clll.l2; \ + JMPNext(); \ + } \ + else { \ + copy_jmp_address((*_PREG)->u.clll.l1); \ + (*_PREG) = (*_PREG)->u.clll.l1; \ + JMPNext(); \ + } \ + } + +#define IF_NOT_THEN_END \ + BLOCK = (CELL)IF_NOT_THEN_END; + +#define HRASH_SHIFT 6 + +#define SWITCH_ON_FUNC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d1 = *(*_SREG)++; \ + { \ + CELL \ + Mask = ((*_PREG)->u.sssl.s - 1) << 1, \ + hash = d1 >> (HRASH_SHIFT - 1) & Mask; \ + CELL *base; \ + base = (CELL *)(*_PREG)->u.sssl.l; \ + pt0 = base + hash; \ + d0 = pt0[0]; \ + if (d0 == d1 || d0 == 0) { \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) (pt0[1]); \ + JMPNext(); \ + } \ + else { \ + register CELL d = ((d1 | 1) << 1) & Mask; \ + while (1) { \ + hash = (hash + d) & Mask; \ + pt0 = base + hash; \ + d0 = pt0[0]; \ + if (d0 == d1 || d0 == 0) { \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) pt0[1]; \ + break; \ + } \ + } \ + } \ + } + +#define SWITCH_ON_FUNC_END \ + BLOCK = (CELL)SWITCH_ON_FUNC_END; + +#define SWITCH_ON_CONS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d1 = I_R; \ + { \ + CELL \ + Mask = ((*_PREG)->u.sssl.s - 1) << 1, \ + hash = d1 >> (HRASH_SHIFT - 1) & Mask; \ + CELL *base; \ + base = (CELL *)(*_PREG)->u.sssl.l; \ + pt0 = base + hash; \ + d0 = pt0[0]; \ + if (d0 == d1 || d0 == 0) { \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) (pt0[1]); \ + JMPNext(); \ + } \ + else { \ + register CELL d = ((d1 | 1) << 1) & Mask; \ + while (1) { \ + hash = (hash + d) & Mask; \ + pt0 = base + hash; \ + d0 = pt0[0]; \ + if (d0 == d1 || d0 == 0) { \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) pt0[1]; \ + break; \ + } \ + } \ + } \ + } + +#define SWITCH_ON_CONS_END \ + BLOCK = (CELL)SWITCH_ON_CONS_END; + +#define GO_ON_FUNC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + { \ + CELL *pt = (CELL *)((*_PREG)->u.sssl.l); \ + d0 = *(*_SREG)++; \ + if (d0 == pt[0]) { \ + copy_jmp_addressa(pt+1); \ + (*_PREG) = (yamop *) pt[1]; \ + JMPNext(); \ + } else { \ + copy_jmp_addressa(pt+3); \ + (*_PREG) = (yamop *) pt[3]; \ + JMPNext(); \ + } \ + } + +#define GO_ON_FUNC_END \ + BLOCK = (CELL)GO_ON_FUNC_END; + +#define GO_ON_CONS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + { \ + CELL *pt = (CELL *)((*_PREG)->u.sssl.l); \ + d0 = I_R; \ + if (d0 == pt[0]) { \ + copy_jmp_addressa(pt+1); \ + (*_PREG) = (yamop *) pt[1]; \ + JMPNext(); \ + } else { \ + copy_jmp_addressa(pt+3); \ + (*_PREG) = (yamop *) pt[3]; \ + JMPNext(); \ + } \ + } + +#define GO_ON_CONS_END \ + BLOCK = (CELL)GO_ON_CONS_END; + +#define IF_FUNC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d1; \ + register CELL *pt0; \ + pt0 = (CELL *) (*_PREG)->u.sssl.l; \ + d1 = *(*_SREG)++; \ + while (pt0[0] != d1 && pt0[0] != (CELL)NULL ) { \ + pt0 += 2; \ + } \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) (pt0[1]); \ + JMPNext(); + +#define IF_FUNC_END \ + BLOCK = (CELL)IF_FUNC_END; + +#define IF_CONS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d1; \ + register CELL *pt0; \ + pt0 = (CELL *) (*_PREG)->u.sssl.l; \ + d1 = I_R; \ + while (pt0[0] != d1 && pt0[0] != 0L ) { \ + pt0 += 2; \ + } \ + copy_jmp_addressa(pt0+1); \ + (*_PREG) = (yamop *) (pt0[1]); \ + JMPNext(); + +#define IF_CONS_END \ + BLOCK = (CELL)IF_CONS_END; + +#define INDEX_DBREF_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + I_R = AbsAppl((*_SREG)-1); \ + GONext(); + +#define INDEX_DBREF_END \ + BLOCK = (CELL)INDEX_DBREF_END; + +#define INDEX_BLOB_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + I_R = Yap_DoubleP_key((*_SREG)); \ + GONext(); + +#define INDEX_BLOB_END \ + BLOCK = (CELL)INDEX_BLOB_END; + +#define INDEX_LONG_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + I_R = Yap_IntP_key((*_SREG)); \ + GONext(); + +#define INDEX_LONG_END \ + BLOCK = (CELL)INDEX_LONG_INSTINIT; + diff --git a/JIT/HPP/indexing_std.h b/JIT/HPP/indexing_std.h new file mode 100644 index 000000000..54211a91f --- /dev/null +++ b/JIT/HPP/indexing_std.h @@ -0,0 +1,1316 @@ +#define TRY_ME_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + store_at_least_one_arg((*_PREG)->u.Otapl.s); \ + store_yaam_regs((*_PREG)->u.Otapl.d, 0); \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_ME_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_ME_END \ + BLOCK = (CELL)TRY_ME_END; \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + GONext(); + +#define RETRY_ME_INSTINIT \ + CACHE_Y(B); \ + restore_yaam_regs((*_PREG)->u.Otapl.d); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define RETRY_ME_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY_ME_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY_ME_END \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#define TRUST_ME_INSTINIT \ + CACHE_Y(B); + +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define TRUST_ME_YAPOR_IF \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } +#else /* FROZEN_STACKS */ +#define TRUST_ME_YAPOR_IF \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } +#endif /* FROZEN STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define TRUST_ME_YAPOR_IF \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } +#else /* FROZEN_STACKS */ +#define TRUST_ME_IF \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } +#endif /* FROZEN STACKS */ +#endif /* YAPOR */ + +#define TRUST_ME_END \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + GONext(); + +#define ENTER_PROFILING_INSTINIT \ + LOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG)->u.p.p->StatisticsForPred.NOfEntries++; \ + UNLOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); + +#define RETRY_PROFILED_INSTINIT \ + LOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG)->u.p.p->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); + +#define PROFILED_RETRY_ME_INSTINIT \ + CACHE_Y(B); \ + LOCK((*_PREG)->u.Otapl.p->StatisticsForPred.lock); \ + (*_PREG)->u.Otapl.p->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.Otapl.p->StatisticsForPred.lock); \ + restore_yaam_regs((*_PREG)->u.Otapl.d); \ + restore_args((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define PROFILED_RETRY_ME_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define PROFILED_RETRY_ME_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define PROFILED_RETRY_ME_END \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#define PROFILED_TRUST_ME_INSTINIT \ + CACHE_Y(B); + +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_ME_IF \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_ME_IF \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_ME_IF \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_ME_IF \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ + +#define PROFILED_TRUST_ME_END \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCK((*_PREG)->u.Otapl.p->StatisticsForPred.lock); \ + (*_PREG)->u.Otapl.p->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.Otapl.p->StatisticsForPred.lock); \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#define PROFILED_RETRY_LOGICAL_INSTINIT \ + check_trail(TR); \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + else { \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + } + +#ifdef THREADS +#define PROFILED_RETRY_LOGICAL_THREADS \ + PP = (*_PREG)->u.OtaLl.d->ClPred; +#endif + +#define PROFILED_RETRY_LOGICAL_POST_THREADS \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; + +#ifdef FROZEN_STACKS +#define PROFILED_RETRY_LOGICAL_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define PROFILED_RETRY_LOGICAL_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define PROFILED_RETRY_LOGICAL_END \ + BLOCKADDRESS = (CELL)(*_PREG); \ + BLOCK = (CELL)PROFILED_RETRY_LOGICAL_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); + +#if MULTIPLE_STACKS +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(1, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + B->cp_tr--; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(1, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + B->cp_tr--; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(1, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + B->cp_tr--; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(1, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + B->cp_tr--; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#else /* MULTIPLE_STACKS */ +#if FROZEN_STACKS +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#endif /* MULTIPLE_STACKS */ + +#define PROFILED_TRUST_LOGICAL_END \ + BLOCK = (CELL)PROFILED_TRUST_LOGICAL_END; + +#define TRY_CLAUSE_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + store_at_least_one_arg((*_PREG)->u.Otapl.s); \ + store_yaam_regs(NEXTOP((*_PREG), Otapl), 0); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_CLAUSE_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_CLAUSE_END \ + BLOCK = (CELL)TRY_CLAUSE_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define TRY_CLAUSE2_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + { \ + register CELL x2 = ARG2; \ + register CELL x1 = ARG1; \ + store_yaam_regs(NEXTOP((*_PREG), l), 2); \ + B_YREG->cp_a1 = x1; \ + B_YREG->cp_a2 = x2; \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + set_cut(S_YREG, B); \ + B = B_YREG; + + +#ifdef YAPOR +#define TRY_CLAUSE2_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_CLAUSE2_END \ + BLOCK = (CELL)TRY_CLAUSE2_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define TRY_CLAUSE3_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + { \ + store_yaam_regs(NEXTOP((*_PREG), l), 3); \ + B_YREG->cp_a1 = ARG1; \ + B_YREG->cp_a2 = ARG2; \ + B_YREG->cp_a3 = ARG3; \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_CLAUSE3_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_CLAUSE3_END \ + BLOCK = (CELL)TRY_CLAUSE3_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define TRY_CLAUSE4_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + { \ + store_yaam_regs(NEXTOP((*_PREG), l), 4); \ + B_YREG->cp_a1 = ARG1; \ + B_YREG->cp_a2 = ARG2; \ + B_YREG->cp_a3 = ARG3; \ + B_YREG->cp_a4 = ARG4; \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_CLAUSE4_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_CLAUSE4_END \ + BLOCK = (CELL)TRY_CLAUSE4_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define RETRY_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + restore_yaam_regs(NEXTOP((*_PREG), Otapl)); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define RETRY_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY_END \ + BLOCK = (CELL)RETRY_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + JMPNext(); + +#define RETRY2_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + restore_yaam_regs(NEXTOP((*_PREG), l)); \ + (*_PREG) = (*_PREG)->u.l.l; \ + ARG1 = B_YREG->cp_a1; \ + ARG2 = B_YREG->cp_a2; + +#ifdef FROZEN_STACKS +#define RETRY2_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY2_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY2_END \ + BLOCK = (CELL)RETRY2_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define RETRY3_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + restore_yaam_regs(NEXTOP((*_PREG), l)); \ + (*_PREG) = (*_PREG)->u.l.l; \ + ARG1 = B_YREG->cp_a1; \ + ARG2 = B_YREG->cp_a2; \ + ARG3 = B_YREG->cp_a3; + +#ifdef FROZEN_STACKS +#define RETRY3_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY3_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY3_END \ + BLOCK = (CELL)RETRY3_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define RETRY4_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + restore_yaam_regs(NEXTOP((*_PREG), l)); \ + (*_PREG) = (*_PREG)->u.l.l; \ + ARG1 = B_YREG->cp_a1; \ + ARG2 = B_YREG->cp_a2; \ + ARG3 = B_YREG->cp_a3; \ + ARG4 = B_YREG->cp_a4; + +#ifdef FROZEN_STACKS +#define RETRY4_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY4_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY4_END \ + BLOCK = (CELL)RETRY4_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define TRUST_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); + +#ifdef YAPOR +#define TRUST_IFOK_INIT \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); +#ifdef FROZEN_STACKS +#define TRUST_IFOK_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif +#define TRUST_IFOK_END \ + set_cut(S_YREG, B->cp_b); \ + } \ + else +#endif + +#define TRUST_NOIF_INIT \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define TRUST_NOIF_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif + +#define TRUST_END \ + BLOCK = (CELL)TRUST_END; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + JMPNext(); + +#define TRY_IN_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + B->cp_ap = NEXTOP((*_PREG), l); \ + (*_PREG) = (*_PREG)->u.l.l; \ + JMPNext(); + +#define TRY_IN_END \ + BLOCK = (CELL)TRY_IN_END; + +#define SPY_OR_TRYMARK_INSTINIT \ + PELOCK(5, ((PredEntry *)((*_PREG)->u.Otapl.p))); \ + (*_PREG) = (yamop *)(&(((PredEntry *)((*_PREG)->u.Otapl.p))->OpcodeOfPred)); \ + UNLOCKPE(11,(PredEntry *)((*_PREG)->u.Otapl.p)); \ + return external_labels[12]; + +#define TRY_AND_MARK_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); + +#if defined(YAPOR) || defined(THREADS) +#ifdef YAPOR +#define TRY_AND_MARK_YAPOR_THREADS_YAPOR \ + CUT_wait_leftmost(); +#endif + +#define TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF \ + BLOCK = (CELL)TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF; \ + if ((*_PREG)->u.Otapl.p->PredFlags & LogUpdatePredFlag) { \ + PELOCK(6,(*_PREG)->u.Otapl.p); \ + PP = (*_PREG)->u.Otapl.p; \ + } \ + if ((*_PREG)->u.Otapl.p->CodeOfPred != (*_PREG)) { \ + PP = NULL; \ + (*_PREG) = (*_PREG)->u.Otapl.p->CodeOfPred; \ + UNLOCKPE(12,(*_PREG)->u.Otapl.p); \ + save_pc(); \ + JMPNext(); \ + } +#endif + +#define TRY_AND_MARK_NOYAPOR_NOTHREADS \ + CACHE_Y(YREG); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + LOCK(DynamicLock((*_PREG))); \ + UNLOCKPE(13,((PredEntry *)((*_PREG)->u.Otapl.p))); \ + BEGD(d1); \ + d1 = (*_PREG)->u.Otapl.s; \ + store_args(d1); \ + store_yaam_regs((*_PREG), 0); \ + ENDD(d1); \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_AND_MARK_SET_LOAD \ + SCH_set_load(B_YREG); +#endif + +#define TRY_AND_MARK_POST_SET_LOAD \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); + +#if MULTIPLE_STACKS +#define TRY_AND_MARK_MULTIPLE_STACKS \ + INC_CLREF_COUNT(ClauseCodeToDynamicClause((*_PREG))); \ + UNLOCK(DynamicLock((*_PREG))); \ + TRAIL_CLREF(ClauseCodeToDynamicClause((*_PREG))); +#else +#define TRY_AND_MARK_NOMULTIPLE_STACKS_IF \ + if (FlagOff(InUseMask, DynamicFlags((*_PREG)))) { \ + SetFlag(InUseMask, DynamicFlags((*_PREG))); \ + TRAIL_CLREF(ClauseCodeToDynamicClause((*_PREG))); \ + } +#endif + +#define TRY_AND_MARK_END \ + (*_PREG) = NEXTOP((*_PREG),Otapl); \ + JMPNext(); + +#define COUNT_RETRY_AND_MARK_INSTINIT \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + else { \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + } + +#define PROFILED_RETRY_AND_MARK_INSTINIT \ + LOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + ((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.NOfRetries++; \ + UNLOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + +#define RETRY_AND_MARK_INSTINIT + +#ifdef YAPOR +#define RETRY_AND_MARK_YAPOR \ + CUT_wait_leftmost(); +#endif + +#define RETRY_AND_MARK_POST_YAPOR \ + PELOCK(7,(*_PREG)->u.Otapl.p); \ + CACHE_Y(B); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + LOCK(DynamicLock((*_PREG))); \ + UNLOCK((*_PREG)->u.Otapl.p->PELock); \ + restore_yaam_regs((*_PREG)); \ + restore_args((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define RETRY_AND_MARK_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY_AND_MARK_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY_AND_MARK_POST_FROZEN \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); + +#if MULTIPLE_STACKS +#define RETRY_AND_MARK_MULTIPLE_STACKS \ + INC_CLREF_COUNT(ClauseCodeToDynamicClause((*_PREG))); \ + TRAIL_CLREF(ClauseCodeToDynamicClause((*_PREG))); \ + UNLOCK(DynamicLock((*_PREG))); +#else +#define RETRY_AND_MARK_NOMULTIPLE_STACKS_IF \ + if (FlagOff(InUseMask, DynamicFlags((*_PREG)))) { \ + SetFlag(InUseMask, DynamicFlags((*_PREG))); \ + TRAIL_CLREF(ClauseCodeToDynamicClause((*_PREG))); \ + } +#endif + +#define RETRY_AND_MARK_END \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + JMPNext(); + diff --git a/JIT/HPP/indexing_std_d.h b/JIT/HPP/indexing_std_d.h new file mode 100644 index 000000000..7a1f490ef --- /dev/null +++ b/JIT/HPP/indexing_std_d.h @@ -0,0 +1,1350 @@ +#define TRY_ME_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + store_at_least_one_arg((*_PREG)->u.Otapl.s); \ + store_yaam_regs((*_PREG)->u.Otapl.d, 0); \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_ME_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_ME_END \ + BLOCK = (CELL)TRY_ME_END; \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + GONext(); + +#define RETRY_ME_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_Y(B); \ + restore_yaam_regs((*_PREG)->u.Otapl.d); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define RETRY_ME_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY_ME_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY_ME_END \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#define TRUST_ME_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_Y(B); + +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define TRUST_ME_YAPOR_IF \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } +#else /* FROZEN_STACKS */ +#define TRUST_ME_YAPOR_IF \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } +#endif /* FROZEN STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define TRUST_ME_YAPOR_IF \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } +#else /* FROZEN_STACKS */ +#define TRUST_ME_IF \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } +#endif /* FROZEN STACKS */ +#endif /* YAPOR */ + +#define TRUST_ME_END \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + GONext(); + +#define ENTER_PROFILING_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + LOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG)->u.p.p->StatisticsForPred.NOfEntries++; \ + UNLOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); + +#define RETRY_PROFILED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + LOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG)->u.p.p->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); + +#define PROFILED_RETRY_ME_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_Y(B); \ + LOCK((*_PREG)->u.Otapl.p->StatisticsForPred.lock); \ + (*_PREG)->u.Otapl.p->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.Otapl.p->StatisticsForPred.lock); \ + restore_yaam_regs((*_PREG)->u.Otapl.d); \ + restore_args((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define PROFILED_RETRY_ME_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define PROFILED_RETRY_ME_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define PROFILED_RETRY_ME_END \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#define PROFILED_TRUST_ME_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_Y(B); + +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_ME_IF \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_ME_IF \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_ME_IF \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_ME_IF \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ + +#define PROFILED_TRUST_ME_END \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCK((*_PREG)->u.Otapl.p->StatisticsForPred.lock); \ + (*_PREG)->u.Otapl.p->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.Otapl.p->StatisticsForPred.lock); \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#define PROFILED_RETRY_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + check_trail(TR); \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + else { \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + } + +#ifdef THREADS +#define PROFILED_RETRY_LOGICAL_THREADS \ + PP = (*_PREG)->u.OtaLl.d->ClPred; +#endif + +#define PROFILED_RETRY_LOGICAL_POST_THREADS \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; + +#ifdef FROZEN_STACKS +#define PROFILED_RETRY_LOGICAL_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define PROFILED_RETRY_LOGICAL_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define PROFILED_RETRY_LOGICAL_END \ + BLOCKADDRESS = (CELL)(*_PREG); \ + BLOCK = (CELL)PROFILED_RETRY_LOGICAL_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); + +#if MULTIPLE_STACKS +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(1, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + B->cp_tr--; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(1, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + B->cp_tr--; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(1, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + B->cp_tr--; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(1, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + B->cp_tr--; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#else /* MULTIPLE_STACKS */ +#if FROZEN_STACKS +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define PROFILED_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } \ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#endif /* MULTIPLE_STACKS */ + +#define PROFILED_TRUST_LOGICAL_END \ + BLOCK = (CELL)PROFILED_TRUST_LOGICAL_END; + +#define TRY_CLAUSE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + store_at_least_one_arg((*_PREG)->u.Otapl.s); \ + store_yaam_regs(NEXTOP((*_PREG), Otapl), 0); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_CLAUSE_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_CLAUSE_END \ + BLOCK = (CELL)TRY_CLAUSE_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define TRY_CLAUSE2_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + { \ + register CELL x2 = ARG2; \ + register CELL x1 = ARG1; \ + store_yaam_regs(NEXTOP((*_PREG), l), 2); \ + B_YREG->cp_a1 = x1; \ + B_YREG->cp_a2 = x2; \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + set_cut(S_YREG, B); \ + B = B_YREG; + + +#ifdef YAPOR +#define TRY_CLAUSE2_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_CLAUSE2_END \ + BLOCK = (CELL)TRY_CLAUSE2_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define TRY_CLAUSE3_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + { \ + store_yaam_regs(NEXTOP((*_PREG), l), 3); \ + B_YREG->cp_a1 = ARG1; \ + B_YREG->cp_a2 = ARG2; \ + B_YREG->cp_a3 = ARG3; \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_CLAUSE3_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_CLAUSE3_END \ + BLOCK = (CELL)TRY_CLAUSE3_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define TRY_CLAUSE4_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); \ + CACHE_Y(YREG); \ + { \ + store_yaam_regs(NEXTOP((*_PREG), l), 4); \ + B_YREG->cp_a1 = ARG1; \ + B_YREG->cp_a2 = ARG2; \ + B_YREG->cp_a3 = ARG3; \ + B_YREG->cp_a4 = ARG4; \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_CLAUSE4_YAPOR \ + SCH_set_load(B_YREG); +#endif + +#define TRY_CLAUSE4_END \ + BLOCK = (CELL)TRY_CLAUSE4_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define RETRY_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + restore_yaam_regs(NEXTOP((*_PREG), Otapl)); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define RETRY_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY_END \ + BLOCK = (CELL)RETRY_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + JMPNext(); + +#define RETRY2_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + restore_yaam_regs(NEXTOP((*_PREG), l)); \ + (*_PREG) = (*_PREG)->u.l.l; \ + ARG1 = B_YREG->cp_a1; \ + ARG2 = B_YREG->cp_a2; + +#ifdef FROZEN_STACKS +#define RETRY2_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY2_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY2_END \ + BLOCK = (CELL)RETRY2_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define RETRY3_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + restore_yaam_regs(NEXTOP((*_PREG), l)); \ + (*_PREG) = (*_PREG)->u.l.l; \ + ARG1 = B_YREG->cp_a1; \ + ARG2 = B_YREG->cp_a2; \ + ARG3 = B_YREG->cp_a3; + +#ifdef FROZEN_STACKS +#define RETRY3_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY3_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY3_END \ + BLOCK = (CELL)RETRY3_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define RETRY4_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + restore_yaam_regs(NEXTOP((*_PREG), l)); \ + (*_PREG) = (*_PREG)->u.l.l; \ + ARG1 = B_YREG->cp_a1; \ + ARG2 = B_YREG->cp_a2; \ + ARG3 = B_YREG->cp_a3; \ + ARG4 = B_YREG->cp_a4; + +#ifdef FROZEN_STACKS +#define RETRY4_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY4_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY4_END \ + BLOCK = (CELL)RETRY4_END; \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); + +#define TRUST_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); + +#ifdef YAPOR +#define TRUST_IFOK_INIT \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_at_least_one_arg((*_PREG)->u.Otapl.s); +#ifdef FROZEN_STACKS +#define TRUST_IFOK_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif +#define TRUST_IFOK_END \ + set_cut(S_YREG, B->cp_b); \ + } \ + else +#endif + +#define TRUST_NOIF_INIT \ + { \ + pop_yaam_regs(); \ + pop_at_least_one_arg((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define TRUST_NOIF_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif + +#define TRUST_END \ + BLOCK = (CELL)TRUST_END; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + JMPNext(); + +#define TRY_IN_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + B->cp_ap = NEXTOP((*_PREG), l); \ + (*_PREG) = (*_PREG)->u.l.l; \ + JMPNext(); + +#define TRY_IN_END \ + BLOCK = (CELL)TRY_IN_END; + +#define SPY_OR_TRYMARK_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + PELOCK(5, ((PredEntry *)((*_PREG)->u.Otapl.p))); \ + (*_PREG) = (yamop *)(&(((PredEntry *)((*_PREG)->u.Otapl.p))->OpcodeOfPred)); \ + UNLOCKPE(11,(PredEntry *)((*_PREG)->u.Otapl.p)); \ + return external_labels[12]; + +#define TRY_AND_MARK_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + check_trail(TR); + +#if defined(YAPOR) || defined(THREADS) +#ifdef YAPOR +#define TRY_AND_MARK_YAPOR_THREADS_YAPOR \ + CUT_wait_leftmost(); +#endif + +#define TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF \ + BLOCK = (CELL)TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF; \ + if ((*_PREG)->u.Otapl.p->PredFlags & LogUpdatePredFlag) { \ + PELOCK(6,(*_PREG)->u.Otapl.p); \ + PP = (*_PREG)->u.Otapl.p; \ + } \ + if ((*_PREG)->u.Otapl.p->CodeOfPred != (*_PREG)) { \ + PP = NULL; \ + (*_PREG) = (*_PREG)->u.Otapl.p->CodeOfPred; \ + UNLOCKPE(12,(*_PREG)->u.Otapl.p); \ + save_pc(); \ + JMPNext(); \ + } +#endif + +#define TRY_AND_MARK_NOYAPOR_NOTHREADS \ + CACHE_Y(YREG); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + LOCK(DynamicLock((*_PREG))); \ + UNLOCKPE(13,((PredEntry *)((*_PREG)->u.Otapl.p))); \ + BEGD(d1); \ + d1 = (*_PREG)->u.Otapl.s; \ + store_args(d1); \ + store_yaam_regs((*_PREG), 0); \ + ENDD(d1); \ + set_cut(S_YREG, B); \ + B = B_YREG; + +#ifdef YAPOR +#define TRY_AND_MARK_SET_LOAD \ + SCH_set_load(B_YREG); +#endif + +#define TRY_AND_MARK_POST_SET_LOAD \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); + +#if MULTIPLE_STACKS +#define TRY_AND_MARK_MULTIPLE_STACKS \ + INC_CLREF_COUNT(ClauseCodeToDynamicClause((*_PREG))); \ + UNLOCK(DynamicLock((*_PREG))); \ + TRAIL_CLREF(ClauseCodeToDynamicClause((*_PREG))); +#else +#define TRY_AND_MARK_NOMULTIPLE_STACKS_IF \ + if (FlagOff(InUseMask, DynamicFlags((*_PREG)))) { \ + SetFlag(InUseMask, DynamicFlags((*_PREG))); \ + TRAIL_CLREF(ClauseCodeToDynamicClause((*_PREG))); \ + } +#endif + +#define TRY_AND_MARK_END \ + (*_PREG) = NEXTOP((*_PREG),Otapl); \ + JMPNext(); + +#define COUNT_RETRY_AND_MARK_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + else { \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + } + +#define PROFILED_RETRY_AND_MARK_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + LOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + ((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.NOfRetries++; \ + UNLOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + +#define RETRY_AND_MARK_INSTINIT + +#ifdef YAPOR +#define RETRY_AND_MARK_YAPOR \ + CUT_wait_leftmost(); +#endif + +#define RETRY_AND_MARK_POST_YAPOR \ + PELOCK(7,(*_PREG)->u.Otapl.p); \ + CACHE_Y(B); \ + (*_PREG) = (*_PREG)->u.Otapl.d; \ + LOCK(DynamicLock((*_PREG))); \ + UNLOCK((*_PREG)->u.Otapl.p->PELock); \ + restore_yaam_regs((*_PREG)); \ + restore_args((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define RETRY_AND_MARK_FROZEN \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); +#else +#define RETRY_AND_MARK_NOFROZEN \ + set_cut(S_YREG, B_YREG->cp_b); +#endif + +#define RETRY_AND_MARK_POST_FROZEN \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); + +#if MULTIPLE_STACKS +#define RETRY_AND_MARK_MULTIPLE_STACKS \ + INC_CLREF_COUNT(ClauseCodeToDynamicClause((*_PREG))); \ + TRAIL_CLREF(ClauseCodeToDynamicClause((*_PREG))); \ + UNLOCK(DynamicLock((*_PREG))); +#else +#define RETRY_AND_MARK_NOMULTIPLE_STACKS_IF \ + if (FlagOff(InUseMask, DynamicFlags((*_PREG)))) { \ + SetFlag(InUseMask, DynamicFlags((*_PREG))); \ + TRAIL_CLREF(ClauseCodeToDynamicClause((*_PREG))); \ + } +#endif + +#define RETRY_AND_MARK_END \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + JMPNext(); + diff --git a/JIT/HPP/jit_predicates.hh b/JIT/HPP/jit_predicates.hh new file mode 100644 index 000000000..ebf661235 --- /dev/null +++ b/JIT/HPP/jit_predicates.hh @@ -0,0 +1,45 @@ +#include "Yap.h" +#include "clause.h" +#include "eval.h" +#if HRAVE_ERRNO_H +#include +#else +extern int errno; +#endif +#include +#include + +#define UPPER_ENTRY(S) \ + tmp = (char*)malloc((strlen(S)+1)*sizeof(char)); \ + while (S[i]) { \ + if (S[i] != '-' && S[i] != '_' && S[i] != ' ') { \ + if ((S[i] >= '0' && S[i] <= '9') || (S[i] == '.')) \ + tmp[j] = S[i]; \ + else \ + tmp[j] = toupper(S[i]); \ + j++; \ + } \ + i++; \ + } \ + tmp[j] = 0; \ + strcpy(S, tmp); \ + free(tmp); + +#if YAP_JIT +void Yap_InitJitAnalysisPreds( void ); +void Yap_InitJitCodegenPreds( void ); +void Yap_InitJitConfigPreds( void ); +void Yap_InitJitTransformPreds( void ); +#if YAP_STAT_PREDS +void Yap_InitJitStatisticPreds( void ); +#endif +#endif /* YAP_JIT */ +#if YAP_DBG_PREDS +void Yap_InitJitDebugPreds( void ); +#endif + +Environment ExpEnv; +#if YAP_JIT +extern NativeContext *NativeArea; +extern IntermediatecodeContext *IntermediatecodeArea; +#endif diff --git a/JIT/HPP/lastop.h b/JIT/HPP/lastop.h new file mode 100644 index 000000000..f81cbd3a0 --- /dev/null +++ b/JIT/HPP/lastop.h @@ -0,0 +1,2398 @@ +yamop* lastop_of(yamop*); + +yamop* +lastop_of(yamop* _p) { + op_numbers op; + yamop* lastp = NULL; + while( (op = Yap_op_from_opcode(_p->opc)) ){ + lastp = _p; + switch(op){ + case _Ystop : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _Nstop : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _try_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _enter_profiling : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _retry_profiled : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _profiled_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _profiled_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _profiled_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _profiled_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _count_call : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _count_retry : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _count_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _count_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _count_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _count_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _lock_lu : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _unlock_lu : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _alloc_for_logical_pred : + _p = ((yamop *)(&((_p)->u.L.next))); + break; + case _copy_idb_term : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _unify_idb_term : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _ensure_space : + _p = ((yamop *)(&((_p)->u.Osbpa.next))); + break; + case _spy_or_trymark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _try_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _count_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _profiled_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _trust_fail : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _op_fail : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _cut : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _cut_t : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _cut_e : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _save_b_x : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _save_b_y : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _commit_b_x : + _p = ((yamop *)(&((_p)->u.xps.next))); + break; + case _commit_b_y : + _p = ((yamop *)(&((_p)->u.yps.next))); + break; + case _execute : + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + case _dexecute : + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + case _fcall : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _call : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _procceed : + _p = ((yamop *)(&((_p)->u.p.next))); + l = (CELL)_p; + break; + case _allocate : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _deallocate : + _p = ((yamop *)(&((_p)->u.p.next))); + break; +#ifdef BEAM + case _retry_eam : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif +#ifdef BEAM + case _run_eam : + _p = ((yamop *)(&((_p)->u.os.next))); + break; +#endif + case _get_x_var : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _get_y_var : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _get_yy_var : + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + case _get_x_val : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _get_y_val : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _get_atom : + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + case _get_2atoms : + _p = ((yamop *)(&((_p)->u.cc.next))); + break; + case _get_3atoms : + _p = ((yamop *)(&((_p)->u.ccc.next))); + break; + case _get_4atoms : + _p = ((yamop *)(&((_p)->u.cccc.next))); + break; + case _get_5atoms : + _p = ((yamop *)(&((_p)->u.ccccc.next))); + break; + case _get_6atoms : + _p = ((yamop *)(&((_p)->u.cccccc.next))); + break; + case _get_list : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _get_struct : + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + case _get_float : + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + case _get_longint : + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + case _get_bigint : + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + case _get_dbterm : + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + case _glist_valx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _glist_valy : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _gl_void_varx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _gl_void_vary : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _gl_void_valx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _gl_void_valy : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _unify_x_var : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_x_var_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_var : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_var_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_x_var2 : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _unify_x_var2_write : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _unify_l_x_var2 : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _unify_l_x_var2_write : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _unify_y_var : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_y_var_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_var : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_var_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_x_val : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_x_val_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_val : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_val_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_y_val : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_y_val_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_val : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_val_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_x_loc : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_x_loc_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_loc : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_l_x_loc_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _unify_y_loc : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_y_loc_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_loc : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_l_y_loc_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _unify_void : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_void_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_l_void : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_l_void_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_n_voids : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _unify_n_voids_write : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _unify_l_n_voids : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _unify_l_n_voids_write : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _unify_atom : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _unify_atom_write : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _unify_l_atom : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _unify_l_atom_write : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _unify_n_atoms : + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + case _unify_n_atoms_write : + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + case _unify_float : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _unify_float_write : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _unify_l_float : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _unify_l_float_write : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _unify_longint : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _unify_longint_write : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _unify_l_longint : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _unify_l_longint_write : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _unify_bigint : + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + case _unify_l_bigint : + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + case _unify_dbterm : + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + case _unify_l_dbterm : + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + case _unify_list : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_list_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_l_list : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_l_list_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _unify_struct : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _unify_struct_write : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _unify_l_struc : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _unify_l_struc_write : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _put_x_var : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _put_y_var : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _put_x_val : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _put_xx_val : + _p = ((yamop *)(&((_p)->u.xxxx.next))); + break; + case _put_y_val : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _put_y_vals : + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + case _put_unsafe : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _put_atom : + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + case _put_dbterm : + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + case _put_bigint : + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + case _put_float : + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + case _put_longint : + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + case _put_list : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _put_struct : + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + case _write_x_var : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _write_void : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _write_n_voids : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _write_y_var : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _write_x_val : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _write_x_loc : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _write_y_val : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _write_y_loc : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _write_atom : + _p = ((yamop *)(&((_p)->u.c.next))); + break; + case _write_bigint : + _p = ((yamop *)(&((_p)->u.N.next))); + break; + case _write_dbterm : + _p = ((yamop *)(&((_p)->u.D.next))); + break; + case _write_float : + _p = ((yamop *)(&((_p)->u.d.next))); + break; + case _write_longint : + _p = ((yamop *)(&((_p)->u.i.next))); + break; + case _write_n_atoms : + _p = ((yamop *)(&((_p)->u.sc.next))); + break; + case _write_list : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _write_l_list : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _write_struct : + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + case _write_l_struc : + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + case _save_pair_x : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _save_pair_x_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _save_pair_y : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _save_pair_y_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _save_appl_x : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _save_appl_x_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _save_appl_y : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _save_appl_y_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _jump : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _move_back : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _skip : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _either : + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + case _or_else : + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + case _pop_n : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _pop : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _call_cpred : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _execute_cpred : + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + case _call_usercpred : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _call_c_wfail : + _p = ((yamop *)(&((_p)->u.slp.next))); + break; + case _try_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + case _retry_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _cut_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#endif + case _try_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + case _retry_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _cut_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#endif + case _lock_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _index_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#ifdef THREADS + case _thread_local : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif + case _expand_index : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _expand_clauses : + _p = ((yamop *)(&((_p)->u.sssllp.next))); + break; + case _undef_p : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _spy_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _try_clause : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _try_clause2 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _try_clause3 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _try_clause4 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _retry : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _retry2 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _retry3 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _retry4 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _trust : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _try_in : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _enter_lu_pred : + _p = ((yamop *)(&((_p)->u.Illss.next))); + break; + case _try_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _user_switch : + _p = ((yamop *)(&((_p)->u.lp.next))); + break; + case _switch_on_type : + _p = ((yamop *)(&((_p)->u.llll.next))); + break; + case _switch_list_nl : + _p = ((yamop *)(&((_p)->u.ollll.next))); + break; + case _switch_on_arg_type : + _p = ((yamop *)(&((_p)->u.xllll.next))); + break; + case _switch_on_sub_arg_type : + _p = ((yamop *)(&((_p)->u.sllll.next))); + break; + case _jump_if_var : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _jump_if_nonvar : + _p = ((yamop *)(&((_p)->u.xll.next))); + break; + case _if_not_then : + _p = ((yamop *)(&((_p)->u.clll.next))); + break; + case _switch_on_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _switch_on_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _go_on_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _go_on_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _if_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _if_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _index_dbref : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _index_blob : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _index_long : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _jit_handler : + _p = ((yamop *)(&((_p)->u.jhc.next))); + break; + case _p_atom_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_atom_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_atomic_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_atomic_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_integer_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_integer_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_nonvar_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_nonvar_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_number_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_number_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_var_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_var_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_db_ref_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_db_ref_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_primitive_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_primitive_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_compound_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_compound_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_float_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _p_float_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _p_plus_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_plus_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_plus_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_plus_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_minus_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_minus_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_minus_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_minus_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_times_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_times_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_times_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_times_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_div_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_div_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_div_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_div_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_div_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_div_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_and_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_and_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_and_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_and_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_or_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_or_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_or_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_or_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_sll_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_sll_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_sll_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_sll_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_sll_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_sll_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_slr_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_slr_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_slr_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_slr_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_slr_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_slr_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _call_bfunc_xx : + _p = ((yamop *)(&((_p)->u.plxxs.next))); + break; + case _call_bfunc_yx : + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + case _call_bfunc_xy : + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + case _call_bfunc_yy : + _p = ((yamop *)(&((_p)->u.plyys.next))); + break; + case _p_equal : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _p_dif : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _p_eq : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _p_arg_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_arg_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_arg_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_arg_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_func2s_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_func2s_cv : + _p = ((yamop *)(&((_p)->u.xxc.next))); + break; + case _p_func2s_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _p_func2s_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_func2s_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_func2s_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _p_func2f_xx : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _p_func2f_xy : + _p = ((yamop *)(&((_p)->u.xxy.next))); + break; + case _p_func2f_yx : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _p_func2f_yy : + _p = ((yamop *)(&((_p)->u.yyx.next))); + break; + case _p_functor : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _p_execute2 : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _p_execute : + _p = ((yamop *)(&((_p)->u.Osbmp.next))); + break; + case _p_execute_tail : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; +#ifdef YAPOR + case _getwork_first_time : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _getwork : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _getwork_seq : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _sync : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _clause_with_cut : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif + case _table_load_answer : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_try_answer : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_try_single : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_try_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_try : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_retry : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_trust : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_new_answer : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _table_answer_resolution : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _table_completion : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#ifdef THREADS_CONSUMER_SHARING + case _table_answer_resolution_completion: + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#endif + case _trie_do_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_do_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_trust_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_try_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _trie_retry_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif +#ifdef YAPOR + case _or_last : + _p = ((yamop *)(&((_p)->u.sblp.next))); + break; +#else + case _or_last : + _p = ((yamop *)(&((_p)->u.p.next))); + break; +#endif + case _traced_Ystop : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_Nstop : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_try_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_enter_profiling : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_retry_profiled : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_profiled_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_profiled_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_profiled_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _traced_profiled_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _traced_count_call : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_count_retry : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_count_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_count_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_count_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _traced_count_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _traced_lock_lu : + _p = ((yamop *)(&((_p)->u.p.next))); + break; + case _traced_unlock_lu : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_alloc_for_logical_pred : + _p = ((yamop *)(&((_p)->u.L.next))); + break; + case _traced_copy_idb_term : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_unify_idb_term : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_ensure_space : + _p = ((yamop *)(&((_p)->u.Osbpa.next))); + break; + case _traced_spy_or_trymark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_try_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_count_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_profiled_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_retry_and_mark : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_trust_fail : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_op_fail : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_cut : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _traced_cut_t : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _traced_cut_e : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _traced_save_b_x : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_save_b_y : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _traced_commit_b_x : + _p = ((yamop *)(&((_p)->u.xps.next))); + break; + case _traced_commit_b_y : + _p = ((yamop *)(&((_p)->u.yps.next))); + break; + case _traced_execute : + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + case _traced_dexecute : + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + case _traced_fcall : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _traced_call : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _traced_procceed : + _p = ((yamop *)(&((_p)->u.p.next))); + l = (CELL)_p; + break; + case _traced_allocate : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_deallocate : + _p = ((yamop *)(&((_p)->u.p.next))); + break; +#ifdef BEAM + case _traced_retry_eam : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif +#ifdef BEAM + case _traced_run_eam : + _p = ((yamop *)(&((_p)->u.os.next))); + break; +#endif + case _traced_get_x_var : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_get_y_var : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_get_yy_var : + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + case _traced_get_x_val : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_get_y_val : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_get_atom : + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + case _traced_get_2atoms : + _p = ((yamop *)(&((_p)->u.cc.next))); + break; + case _traced_get_3atoms : + _p = ((yamop *)(&((_p)->u.ccc.next))); + break; + case _traced_get_4atoms : + _p = ((yamop *)(&((_p)->u.cccc.next))); + break; + case _traced_get_5atoms : + _p = ((yamop *)(&((_p)->u.ccccc.next))); + break; + case _traced_get_6atoms : + _p = ((yamop *)(&((_p)->u.cccccc.next))); + break; + case _traced_get_list : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_get_struct : + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + case _traced_get_float : + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + case _traced_get_longint : + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + case _traced_get_bigint : + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + case _traced_get_dbterm : + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + case _traced_glist_valx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_glist_valy : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_gl_void_varx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_gl_void_vary : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_gl_void_valx : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_gl_void_valy : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_unify_x_var : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_x_var_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_var : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_var_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_x_var2 : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _traced_unify_x_var2_write : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _traced_unify_l_x_var2 : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _traced_unify_l_x_var2_write : + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + case _traced_unify_y_var : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_y_var_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_var : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_var_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_x_val : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_x_val_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_val : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_val_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_y_val : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_y_val_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_val : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_val_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_x_loc : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_x_loc_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_loc : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_l_x_loc_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_unify_y_loc : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_y_loc_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_loc : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_l_y_loc_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_unify_void : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_void_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_l_void : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_l_void_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_n_voids : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _traced_unify_n_voids_write : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _traced_unify_l_n_voids : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _traced_unify_l_n_voids_write : + _p = ((yamop *)(&((_p)->u.os.next))); + break; + case _traced_unify_atom : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _traced_unify_atom_write : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _traced_unify_l_atom : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _traced_unify_l_atom_write : + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + case _traced_unify_n_atoms : + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + case _traced_unify_n_atoms_write : + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + case _traced_unify_float : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _traced_unify_float_write : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _traced_unify_l_float : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _traced_unify_l_float_write : + _p = ((yamop *)(&((_p)->u.od.next))); + break; + case _traced_unify_longint : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _traced_unify_longint_write : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _traced_unify_l_longint : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _traced_unify_l_longint_write : + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + case _traced_unify_bigint : + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + case _traced_unify_l_bigint : + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + case _traced_unify_dbterm : + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + case _traced_unify_l_dbterm : + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + case _traced_unify_list : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_list_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_l_list : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_l_list_write : + _p = ((yamop *)(&((_p)->u.o.next))); + break; + case _traced_unify_struct : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _traced_unify_struct_write : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _traced_unify_l_struc : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _traced_unify_l_struc_write : + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + case _traced_put_x_var : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_put_y_var : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_put_x_val : + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + case _traced_put_xx_val : + _p = ((yamop *)(&((_p)->u.xxxx.next))); + break; + case _traced_put_y_val : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_put_y_vals : + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + case _traced_put_unsafe : + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + case _traced_put_atom : + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + case _traced_put_dbterm : + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + case _traced_put_bigint : + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + case _traced_put_float : + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + case _traced_put_longint : + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + case _traced_put_list : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_put_struct : + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + case _traced_write_x_var : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_write_void : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_write_n_voids : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _traced_write_y_var : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _traced_write_x_val : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_write_x_loc : + _p = ((yamop *)(&((_p)->u.x.next))); + break; + case _traced_write_y_val : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _traced_write_y_loc : + _p = ((yamop *)(&((_p)->u.y.next))); + break; + case _traced_write_atom : + _p = ((yamop *)(&((_p)->u.c.next))); + break; + case _traced_write_bigint : + _p = ((yamop *)(&((_p)->u.N.next))); + break; + case _traced_write_dbterm : + _p = ((yamop *)(&((_p)->u.D.next))); + break; + case _traced_write_float : + _p = ((yamop *)(&((_p)->u.d.next))); + break; + case _traced_write_longint : + _p = ((yamop *)(&((_p)->u.i.next))); + break; + case _traced_write_n_atoms : + _p = ((yamop *)(&((_p)->u.sc.next))); + break; + case _traced_write_list : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_write_l_list : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_write_struct : + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + case _traced_write_l_struc : + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + case _traced_save_pair_x : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_save_pair_x_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_save_pair_y : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_save_pair_y_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_save_appl_x : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_save_appl_x_write : + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + case _traced_save_appl_y : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_save_appl_y_write : + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + case _traced_jump : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_move_back : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_skip : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_either : + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + case _traced_or_else : + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + case _traced_pop_n : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _traced_pop : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_call_cpred : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _traced_execute_cpred : + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + case _traced_call_usercpred : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _traced_call_c_wfail : + _p = ((yamop *)(&((_p)->u.slp.next))); + break; + case _traced_try_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + case _traced_retry_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _traced_cut_c : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#endif + case _traced_try_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + case _traced_retry_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _traced_cut_userc : + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; +#endif + case _traced_lock_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_index_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#ifdef THREADS + case _traced_thread_local : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif + case _traced_expand_index : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_expand_clauses : + _p = ((yamop *)(&((_p)->u.sssllp.next))); + break; + case _traced_undef_p : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_spy_pred : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_try_clause : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_try_clause2 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_try_clause3 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_try_clause4 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_retry : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_retry2 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_retry3 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_retry4 : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_trust : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_try_in : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_enter_lu_pred : + _p = ((yamop *)(&((_p)->u.Illss.next))); + break; + case _traced_try_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _traced_retry_logical : + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + case _traced_trust_logical : + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + case _traced_user_switch : + _p = ((yamop *)(&((_p)->u.lp.next))); + break; + case _traced_switch_on_type : + _p = ((yamop *)(&((_p)->u.llll.next))); + break; + case _traced_switch_list_nl : + _p = ((yamop *)(&((_p)->u.ollll.next))); + break; + case _traced_switch_on_arg_type : + _p = ((yamop *)(&((_p)->u.xllll.next))); + break; + case _traced_switch_on_sub_arg_type : + _p = ((yamop *)(&((_p)->u.sllll.next))); + break; + case _traced_jump_if_var : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_jump_if_nonvar : + _p = ((yamop *)(&((_p)->u.xll.next))); + break; + case _traced_if_not_then : + _p = ((yamop *)(&((_p)->u.clll.next))); + break; + case _traced_switch_on_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_switch_on_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_go_on_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_go_on_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_if_func : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_if_cons : + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + case _traced_index_dbref : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_index_blob : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_index_long : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_jit_handler : + _p = ((yamop *)(&((_p)->u.jhc.next))); + break; + case _traced_p_atom_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_atom_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_atomic_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_atomic_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_integer_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_integer_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_nonvar_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_nonvar_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_number_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_number_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_var_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_var_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_db_ref_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_db_ref_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_primitive_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_primitive_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_compound_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_compound_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_float_x : + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + case _traced_p_float_y : + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + case _traced_p_plus_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_plus_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_plus_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_plus_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_minus_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_minus_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_minus_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_minus_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_times_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_times_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_times_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_times_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_div_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_div_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_div_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_div_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_div_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_div_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_and_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_and_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_and_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_and_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_or_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_or_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_or_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_or_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_sll_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_sll_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_sll_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_sll_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_sll_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_sll_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_slr_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_slr_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_slr_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_slr_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_slr_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_slr_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_call_bfunc_xx : + _p = ((yamop *)(&((_p)->u.plxxs.next))); + break; + case _traced_call_bfunc_yx : + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + case _traced_call_bfunc_xy : + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + case _traced_call_bfunc_yy : + _p = ((yamop *)(&((_p)->u.plyys.next))); + break; + case _traced_p_equal : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_p_dif : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_p_eq : + _p = ((yamop *)(&((_p)->u.l.next))); + break; + case _traced_p_arg_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_arg_cv : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_arg_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_arg_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_func2s_vv : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_func2s_cv : + _p = ((yamop *)(&((_p)->u.xxc.next))); + break; + case _traced_p_func2s_vc : + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + case _traced_p_func2s_y_vv : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_func2s_y_cv : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_func2s_y_vc : + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + case _traced_p_func2f_xx : + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + case _traced_p_func2f_xy : + _p = ((yamop *)(&((_p)->u.xxy.next))); + break; + case _traced_p_func2f_yx : + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + case _traced_p_func2f_yy : + _p = ((yamop *)(&((_p)->u.yyx.next))); + break; + case _traced_p_functor : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_p_execute2 : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + case _traced_p_execute : + _p = ((yamop *)(&((_p)->u.Osbmp.next))); + break; + case _traced_p_execute_tail : + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; +#ifdef YAPOR + case _traced_getwork_first_time : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_getwork : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_getwork_seq : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_sync : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _traced_clause_with_cut : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif + case _traced_table_load_answer : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_try_answer : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_try_single : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_try_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_try : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_retry_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_retry : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_trust_me : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_trust : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_new_answer : + _p = ((yamop *)(&((_p)->u.s.next))); + break; + case _traced_table_answer_resolution : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + case _traced_table_completion : + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#ifdef THREADS_CONSUMER_SHARING + case _traced_table_answer_resolution_completion: + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; +#endif + case _traced_trie_do_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_var : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_var_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_val : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_val_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_atom : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_atom_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_null : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_null_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_appl : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_appl_in_pair : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_extension : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_double : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_longint : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_do_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_trust_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_try_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; + case _traced_trie_retry_gterm : + _p = ((yamop *)(&((_p)->u.e.next))); + break; +#endif +#ifdef YAPOR + case _traced_or_last : + _p = ((yamop *)(&((_p)->u.sblp.next))); + break; +#else + case _traced_or_last : + _p = ((yamop *)(&((_p)->u.p.next))); + break; +#endif + } + } + return lastp; +} + diff --git a/JIT/HPP/native_header.h b/JIT/HPP/native_header.h new file mode 100644 index 000000000..47ba7e157 --- /dev/null +++ b/JIT/HPP/native_header.h @@ -0,0 +1,17 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern void print_block(YAP_BBs block, enumPlace place); diff --git a/JIT/HPP/native_header_d.h b/JIT/HPP/native_header_d.h new file mode 100644 index 000000000..5948eac0c --- /dev/null +++ b/JIT/HPP/native_header_d.h @@ -0,0 +1,19 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern void print_instruction(yamop*, enumPlace); +extern void print_block(YAP_BBs, enumPlace); +extern void print_main_when_head(yamop*, enumPlace); diff --git a/JIT/HPP/nextof.hh b/JIT/HPP/nextof.hh new file mode 100644 index 000000000..690b51149 --- /dev/null +++ b/JIT/HPP/nextof.hh @@ -0,0 +1,2390 @@ +void NextOf(yamop**); + +void +NextOf(yamop** _p) { + op_numbers op = Yap_op_from_opcode((*_p)->opc); + switch(op){ + case _Ystop : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _Nstop : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _try_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _retry_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _trust_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _enter_profiling : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _retry_profiled : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _profiled_retry_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _profiled_trust_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _profiled_retry_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtaLl.next))); + break; + case _profiled_trust_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtILl.next))); + break; + case _count_call : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _count_retry : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _count_retry_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _count_trust_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _count_retry_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtaLl.next))); + break; + case _count_trust_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtILl.next))); + break; + case _lock_lu : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _unlock_lu : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _alloc_for_logical_pred : + (*_p) = ((yamop *)(&((*_p)->u.L.next))); + break; + case _copy_idb_term : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _unify_idb_term : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _ensure_space : + (*_p) = ((yamop *)(&((*_p)->u.Osbpa.next))); + break; + case _spy_or_trymark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _try_and_mark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _count_retry_and_mark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _profiled_retry_and_mark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _retry_and_mark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _trust_fail : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _op_fail : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _cut : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _cut_t : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _cut_e : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _save_b_x : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _save_b_y : + (*_p) = ((yamop *)(&((*_p)->u.y.next))); + break; + case _commit_b_x : + (*_p) = ((yamop *)(&((*_p)->u.xps.next))); + break; + case _commit_b_y : + (*_p) = ((yamop *)(&((*_p)->u.yps.next))); + break; + case _execute : + (*_p) = ((yamop *)(&((*_p)->u.pp.next))); + break; + case _dexecute : + (*_p) = ((yamop *)(&((*_p)->u.pp.next))); + break; + case _fcall : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _call : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _procceed : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _allocate : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _deallocate : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; +#ifdef BEAM + case _retry_eam : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#endif +#ifdef BEAM + case _run_eam : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; +#endif + case _get_x_var : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _get_y_var : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _get_yy_var : + (*_p) = ((yamop *)(&((*_p)->u.yyxx.next))); + break; + case _get_x_val : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _get_y_val : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _get_atom : + (*_p) = ((yamop *)(&((*_p)->u.xc.next))); + break; + case _get_2atoms : + (*_p) = ((yamop *)(&((*_p)->u.cc.next))); + break; + case _get_3atoms : + (*_p) = ((yamop *)(&((*_p)->u.ccc.next))); + break; + case _get_4atoms : + (*_p) = ((yamop *)(&((*_p)->u.cccc.next))); + break; + case _get_5atoms : + (*_p) = ((yamop *)(&((*_p)->u.ccccc.next))); + break; + case _get_6atoms : + (*_p) = ((yamop *)(&((*_p)->u.cccccc.next))); + break; + case _get_list : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _get_struct : + (*_p) = ((yamop *)(&((*_p)->u.xfa.next))); + break; + case _get_float : + (*_p) = ((yamop *)(&((*_p)->u.xd.next))); + break; + case _get_longint : + (*_p) = ((yamop *)(&((*_p)->u.xi.next))); + break; + case _get_bigint : + (*_p) = ((yamop *)(&((*_p)->u.xN.next))); + break; + case _get_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.xD.next))); + break; + case _glist_valx : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _glist_valy : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _gl_void_varx : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _gl_void_vary : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _gl_void_valx : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _gl_void_valy : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _unify_x_var : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_x_var_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_l_x_var : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_l_x_var_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_x_var2 : + (*_p) = ((yamop *)(&((*_p)->u.oxx.next))); + break; + case _unify_x_var2_write : + (*_p) = ((yamop *)(&((*_p)->u.oxx.next))); + break; + case _unify_l_x_var2 : + (*_p) = ((yamop *)(&((*_p)->u.oxx.next))); + break; + case _unify_l_x_var2_write : + (*_p) = ((yamop *)(&((*_p)->u.oxx.next))); + break; + case _unify_y_var : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_y_var_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_l_y_var : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_l_y_var_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_x_val : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_x_val_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_l_x_val : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_l_x_val_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_y_val : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_y_val_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_l_y_val : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_l_y_val_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_x_loc : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_x_loc_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_l_x_loc : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_l_x_loc_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _unify_y_loc : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_y_loc_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_l_y_loc : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_l_y_loc_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _unify_void : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _unify_void_write : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _unify_l_void : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _unify_l_void_write : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _unify_n_voids : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; + case _unify_n_voids_write : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; + case _unify_l_n_voids : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; + case _unify_l_n_voids_write : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; + case _unify_atom : + (*_p) = ((yamop *)(&((*_p)->u.oc.next))); + break; + case _unify_atom_write : + (*_p) = ((yamop *)(&((*_p)->u.oc.next))); + break; + case _unify_l_atom : + (*_p) = ((yamop *)(&((*_p)->u.oc.next))); + break; + case _unify_l_atom_write : + (*_p) = ((yamop *)(&((*_p)->u.oc.next))); + break; + case _unify_n_atoms : + (*_p) = ((yamop *)(&((*_p)->u.osc.next))); + break; + case _unify_n_atoms_write : + (*_p) = ((yamop *)(&((*_p)->u.osc.next))); + break; + case _unify_float : + (*_p) = ((yamop *)(&((*_p)->u.od.next))); + break; + case _unify_float_write : + (*_p) = ((yamop *)(&((*_p)->u.od.next))); + break; + case _unify_l_float : + (*_p) = ((yamop *)(&((*_p)->u.od.next))); + break; + case _unify_l_float_write : + (*_p) = ((yamop *)(&((*_p)->u.od.next))); + break; + case _unify_longint : + (*_p) = ((yamop *)(&((*_p)->u.oi.next))); + break; + case _unify_longint_write : + (*_p) = ((yamop *)(&((*_p)->u.oi.next))); + break; + case _unify_l_longint : + (*_p) = ((yamop *)(&((*_p)->u.oi.next))); + break; + case _unify_l_longint_write : + (*_p) = ((yamop *)(&((*_p)->u.oi.next))); + break; + case _unify_bigint : + (*_p) = ((yamop *)(&((*_p)->u.oN.next))); + break; + case _unify_l_bigint : + (*_p) = ((yamop *)(&((*_p)->u.oN.next))); + break; + case _unify_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.oD.next))); + break; + case _unify_l_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.oD.next))); + break; + case _unify_list : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _unify_list_write : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _unify_l_list : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _unify_l_list_write : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _unify_struct : + (*_p) = ((yamop *)(&((*_p)->u.ofa.next))); + break; + case _unify_struct_write : + (*_p) = ((yamop *)(&((*_p)->u.ofa.next))); + break; + case _unify_l_struc : + (*_p) = ((yamop *)(&((*_p)->u.ofa.next))); + break; + case _unify_l_struc_write : + (*_p) = ((yamop *)(&((*_p)->u.ofa.next))); + break; + case _put_x_var : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _put_y_var : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _put_x_val : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _put_xx_val : + (*_p) = ((yamop *)(&((*_p)->u.xxxx.next))); + break; + case _put_y_val : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _put_y_vals : + (*_p) = ((yamop *)(&((*_p)->u.yyxx.next))); + break; + case _put_unsafe : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _put_atom : + (*_p) = ((yamop *)(&((*_p)->u.xc.next))); + break; + case _put_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.xD.next))); + break; + case _put_bigint : + (*_p) = ((yamop *)(&((*_p)->u.xN.next))); + break; + case _put_float : + (*_p) = ((yamop *)(&((*_p)->u.xd.next))); + break; + case _put_longint : + (*_p) = ((yamop *)(&((*_p)->u.xi.next))); + break; + case _put_list : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _put_struct : + (*_p) = ((yamop *)(&((*_p)->u.xfa.next))); + break; + case _write_x_var : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _write_void : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _write_n_voids : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _write_y_var : + (*_p) = ((yamop *)(&((*_p)->u.y.next))); + break; + case _write_x_val : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _write_x_loc : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _write_y_val : + (*_p) = ((yamop *)(&((*_p)->u.y.next))); + break; + case _write_y_loc : + (*_p) = ((yamop *)(&((*_p)->u.y.next))); + break; + case _write_atom : + (*_p) = ((yamop *)(&((*_p)->u.c.next))); + break; + case _write_bigint : + (*_p) = ((yamop *)(&((*_p)->u.N.next))); + break; + case _write_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.D.next))); + break; + case _write_float : + (*_p) = ((yamop *)(&((*_p)->u.d.next))); + break; + case _write_longint : + (*_p) = ((yamop *)(&((*_p)->u.i.next))); + break; + case _write_n_atoms : + (*_p) = ((yamop *)(&((*_p)->u.sc.next))); + break; + case _write_list : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _write_l_list : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _write_struct : + (*_p) = ((yamop *)(&((*_p)->u.fa.next))); + break; + case _write_l_struc : + (*_p) = ((yamop *)(&((*_p)->u.fa.next))); + break; + case _save_pair_x : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _save_pair_x_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _save_pair_y : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _save_pair_y_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _save_appl_x : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _save_appl_x_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _save_appl_y : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _save_appl_y_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _jump : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _move_back : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _skip : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _either : + (*_p) = ((yamop *)(&((*_p)->u.Osblp.next))); + break; + case _or_else : + (*_p) = ((yamop *)(&((*_p)->u.Osblp.next))); + break; + case _pop_n : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _pop : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _call_cpred : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _execute_cpred : + (*_p) = ((yamop *)(&((*_p)->u.pp.next))); + break; + case _call_usercpred : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _call_c_wfail : + (*_p) = ((yamop *)(&((*_p)->u.slp.next))); + break; + case _try_c : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; + case _retry_c : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _cut_c : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; +#endif + case _try_userc : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; + case _retry_userc : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _cut_userc : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; +#endif + case _lock_pred : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _index_pred : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#ifdef THREADS + case _thread_local : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#endif + case _expand_index : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _expand_clauses : + (*_p) = ((yamop *)(&((*_p)->u.sssllp.next))); + break; + case _undef_p : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _spy_pred : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _try_clause : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _try_clause2 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _try_clause3 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _try_clause4 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _retry : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _retry2 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _retry3 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _retry4 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _trust : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _try_in : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _enter_lu_pred : + (*_p) = ((yamop *)(&((*_p)->u.Illss.next))); + break; + case _try_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtaLl.next))); + break; + case _retry_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtaLl.next))); + break; + case _trust_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtILl.next))); + break; + case _user_switch : + (*_p) = ((yamop *)(&((*_p)->u.lp.next))); + break; + case _switch_on_type : + (*_p) = ((yamop *)(&((*_p)->u.llll.next))); + break; + case _switch_list_nl : + (*_p) = ((yamop *)(&((*_p)->u.ollll.next))); + break; + case _switch_on_arg_type : + (*_p) = ((yamop *)(&((*_p)->u.xllll.next))); + break; + case _switch_on_sub_arg_type : + (*_p) = ((yamop *)(&((*_p)->u.sllll.next))); + break; + case _jump_if_var : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _jump_if_nonvar : + (*_p) = ((yamop *)(&((*_p)->u.xll.next))); + break; + case _if_not_then : + (*_p) = ((yamop *)(&((*_p)->u.clll.next))); + break; + case _switch_on_func : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _switch_on_cons : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _go_on_func : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _go_on_cons : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _if_func : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _if_cons : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _index_dbref : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _index_blob : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _index_long : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _jit_handler : + (*_p) = ((yamop *)(&((*_p)->u.jhc.next))); + break; + case _p_atom_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_atom_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_atomic_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_atomic_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_integer_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_integer_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_nonvar_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_nonvar_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_number_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_number_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_var_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_var_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_db_ref_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_db_ref_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_primitive_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_primitive_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_compound_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_compound_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_float_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _p_float_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _p_plus_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_plus_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_plus_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_plus_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_minus_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_minus_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_minus_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_minus_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_times_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_times_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_times_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_times_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_div_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_div_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_div_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_div_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_div_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_div_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_and_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_and_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_and_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_and_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_or_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_or_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_or_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_or_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_sll_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_sll_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_sll_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_sll_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_sll_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_sll_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_slr_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_slr_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_slr_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_slr_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_slr_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_slr_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _call_bfunc_xx : + (*_p) = ((yamop *)(&((*_p)->u.plxxs.next))); + break; + case _call_bfunc_yx : + (*_p) = ((yamop *)(&((*_p)->u.plxys.next))); + break; + case _call_bfunc_xy : + (*_p) = ((yamop *)(&((*_p)->u.plxys.next))); + break; + case _call_bfunc_yy : + (*_p) = ((yamop *)(&((*_p)->u.plyys.next))); + break; + case _p_equal : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _p_dif : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _p_eq : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _p_arg_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_arg_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_arg_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_arg_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_func2s_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_func2s_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxc.next))); + break; + case _p_func2s_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _p_func2s_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_func2s_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_func2s_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _p_func2f_xx : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _p_func2f_xy : + (*_p) = ((yamop *)(&((*_p)->u.xxy.next))); + break; + case _p_func2f_yx : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _p_func2f_yy : + (*_p) = ((yamop *)(&((*_p)->u.yyx.next))); + break; + case _p_functor : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _p_execute2 : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _p_execute : + (*_p) = ((yamop *)(&((*_p)->u.Osbmp.next))); + break; + case _p_execute_tail : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; +#ifdef YAPOR + case _getwork_first_time : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _getwork : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _getwork_seq : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _sync : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _clause_with_cut : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#endif + case _table_load_answer : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_try_answer : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_try_single : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_try_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_try : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_retry_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_retry : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_trust_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_trust : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_new_answer : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _table_answer_resolution : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _table_completion : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; +#ifdef THREADS_CONSUMER_SHARING + case _table_answer_resolution_completion: + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; +#endif + case _trie_do_var : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_var : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_var : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_var : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_var_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_var_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_var_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_var_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_val : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_val : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_val : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_val : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_val_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_val_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_val_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_val_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_atom : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_atom : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_atom : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_atom : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_atom_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_atom_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_atom_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_atom_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_null : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_null : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_null : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_null : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_null_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_null_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_null_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_null_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_appl : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_appl : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_appl : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_appl : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_appl_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_appl_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_appl_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_appl_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_extension : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_extension : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_extension : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_extension : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_double : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_double : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_double : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_double : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_longint : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_longint : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_longint : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_longint : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_do_gterm : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_trust_gterm : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_try_gterm : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _trie_retry_gterm : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#endif +#ifdef YAPOR + case _or_last : + (*_p) = ((yamop *)(&((*_p)->u.sblp.next))); + break; +#else + case _or_last : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; +#endif + case _traced_Ystop : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_Nstop : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_try_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_retry_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_trust_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_enter_profiling : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _traced_retry_profiled : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _traced_profiled_retry_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_profiled_trust_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_profiled_retry_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtaLl.next))); + break; + case _traced_profiled_trust_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtILl.next))); + break; + case _traced_count_call : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _traced_count_retry : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _traced_count_retry_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_count_trust_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_count_retry_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtaLl.next))); + break; + case _traced_count_trust_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtILl.next))); + break; + case _traced_lock_lu : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _traced_unlock_lu : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_alloc_for_logical_pred : + (*_p) = ((yamop *)(&((*_p)->u.L.next))); + break; + case _traced_copy_idb_term : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_unify_idb_term : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_ensure_space : + (*_p) = ((yamop *)(&((*_p)->u.Osbpa.next))); + break; + case _traced_spy_or_trymark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_try_and_mark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_count_retry_and_mark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_profiled_retry_and_mark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_retry_and_mark : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_trust_fail : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_op_fail : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_cut : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _traced_cut_t : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _traced_cut_e : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _traced_save_b_x : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _traced_save_b_y : + (*_p) = ((yamop *)(&((*_p)->u.y.next))); + break; + case _traced_commit_b_x : + (*_p) = ((yamop *)(&((*_p)->u.xps.next))); + break; + case _traced_commit_b_y : + (*_p) = ((yamop *)(&((*_p)->u.yps.next))); + break; + case _traced_execute : + (*_p) = ((yamop *)(&((*_p)->u.pp.next))); + break; + case _traced_dexecute : + (*_p) = ((yamop *)(&((*_p)->u.pp.next))); + break; + case _traced_fcall : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _traced_call : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _traced_procceed : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; + case _traced_allocate : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_deallocate : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; +#ifdef BEAM + case _traced_retry_eam : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#endif +#ifdef BEAM + case _traced_run_eam : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; +#endif + case _traced_get_x_var : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _traced_get_y_var : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _traced_get_yy_var : + (*_p) = ((yamop *)(&((*_p)->u.yyxx.next))); + break; + case _traced_get_x_val : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _traced_get_y_val : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _traced_get_atom : + (*_p) = ((yamop *)(&((*_p)->u.xc.next))); + break; + case _traced_get_2atoms : + (*_p) = ((yamop *)(&((*_p)->u.cc.next))); + break; + case _traced_get_3atoms : + (*_p) = ((yamop *)(&((*_p)->u.ccc.next))); + break; + case _traced_get_4atoms : + (*_p) = ((yamop *)(&((*_p)->u.cccc.next))); + break; + case _traced_get_5atoms : + (*_p) = ((yamop *)(&((*_p)->u.ccccc.next))); + break; + case _traced_get_6atoms : + (*_p) = ((yamop *)(&((*_p)->u.cccccc.next))); + break; + case _traced_get_list : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _traced_get_struct : + (*_p) = ((yamop *)(&((*_p)->u.xfa.next))); + break; + case _traced_get_float : + (*_p) = ((yamop *)(&((*_p)->u.xd.next))); + break; + case _traced_get_longint : + (*_p) = ((yamop *)(&((*_p)->u.xi.next))); + break; + case _traced_get_bigint : + (*_p) = ((yamop *)(&((*_p)->u.xN.next))); + break; + case _traced_get_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.xD.next))); + break; + case _traced_glist_valx : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _traced_glist_valy : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _traced_gl_void_varx : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _traced_gl_void_vary : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _traced_gl_void_valx : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _traced_gl_void_valy : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _traced_unify_x_var : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_x_var_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_l_x_var : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_l_x_var_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_x_var2 : + (*_p) = ((yamop *)(&((*_p)->u.oxx.next))); + break; + case _traced_unify_x_var2_write : + (*_p) = ((yamop *)(&((*_p)->u.oxx.next))); + break; + case _traced_unify_l_x_var2 : + (*_p) = ((yamop *)(&((*_p)->u.oxx.next))); + break; + case _traced_unify_l_x_var2_write : + (*_p) = ((yamop *)(&((*_p)->u.oxx.next))); + break; + case _traced_unify_y_var : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_y_var_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_l_y_var : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_l_y_var_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_x_val : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_x_val_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_l_x_val : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_l_x_val_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_y_val : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_y_val_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_l_y_val : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_l_y_val_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_x_loc : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_x_loc_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_l_x_loc : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_l_x_loc_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_unify_y_loc : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_y_loc_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_l_y_loc : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_l_y_loc_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_unify_void : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _traced_unify_void_write : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _traced_unify_l_void : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _traced_unify_l_void_write : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _traced_unify_n_voids : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; + case _traced_unify_n_voids_write : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; + case _traced_unify_l_n_voids : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; + case _traced_unify_l_n_voids_write : + (*_p) = ((yamop *)(&((*_p)->u.os.next))); + break; + case _traced_unify_atom : + (*_p) = ((yamop *)(&((*_p)->u.oc.next))); + break; + case _traced_unify_atom_write : + (*_p) = ((yamop *)(&((*_p)->u.oc.next))); + break; + case _traced_unify_l_atom : + (*_p) = ((yamop *)(&((*_p)->u.oc.next))); + break; + case _traced_unify_l_atom_write : + (*_p) = ((yamop *)(&((*_p)->u.oc.next))); + break; + case _traced_unify_n_atoms : + (*_p) = ((yamop *)(&((*_p)->u.osc.next))); + break; + case _traced_unify_n_atoms_write : + (*_p) = ((yamop *)(&((*_p)->u.osc.next))); + break; + case _traced_unify_float : + (*_p) = ((yamop *)(&((*_p)->u.od.next))); + break; + case _traced_unify_float_write : + (*_p) = ((yamop *)(&((*_p)->u.od.next))); + break; + case _traced_unify_l_float : + (*_p) = ((yamop *)(&((*_p)->u.od.next))); + break; + case _traced_unify_l_float_write : + (*_p) = ((yamop *)(&((*_p)->u.od.next))); + break; + case _traced_unify_longint : + (*_p) = ((yamop *)(&((*_p)->u.oi.next))); + break; + case _traced_unify_longint_write : + (*_p) = ((yamop *)(&((*_p)->u.oi.next))); + break; + case _traced_unify_l_longint : + (*_p) = ((yamop *)(&((*_p)->u.oi.next))); + break; + case _traced_unify_l_longint_write : + (*_p) = ((yamop *)(&((*_p)->u.oi.next))); + break; + case _traced_unify_bigint : + (*_p) = ((yamop *)(&((*_p)->u.oN.next))); + break; + case _traced_unify_l_bigint : + (*_p) = ((yamop *)(&((*_p)->u.oN.next))); + break; + case _traced_unify_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.oD.next))); + break; + case _traced_unify_l_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.oD.next))); + break; + case _traced_unify_list : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _traced_unify_list_write : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _traced_unify_l_list : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _traced_unify_l_list_write : + (*_p) = ((yamop *)(&((*_p)->u.o.next))); + break; + case _traced_unify_struct : + (*_p) = ((yamop *)(&((*_p)->u.ofa.next))); + break; + case _traced_unify_struct_write : + (*_p) = ((yamop *)(&((*_p)->u.ofa.next))); + break; + case _traced_unify_l_struc : + (*_p) = ((yamop *)(&((*_p)->u.ofa.next))); + break; + case _traced_unify_l_struc_write : + (*_p) = ((yamop *)(&((*_p)->u.ofa.next))); + break; + case _traced_put_x_var : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _traced_put_y_var : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _traced_put_x_val : + (*_p) = ((yamop *)(&((*_p)->u.xx.next))); + break; + case _traced_put_xx_val : + (*_p) = ((yamop *)(&((*_p)->u.xxxx.next))); + break; + case _traced_put_y_val : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _traced_put_y_vals : + (*_p) = ((yamop *)(&((*_p)->u.yyxx.next))); + break; + case _traced_put_unsafe : + (*_p) = ((yamop *)(&((*_p)->u.yx.next))); + break; + case _traced_put_atom : + (*_p) = ((yamop *)(&((*_p)->u.xc.next))); + break; + case _traced_put_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.xD.next))); + break; + case _traced_put_bigint : + (*_p) = ((yamop *)(&((*_p)->u.xN.next))); + break; + case _traced_put_float : + (*_p) = ((yamop *)(&((*_p)->u.xd.next))); + break; + case _traced_put_longint : + (*_p) = ((yamop *)(&((*_p)->u.xi.next))); + break; + case _traced_put_list : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _traced_put_struct : + (*_p) = ((yamop *)(&((*_p)->u.xfa.next))); + break; + case _traced_write_x_var : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _traced_write_void : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_write_n_voids : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _traced_write_y_var : + (*_p) = ((yamop *)(&((*_p)->u.y.next))); + break; + case _traced_write_x_val : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _traced_write_x_loc : + (*_p) = ((yamop *)(&((*_p)->u.x.next))); + break; + case _traced_write_y_val : + (*_p) = ((yamop *)(&((*_p)->u.y.next))); + break; + case _traced_write_y_loc : + (*_p) = ((yamop *)(&((*_p)->u.y.next))); + break; + case _traced_write_atom : + (*_p) = ((yamop *)(&((*_p)->u.c.next))); + break; + case _traced_write_bigint : + (*_p) = ((yamop *)(&((*_p)->u.N.next))); + break; + case _traced_write_dbterm : + (*_p) = ((yamop *)(&((*_p)->u.D.next))); + break; + case _traced_write_float : + (*_p) = ((yamop *)(&((*_p)->u.d.next))); + break; + case _traced_write_longint : + (*_p) = ((yamop *)(&((*_p)->u.i.next))); + break; + case _traced_write_n_atoms : + (*_p) = ((yamop *)(&((*_p)->u.sc.next))); + break; + case _traced_write_list : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_write_l_list : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_write_struct : + (*_p) = ((yamop *)(&((*_p)->u.fa.next))); + break; + case _traced_write_l_struc : + (*_p) = ((yamop *)(&((*_p)->u.fa.next))); + break; + case _traced_save_pair_x : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_save_pair_x_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_save_pair_y : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_save_pair_y_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_save_appl_x : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_save_appl_x_write : + (*_p) = ((yamop *)(&((*_p)->u.ox.next))); + break; + case _traced_save_appl_y : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_save_appl_y_write : + (*_p) = ((yamop *)(&((*_p)->u.oy.next))); + break; + case _traced_jump : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_move_back : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_skip : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_either : + (*_p) = ((yamop *)(&((*_p)->u.Osblp.next))); + break; + case _traced_or_else : + (*_p) = ((yamop *)(&((*_p)->u.Osblp.next))); + break; + case _traced_pop_n : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _traced_pop : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_call_cpred : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _traced_execute_cpred : + (*_p) = ((yamop *)(&((*_p)->u.pp.next))); + break; + case _traced_call_usercpred : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _traced_call_c_wfail : + (*_p) = ((yamop *)(&((*_p)->u.slp.next))); + break; + case _traced_try_c : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; + case _traced_retry_c : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _traced_cut_c : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; +#endif + case _traced_try_userc : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; + case _traced_retry_userc : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; +#ifdef CUT_C + case _traced_cut_userc : + (*_p) = ((yamop *)(&((*_p)->u.OtapFs.next))); + break; +#endif + case _traced_lock_pred : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_index_pred : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#ifdef THREADS + case _traced_thread_local : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#endif + case _traced_expand_index : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_expand_clauses : + (*_p) = ((yamop *)(&((*_p)->u.sssllp.next))); + break; + case _traced_undef_p : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_spy_pred : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_try_clause : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_try_clause2 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_try_clause3 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_try_clause4 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_retry : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_retry2 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_retry3 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_retry4 : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_trust : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_try_in : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_enter_lu_pred : + (*_p) = ((yamop *)(&((*_p)->u.Illss.next))); + break; + case _traced_try_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtaLl.next))); + break; + case _traced_retry_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtaLl.next))); + break; + case _traced_trust_logical : + (*_p) = ((yamop *)(&((*_p)->u.OtILl.next))); + break; + case _traced_user_switch : + (*_p) = ((yamop *)(&((*_p)->u.lp.next))); + break; + case _traced_switch_on_type : + (*_p) = ((yamop *)(&((*_p)->u.llll.next))); + break; + case _traced_switch_list_nl : + (*_p) = ((yamop *)(&((*_p)->u.ollll.next))); + break; + case _traced_switch_on_arg_type : + (*_p) = ((yamop *)(&((*_p)->u.xllll.next))); + break; + case _traced_switch_on_sub_arg_type : + (*_p) = ((yamop *)(&((*_p)->u.sllll.next))); + break; + case _traced_jump_if_var : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_jump_if_nonvar : + (*_p) = ((yamop *)(&((*_p)->u.xll.next))); + break; + case _traced_if_not_then : + (*_p) = ((yamop *)(&((*_p)->u.clll.next))); + break; + case _traced_switch_on_func : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _traced_switch_on_cons : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _traced_go_on_func : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _traced_go_on_cons : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _traced_if_func : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _traced_if_cons : + (*_p) = ((yamop *)(&((*_p)->u.sssl.next))); + break; + case _traced_index_dbref : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_index_blob : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_index_long : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_jit_handler : + (*_p) = ((yamop *)(&((*_p)->u.jhc.next))); + break; + case _traced_p_atom_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_atom_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_atomic_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_atomic_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_integer_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_integer_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_nonvar_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_nonvar_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_number_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_number_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_var_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_var_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_db_ref_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_db_ref_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_primitive_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_primitive_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_compound_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_compound_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_float_x : + (*_p) = ((yamop *)(&((*_p)->u.xl.next))); + break; + case _traced_p_float_y : + (*_p) = ((yamop *)(&((*_p)->u.yl.next))); + break; + case _traced_p_plus_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_plus_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_plus_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_plus_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_minus_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_minus_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_minus_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_minus_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_times_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_times_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_times_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_times_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_div_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_div_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_div_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_div_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_div_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_div_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_and_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_and_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_and_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_and_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_or_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_or_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_or_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_or_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_sll_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_sll_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_sll_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_sll_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_sll_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_sll_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_slr_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_slr_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_slr_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_slr_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_slr_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_slr_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_call_bfunc_xx : + (*_p) = ((yamop *)(&((*_p)->u.plxxs.next))); + break; + case _traced_call_bfunc_yx : + (*_p) = ((yamop *)(&((*_p)->u.plxys.next))); + break; + case _traced_call_bfunc_xy : + (*_p) = ((yamop *)(&((*_p)->u.plxys.next))); + break; + case _traced_call_bfunc_yy : + (*_p) = ((yamop *)(&((*_p)->u.plyys.next))); + break; + case _traced_p_equal : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_p_dif : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_p_eq : + (*_p) = ((yamop *)(&((*_p)->u.l.next))); + break; + case _traced_p_arg_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_arg_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_arg_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_arg_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_func2s_vv : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_func2s_cv : + (*_p) = ((yamop *)(&((*_p)->u.xxc.next))); + break; + case _traced_p_func2s_vc : + (*_p) = ((yamop *)(&((*_p)->u.xxn.next))); + break; + case _traced_p_func2s_y_vv : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_func2s_y_cv : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_func2s_y_vc : + (*_p) = ((yamop *)(&((*_p)->u.yxn.next))); + break; + case _traced_p_func2f_xx : + (*_p) = ((yamop *)(&((*_p)->u.xxx.next))); + break; + case _traced_p_func2f_xy : + (*_p) = ((yamop *)(&((*_p)->u.xxy.next))); + break; + case _traced_p_func2f_yx : + (*_p) = ((yamop *)(&((*_p)->u.yxx.next))); + break; + case _traced_p_func2f_yy : + (*_p) = ((yamop *)(&((*_p)->u.yyx.next))); + break; + case _traced_p_functor : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_p_execute2 : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; + case _traced_p_execute : + (*_p) = ((yamop *)(&((*_p)->u.Osbmp.next))); + break; + case _traced_p_execute_tail : + (*_p) = ((yamop *)(&((*_p)->u.Osbpp.next))); + break; +#ifdef YAPOR + case _traced_getwork_first_time : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_getwork : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_getwork_seq : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_sync : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _traced_clause_with_cut : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#endif + case _traced_table_load_answer : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_try_answer : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_try_single : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_try_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_try : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_retry_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_retry : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_trust_me : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_trust : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_new_answer : + (*_p) = ((yamop *)(&((*_p)->u.s.next))); + break; + case _traced_table_answer_resolution : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; + case _traced_table_completion : + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; +#ifdef THREADS_CONSUMER_SHARING + case _traced_table_answer_resolution_completion: + (*_p) = ((yamop *)(&((*_p)->u.Otapl.next))); + break; +#endif + case _traced_trie_do_var : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_var : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_var : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_var : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_var_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_var_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_var_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_var_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_val : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_val : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_val : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_val : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_val_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_val_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_val_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_val_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_atom : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_atom : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_atom : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_atom : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_atom_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_atom_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_atom_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_atom_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_null : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_null : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_null : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_null : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_null_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_null_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_null_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_null_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_appl : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_appl : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_appl : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_appl : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_appl_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_appl_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_appl_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_appl_in_pair : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_extension : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_extension : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_extension : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_extension : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_double : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_double : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_double : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_double : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_longint : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_longint : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_longint : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_longint : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_do_gterm : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_trust_gterm : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_try_gterm : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; + case _traced_trie_retry_gterm : + (*_p) = ((yamop *)(&((*_p)->u.e.next))); + break; +#endif +#ifdef YAPOR + case _traced_or_last : + (*_p) = ((yamop *)(&((*_p)->u.sblp.next))); + break; +#else + case _traced_or_last : + (*_p) = ((yamop *)(&((*_p)->u.p.next))); + break; +#endif + } +} diff --git a/JIT/HPP/p_dif.i b/JIT/HPP/p_dif.i new file mode 100644 index 000000000..0e871a0e5 --- /dev/null +++ b/JIT/HPP/p_dif.i @@ -0,0 +1,661 @@ +#define P_DIF_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define P_DIF_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); +#endif + +#define P_DIF_POST_LOW_LEVEL_TRACER \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define P_DIF_DIF_NVAR1 \ + d1 = ARG2; + +#ifdef COROUTINING +#if defined(YAPOR_SBA) && defined(YAPOR) +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + }\ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HR = HRBREG; \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + RESET_VARIABLE(d1); \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#else /* FROZEN_STACKS */ +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + }\ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HR = HRBREG; \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + RESET_VARIABLE(d1); \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /*MULTI_ASSIGNMENT_VARIABLES */ +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + }\ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HR = HRBREG; \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + RESET_VARIABLE(d1); \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#endif /*MULTI_ASSIGNMENT_VARIABLES */ +#else /* defined(YAPOR_SBA) && defined(YAPOR) */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HR = HRBREG; \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + RESET_VARIABLE(d1); \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#else /* FROZEN_STACKS */ +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + }\ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HR = HRBREG; \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + RESET_VARIABLE(d1); \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /*MULTI_ASSIGNMENT_VARIABLES */ +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + }\ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HR = HRBREG; \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + RESET_VARIABLE(d1); \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#endif /*MULTI_ASSIGNMENT_VARIABLES */ +#endif /* defined(YAPOR_SBA) && defined(YAPOR) */ +#else /* COROUTINING */ +#if defined(YAPOR_SBA) && defined(YAPOR) +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + RESET_VARIABLE(d1); \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#else /* FROZEN_STACKS */ +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + RESET_VARIABLE(d1); \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /*MULTI_ASSIGNMENT_VARIABLES */ +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + RESET_VARIABLE(d1); \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#endif /*MULTI_ASSIGNMENT_VARIABLES */ +#else /* defined(YAPOR_SBA) && defined(YAPOR) */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + RESET_VARIABLE(d1); \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#else /* FROZEN_STACKS */ +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + RESET_VARIABLE(d1); \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /*MULTI_ASSIGNMENT_VARIABLES */ +#define P_DIF_DIF_NVAR1_NVAR2 \ + BLOCK = (CELL)P_DIF_DIF_NVAR1_NVAR2; \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HRBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HRBREG = B->cp_h; \ + while (TR != pt0) { \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + RESET_VARIABLE(d1); \ + } \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + ENDCHO(pt1); \ + } \ + } +#endif /*MULTI_ASSIGNMENT_VARIABLES */ +#endif /* defined(YAPOR_SBA) && defined(YAPOR) */ +#endif /* COROUTINING */ + +#define P_DIF_DIF_UNK1 \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); + +#define P_DIF_DIF_NVAR1_UNK2 \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); diff --git a/JIT/HPP/p_eq.i b/JIT/HPP/p_eq.i new file mode 100644 index 000000000..e43b33852 --- /dev/null +++ b/JIT/HPP/p_eq.i @@ -0,0 +1,261 @@ +#define P_EQ_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define P_EQ_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorSame,0)),XREGS+1); +#endif + +#define P_EQ_POST_LOW_LEVEL_TRACER \ + register CELL d0, d1, d2; \ + register CELL *pt0, *pt1; \ + d0 = ARG1; + +#define P_EQ_P_EQ_NVAR1 \ + d1 = ARG2; + +#ifdef USE_GMP +#define P_EQ_P_EQ_NVAR1_NVAR2 \ + BLOCK = (CELL)P_EQ_P_EQ_NVAR1_NVAR2; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + if (IsPairTerm(d0)) { \ + if (!IsPairTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + always_save_pc(); \ + d2 = iequ_complex(RepPair(d0)-1, RepPair(d0)+1,RepPair(d1)-1); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + } \ + } \ + else if (IsApplTerm(d0)) { \ + Functor f0 = FunctorOfTerm(d0); \ + Functor f1; \ + if (!IsApplTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + f1 = FunctorOfTerm(d1); \ + if (IsExtensionFunctor(f0)) { \ + switch ((CELL)f0) { \ + case (CELL)FunctorDBRef: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + break; \ + case (CELL)FunctorLongInt: \ + if (f1 != FunctorLongInt) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else if (LongIntOfTerm(d0) == LongIntOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + break; \ + case (CELL)FunctorBigInt: \ + if (f1 != FunctorBigInt) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else if (Yap_gmp_tcmp_big_big(d0,d1) == 0) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + break; \ + case (CELL)FunctorDouble: \ + if (f1 != FunctorDouble) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else if (FloatOfTerm(d0) == FloatOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + break; \ + default: \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + } \ + else { \ + if (f0 != f1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + always_save_pc(); \ + d2 = iequ_complex(RepAppl(d0), RepAppl(d0)+ArityOfFunctor(f0), RepAppl(d1)); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + } \ + } \ + } \ + } \ + else { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + } +#else /* USE_GMP */ +#define P_EQ_P_EQ_NVAR1_NVAR2 \ + BLOCK = (CELL)P_EQ_P_EQ_NVAR1_NVAR2; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + if (IsPairTerm(d0)) { \ + if (!IsPairTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + always_save_pc(); \ + d2 = iequ_complex(RepPair(d0)-1, RepPair(d0)+1,RepPair(d1)-1); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + } \ + } \ + else if (IsApplTerm(d0)) { \ + Functor f0 = FunctorOfTerm(d0); \ + Functor f1; \ + if (!IsApplTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + f1 = FunctorOfTerm(d1); \ + if (IsExtensionFunctor(f0)) { \ + switch ((CELL)f0) { \ + case (CELL)FunctorDBRef: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + break; \ + case (CELL)FunctorLongInt: \ + if (f1 != FunctorLongInt) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else if (LongIntOfTerm(d0) == LongIntOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + else { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + break; \ + case (CELL)FunctorDouble: \ + if (f1 != FunctorDouble) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else if (FloatOfTerm(d0) == FloatOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + break; \ + default: \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + } \ + else { \ + if (f0 != f1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + always_save_pc(); \ + d2 = iequ_complex(RepAppl(d0), RepAppl(d0)+ArityOfFunctor(f0), RepAppl(d1)); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } \ + } \ + } \ + } \ + } \ + else { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + } +#endif /* USE_GMP */ + +#define P_EQ_P_EQ_NVAR1_UNK2 \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); + +#define P_EQ_P_EQ_UNK1 \ + d1 = ARG2; + +#define P_EQ_P_EQ_VAR1_NVAR2 \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); + +#define P_EQ_P_EQ_VAR1_UNK2_END \ + BLOCK = (CELL)P_EQ_P_EQ_VAR1_UNK2_END; \ + if (pt1 != pt0) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONext(); \ + } diff --git a/JIT/HPP/p_functor.i b/JIT/HPP/p_functor.i new file mode 100644 index 000000000..e9be65ec2 --- /dev/null +++ b/JIT/HPP/p_functor.i @@ -0,0 +1,1134 @@ +#ifdef LOW_LEVEL_TRACER +#define P_FUNCTOR_INSTINIT \ + if (Yap_do_low_level_trace) \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),XREGS+1); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + while (1) { \ + d0 = ARG1; \ + if (IsVarTerm(d0)) { \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + if (IsApplTerm(d0)) { \ + d1 = *RepAppl(d0); \ + if (IsExtensionFunctor((Functor) d1)) { \ + if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt ) { \ + d1 = MkIntTerm(0); \ + } else { \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + d0 = MkAtomTerm(NameOfFunctor((Functor) d1)); \ + d1 = MkIntTerm(ArityOfFunctor((Functor) d1)); \ + } \ + } \ + else if (IsPairTerm(d0)) { \ + d0 = TermDot; \ + d1 = MkIntTerm(2); \ + } \ + else { \ + d1 = MkIntTerm(0); \ + } \ + register CELL arity = d1; \ + d1 = ARG2; \ + if (IsVarTerm(d1) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + d0 = arity; \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + Bind(pt0, d0); \ + d0 = arity; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + d0 = arity; \ + } \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + d0 = ARG2; \ + if (IsVarTerm(d0)) { \ + (pt1) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt1) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt1) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt1) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (IsIntTerm(d1)) { \ + d1 = IntOfTerm(d1); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + HR += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomTerm(d0)) { \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + } \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); \ + break; \ + } else { \ + setregs(); \ + } \ + continue; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + HR = pt1; \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + (pt1) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + if (IsIntTerm(d1)) { \ + d1 = IntOfTerm(d1); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + HR += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomTerm(d0)) { \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + } \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); \ + break; \ + } else { \ + setregs(); \ + } \ + continue; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + HR = pt1; \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + } \ + (pt1) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt1) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt1) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (IsIntTerm(d1)) { \ + d1 = IntOfTerm(d1); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + HR += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomTerm(d0)) { \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + } \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); \ + break; \ + } else { \ + setregs(); \ + } \ + continue; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + HR = pt1; \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + (pt1) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + if (IsIntTerm(d1)) { \ + d1 = IntOfTerm(d1); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + HR += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomTerm(d0)) { \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + } \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); \ + break; \ + } else { \ + setregs(); \ + } \ + continue; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + HR = pt1; \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + } \ + } \ + else { \ + if (IsApplTerm(d0)) { \ + d1 = *RepAppl(d0); \ + if (IsExtensionFunctor((Functor) d1)) { \ + if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt ) { \ + d1 = MkIntTerm(0); \ + } else { \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + d0 = MkAtomTerm(NameOfFunctor((Functor) d1)); \ + d1 = MkIntTerm(ArityOfFunctor((Functor) d1)); \ + } \ + } \ + else if (IsPairTerm(d0)) { \ + d0 = TermDot; \ + d1 = MkIntTerm(2); \ + } \ + else { \ + d1 = MkIntTerm(0); \ + } \ + register CELL arity = d1; \ + d1 = ARG2; \ + if (IsVarTerm(d1) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + d0 = arity; \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + Bind(pt0, d0); \ + d0 = arity; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + d0 = arity; \ + } \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + } \ + } +#else /* LOW_LEVEL_TRACER */ +#define P_FUNCTOR_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + while (1) { \ + d0 = ARG1; \ + if (IsVarTerm(d0)) { \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt0) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + if (IsApplTerm(d0)) { \ + d1 = *RepAppl(d0); \ + if (IsExtensionFunctor((Functor) d1)) { \ + if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt ) { \ + d1 = MkIntTerm(0); \ + } else { \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + d0 = MkAtomTerm(NameOfFunctor((Functor) d1)); \ + d1 = MkIntTerm(ArityOfFunctor((Functor) d1)); \ + } \ + } \ + else if (IsPairTerm(d0)) { \ + d0 = TermDot; \ + d1 = MkIntTerm(2); \ + } \ + else { \ + d1 = MkIntTerm(0); \ + } \ + register CELL arity = d1; \ + d1 = ARG2; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + d0 = arity; \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + Bind(pt0, d0); \ + d0 = arity; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + d0 = arity; \ + } \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + } \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + d0 = ARG2; \ + if (IsVarTerm(d0)) { \ + (pt1) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + while (Unsigned(pt1) != (d0)) { \ + if(!IsVarTerm(d0)) { \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt1) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt1) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (IsIntTerm(d1)) { \ + d1 = IntOfTerm(d1); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + HR += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomTerm(d0)) { \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + } \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); \ + break; \ + } else { \ + setregs(); \ + } \ + continue; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + HR = pt1; \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + (pt1) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + if (IsIntTerm(d1)) { \ + d1 = IntOfTerm(d1); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + HR += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomTerm(d0)) { \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + } \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); \ + break; \ + } else { \ + setregs(); \ + } \ + continue; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + HR = pt1; \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + } \ + (pt1) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + } \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt1) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt1) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (IsIntTerm(d1)) { \ + d1 = IntOfTerm(d1); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + HR += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomTerm(d0)) { \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + } \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); \ + break; \ + } else { \ + setregs(); \ + } \ + continue; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + HR = pt1; \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + (pt1) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + if (IsIntTerm(d1)) { \ + d1 = IntOfTerm(d1); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + HR += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + if (!IsAtomTerm(d0)) { \ + YAAM_FAIL; \ + break; \ + } \ + else { \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + } \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); \ + break; \ + } else { \ + setregs(); \ + } \ + continue; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + HR = pt1; \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + } \ + } \ + else { \ + if (IsApplTerm(d0)) { \ + d1 = *RepAppl(d0); \ + if (IsExtensionFunctor((Functor) d1)) { \ + if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt ) { \ + d1 = MkIntTerm(0); \ + } else { \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + d0 = MkAtomTerm(NameOfFunctor((Functor) d1)); \ + d1 = MkIntTerm(ArityOfFunctor((Functor) d1)); \ + } \ + } \ + else if (IsPairTerm(d0)) { \ + d0 = TermDot; \ + d1 = MkIntTerm(2); \ + } \ + else { \ + d1 = MkIntTerm(0); \ + } \ + register CELL arity = d1; \ + d1 = ARG2; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + d0 = arity; \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + Bind(pt0, d0); \ + d0 = arity; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + d0 = arity; \ + } \ + d1 = ARG3; \ + if (IsVarTerm(d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + while (Unsigned(pt0) != (d1)) { \ + if(!IsVarTerm(d1)) { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONext(); \ + break; \ + } \ + else { \ + if (d0 != d1) { \ + YAAM_FAIL; \ + break; \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONext(); \ + break; \ + } \ + } \ + } +#endif /* LOW_LEVEL_TRACER */ + +#define P_FUNCTOR_END \ + BLOCK = (CELL)P_FUNCTOR_END; diff --git a/JIT/HPP/print_op.hh b/JIT/HPP/print_op.hh new file mode 100644 index 000000000..edffdd55e --- /dev/null +++ b/JIT/HPP/print_op.hh @@ -0,0 +1,3181 @@ +void print_op(char*, op_numbers, char*); + +void +print_op(char* prepend_term, op_numbers op, char* append_term) { + switch(op){ + case _Ystop : + fprintf(stderr, "%s_Ystop%s", prepend_term, append_term); + break; + + case _Nstop : + fprintf(stderr, "%s_Nstop%s", prepend_term, append_term); + break; + + case _try_me : + fprintf(stderr, "%s_try_me%s", prepend_term, append_term); + break; + + case _retry_me : + fprintf(stderr, "%s_retry_me%s", prepend_term, append_term); + break; + + case _trust_me : + fprintf(stderr, "%s_trust_me%s", prepend_term, append_term); + break; + + case _enter_profiling : + fprintf(stderr, "%s_enter_profiling%s", prepend_term, append_term); + break; + + case _retry_profiled : + fprintf(stderr, "%s_retry_profiled%s", prepend_term, append_term); + break; + + case _profiled_retry_me : + fprintf(stderr, "%s_profiled_retry_me%s", prepend_term, append_term); + break; + + case _profiled_trust_me : + fprintf(stderr, "%s_profiled_trust_me%s", prepend_term, append_term); + break; + + case _profiled_retry_logical : + fprintf(stderr, "%s_profiled_retry_logical%s", prepend_term, append_term); + break; + + case _profiled_trust_logical : + fprintf(stderr, "%s_profiled_trust_logical%s", prepend_term, append_term); + break; + + case _count_call : + fprintf(stderr, "%s_count_call%s", prepend_term, append_term); + break; + + case _count_retry : + fprintf(stderr, "%s_count_retry%s", prepend_term, append_term); + break; + + case _count_retry_me : + fprintf(stderr, "%s_count_retry_me%s", prepend_term, append_term); + break; + + case _count_trust_me : + fprintf(stderr, "%s_count_trust_me%s", prepend_term, append_term); + break; + + case _count_retry_logical : + fprintf(stderr, "%s_count_retry_logical%s", prepend_term, append_term); + break; + + case _count_trust_logical : + fprintf(stderr, "%s_count_trust_logical%s", prepend_term, append_term); + break; + + case _lock_lu : + fprintf(stderr, "%s_lock_lu%s", prepend_term, append_term); + break; + + case _unlock_lu : + fprintf(stderr, "%s_unlock_lu%s", prepend_term, append_term); + break; + + case _alloc_for_logical_pred : + fprintf(stderr, "%s_alloc_for_logical_pred%s", prepend_term, append_term); + break; + + case _copy_idb_term : + fprintf(stderr, "%s_copy_idb_term%s", prepend_term, append_term); + break; + + case _unify_idb_term : + fprintf(stderr, "%s_unify_idb_term%s", prepend_term, append_term); + break; + + case _ensure_space : + fprintf(stderr, "%s_ensure_space%s", prepend_term, append_term); + break; + + case _spy_or_trymark : + fprintf(stderr, "%s_spy_or_trymark%s", prepend_term, append_term); + break; + + case _try_and_mark : + fprintf(stderr, "%s_try_and_mark%s", prepend_term, append_term); + break; + + case _count_retry_and_mark : + fprintf(stderr, "%s_count_retry_and_mark%s", prepend_term, append_term); + break; + + case _profiled_retry_and_mark : + fprintf(stderr, "%s_profiled_retry_and_mark%s", prepend_term, append_term); + break; + + case _retry_and_mark : + fprintf(stderr, "%s_retry_and_mark%s", prepend_term, append_term); + break; + + case _trust_fail : + fprintf(stderr, "%s_trust_fail%s", prepend_term, append_term); + break; + + case _op_fail : + fprintf(stderr, "%s_op_fail%s", prepend_term, append_term); + break; + + case _cut : + fprintf(stderr, "%s_cut%s", prepend_term, append_term); + break; + + case _cut_t : + fprintf(stderr, "%s_cut_t%s", prepend_term, append_term); + break; + + case _cut_e : + fprintf(stderr, "%s_cut_e%s", prepend_term, append_term); + break; + + case _save_b_x : + fprintf(stderr, "%s_save_b_x%s", prepend_term, append_term); + break; + + case _save_b_y : + fprintf(stderr, "%s_save_b_y%s", prepend_term, append_term); + break; + + case _commit_b_x : + fprintf(stderr, "%s_commit_b_x%s", prepend_term, append_term); + break; + + case _commit_b_y : + fprintf(stderr, "%s_commit_b_y%s", prepend_term, append_term); + break; + + case _execute : + fprintf(stderr, "%s_execute%s", prepend_term, append_term); + break; + + case _dexecute : + fprintf(stderr, "%s_dexecute%s", prepend_term, append_term); + break; + + case _fcall : + fprintf(stderr, "%s_fcall%s", prepend_term, append_term); + break; + + case _call : + fprintf(stderr, "%s_call%s", prepend_term, append_term); + break; + + case _procceed : + fprintf(stderr, "%s_procceed%s", prepend_term, append_term); + break; + + case _allocate : + fprintf(stderr, "%s_allocate%s", prepend_term, append_term); + break; + + case _deallocate : + fprintf(stderr, "%s_deallocate%s", prepend_term, append_term); + break; + +#ifdef BEAM + case _retry_eam : + fprintf(stderr, "%s_retry_eam%s", prepend_term, append_term); + break; + +#endif +#ifdef BEAM + case _run_eam : + fprintf(stderr, "%s_run_eam%s", prepend_term, append_term); + break; + +#endif + case _get_x_var : + fprintf(stderr, "%s_get_x_var%s", prepend_term, append_term); + break; + + case _get_y_var : + fprintf(stderr, "%s_get_y_var%s", prepend_term, append_term); + break; + + case _get_yy_var : + fprintf(stderr, "%s_get_yy_var%s", prepend_term, append_term); + break; + + case _get_x_val : + fprintf(stderr, "%s_get_x_val%s", prepend_term, append_term); + break; + + case _get_y_val : + fprintf(stderr, "%s_get_y_val%s", prepend_term, append_term); + break; + + case _get_atom : + fprintf(stderr, "%s_get_atom%s", prepend_term, append_term); + break; + + case _get_2atoms : + fprintf(stderr, "%s_get_2atoms%s", prepend_term, append_term); + break; + + case _get_3atoms : + fprintf(stderr, "%s_get_3atoms%s", prepend_term, append_term); + break; + + case _get_4atoms : + fprintf(stderr, "%s_get_4atoms%s", prepend_term, append_term); + break; + + case _get_5atoms : + fprintf(stderr, "%s_get_5atoms%s", prepend_term, append_term); + break; + + case _get_6atoms : + fprintf(stderr, "%s_get_6atoms%s", prepend_term, append_term); + break; + + case _get_list : + fprintf(stderr, "%s_get_list%s", prepend_term, append_term); + break; + + case _get_struct : + fprintf(stderr, "%s_get_struct%s", prepend_term, append_term); + break; + + case _get_float : + fprintf(stderr, "%s_get_float%s", prepend_term, append_term); + break; + + case _get_longint : + fprintf(stderr, "%s_get_longint%s", prepend_term, append_term); + break; + + case _get_bigint : + fprintf(stderr, "%s_get_bigint%s", prepend_term, append_term); + break; + + case _get_dbterm : + fprintf(stderr, "%s_get_dbterm%s", prepend_term, append_term); + break; + + case _glist_valx : + fprintf(stderr, "%s_glist_valx%s", prepend_term, append_term); + break; + + case _glist_valy : + fprintf(stderr, "%s_glist_valy%s", prepend_term, append_term); + break; + + case _gl_void_varx : + fprintf(stderr, "%s_gl_void_varx%s", prepend_term, append_term); + break; + + case _gl_void_vary : + fprintf(stderr, "%s_gl_void_vary%s", prepend_term, append_term); + break; + + case _gl_void_valx : + fprintf(stderr, "%s_gl_void_valx%s", prepend_term, append_term); + break; + + case _gl_void_valy : + fprintf(stderr, "%s_gl_void_valy%s", prepend_term, append_term); + break; + + case _unify_x_var : + fprintf(stderr, "%s_unify_x_var%s", prepend_term, append_term); + break; + + case _unify_x_var_write : + fprintf(stderr, "%s_unify_x_var_write%s", prepend_term, append_term); + break; + + case _unify_l_x_var : + fprintf(stderr, "%s_unify_l_x_var%s", prepend_term, append_term); + break; + + case _unify_l_x_var_write : + fprintf(stderr, "%s_unify_l_x_var_write%s", prepend_term, append_term); + break; + + case _unify_x_var2 : + fprintf(stderr, "%s_unify_x_var2%s", prepend_term, append_term); + break; + + case _unify_x_var2_write : + fprintf(stderr, "%s_unify_x_var2_write%s", prepend_term, append_term); + break; + + case _unify_l_x_var2 : + fprintf(stderr, "%s_unify_l_x_var2%s", prepend_term, append_term); + break; + + case _unify_l_x_var2_write : + fprintf(stderr, "%s_unify_l_x_var2_write%s", prepend_term, append_term); + break; + + case _unify_y_var : + fprintf(stderr, "%s_unify_y_var%s", prepend_term, append_term); + break; + + case _unify_y_var_write : + fprintf(stderr, "%s_unify_y_var_write%s", prepend_term, append_term); + break; + + case _unify_l_y_var : + fprintf(stderr, "%s_unify_l_y_var%s", prepend_term, append_term); + break; + + case _unify_l_y_var_write : + fprintf(stderr, "%s_unify_l_y_var_write%s", prepend_term, append_term); + break; + + case _unify_x_val : + fprintf(stderr, "%s_unify_x_val%s", prepend_term, append_term); + break; + + case _unify_x_val_write : + fprintf(stderr, "%s_unify_x_val_write%s", prepend_term, append_term); + break; + + case _unify_l_x_val : + fprintf(stderr, "%s_unify_l_x_val%s", prepend_term, append_term); + break; + + case _unify_l_x_val_write : + fprintf(stderr, "%s_uify_l_x_val_write%s", prepend_term, append_term); + break; + + case _unify_y_val : + fprintf(stderr, "%s_unify_y_val%s", prepend_term, append_term); + break; + + case _unify_y_val_write : + fprintf(stderr, "%s_unify_y_val_write%s", prepend_term, append_term); + break; + + case _unify_l_y_val : + fprintf(stderr, "%s_unify_l_y_val%s", prepend_term, append_term); + break; + + case _unify_l_y_val_write : + fprintf(stderr, "%s_unify_l_y_val_write%s", prepend_term, append_term); + break; + + case _unify_x_loc : + fprintf(stderr, "%s_unify_x_loc%s", prepend_term, append_term); + break; + + case _unify_x_loc_write : + fprintf(stderr, "%s_unify_x_loc_write%s", prepend_term, append_term); + break; + + case _unify_l_x_loc : + fprintf(stderr, "%s_unify_l_x_loc%s", prepend_term, append_term); + break; + + case _unify_l_x_loc_write : + fprintf(stderr, "%s_unify_l_x_loc_write%s", prepend_term, append_term); + break; + + case _unify_y_loc : + fprintf(stderr, "%s_unify_y_loc%s", prepend_term, append_term); + break; + + case _unify_y_loc_write : + fprintf(stderr, "%s_unify_y_loc_write%s", prepend_term, append_term); + break; + + case _unify_l_y_loc : + fprintf(stderr, "%s_unify_l_y_loc%s", prepend_term, append_term); + break; + + case _unify_l_y_loc_write : + fprintf(stderr, "%s_unify_l_y_loc_write%s", prepend_term, append_term); + break; + + case _unify_void : + fprintf(stderr, "%s_unify_void%s", prepend_term, append_term); + break; + + case _unify_void_write : + fprintf(stderr, "%s_unify_void_write%s", prepend_term, append_term); + break; + + case _unify_l_void : + fprintf(stderr, "%s_unify_l_void%s", prepend_term, append_term); + break; + + case _unify_l_void_write : + fprintf(stderr, "%s_unify_l_void_write%s", prepend_term, append_term); + break; + + case _unify_n_voids : + fprintf(stderr, "%s_unify_n_voids%s", prepend_term, append_term); + break; + + case _unify_n_voids_write : + fprintf(stderr, "%s_unify_n_voids_write%s", prepend_term, append_term); + break; + + case _unify_l_n_voids : + fprintf(stderr, "%s_unify_l_n_voids%s", prepend_term, append_term); + break; + + case _unify_l_n_voids_write : + fprintf(stderr, "%s_unify_l_n_voids_write%s", prepend_term, append_term); + break; + + case _unify_atom : + fprintf(stderr, "%s_unify_atom%s", prepend_term, append_term); + break; + + case _unify_atom_write : + fprintf(stderr, "%s_unify_atom_write%s", prepend_term, append_term); + break; + + case _unify_l_atom : + fprintf(stderr, "%s_unify_l_atom%s", prepend_term, append_term); + break; + + case _unify_l_atom_write : + fprintf(stderr, "%s_unify_l_atom_write%s", prepend_term, append_term); + break; + + case _unify_n_atoms : + fprintf(stderr, "%s_unify_n_atoms%s", prepend_term, append_term); + break; + + case _unify_n_atoms_write : + fprintf(stderr, "%s_unify_n_atoms_write%s", prepend_term, append_term); + break; + + case _unify_float : + fprintf(stderr, "%s_unify_float%s", prepend_term, append_term); + break; + + case _unify_float_write : + fprintf(stderr, "%s_unify_float_write%s", prepend_term, append_term); + break; + + case _unify_l_float : + fprintf(stderr, "%s_unify_l_float%s", prepend_term, append_term); + break; + + case _unify_l_float_write : + fprintf(stderr, "%s_unify_l_float_write%s", prepend_term, append_term); + break; + + case _unify_longint : + fprintf(stderr, "%s_unify_longint%s", prepend_term, append_term); + break; + + case _unify_longint_write : + fprintf(stderr, "%s_unify_longint_write%s", prepend_term, append_term); + break; + + case _unify_l_longint : + fprintf(stderr, "%s_unify_l_longint%s", prepend_term, append_term); + break; + + case _unify_l_longint_write : + fprintf(stderr, "%s_unify_l_longint_write%s", prepend_term, append_term); + break; + + case _unify_bigint : + fprintf(stderr, "%s_unify_bigint%s", prepend_term, append_term); + break; + + case _unify_l_bigint : + fprintf(stderr, "%s_unify_l_bigint%s", prepend_term, append_term); + break; + + case _unify_dbterm : + fprintf(stderr, "%s_unify_dbterm%s", prepend_term, append_term); + break; + + case _unify_l_dbterm : + fprintf(stderr, "%s_unify_l_dbterm%s", prepend_term, append_term); + break; + + case _unify_list : + fprintf(stderr, "%s_unify_list%s", prepend_term, append_term); + break; + + case _unify_list_write : + fprintf(stderr, "%s_unify_list_write%s", prepend_term, append_term); + break; + + case _unify_l_list : + fprintf(stderr, "%s_unify_l_list%s", prepend_term, append_term); + break; + + case _unify_l_list_write : + fprintf(stderr, "%s_unify_l_list_write%s", prepend_term, append_term); + break; + + case _unify_struct : + fprintf(stderr, "%s_unify_struct%s", prepend_term, append_term); + break; + + case _unify_struct_write : + fprintf(stderr, "%s_unify_struct_write%s", prepend_term, append_term); + break; + + case _unify_l_struc : + fprintf(stderr, "%s_unify_l_struc%s", prepend_term, append_term); + break; + + case _unify_l_struc_write : + fprintf(stderr, "%s_unify_l_struc_write%s", prepend_term, append_term); + break; + + case _put_x_var : + fprintf(stderr, "%s_put_x_var%s", prepend_term, append_term); + break; + + case _put_y_var : + fprintf(stderr, "%s_put_y_var%s", prepend_term, append_term); + break; + + case _put_x_val : + fprintf(stderr, "%s_put_x_val%s", prepend_term, append_term); + break; + + case _put_xx_val : + fprintf(stderr, "%s_put_xx_val%s", prepend_term, append_term); + break; + + case _put_y_val : + fprintf(stderr, "%s_put_y_val%s", prepend_term, append_term); + break; + + case _put_y_vals : + fprintf(stderr, "%s_put_y_vals%s", prepend_term, append_term); + break; + + case _put_unsafe : + fprintf(stderr, "%s_put_unsafe%s", prepend_term, append_term); + break; + + case _put_atom : + fprintf(stderr, "%s_put_atom%s", prepend_term, append_term); + break; + + case _put_dbterm : + fprintf(stderr, "%s_put_dbterm%s", prepend_term, append_term); + break; + + case _put_bigint : + fprintf(stderr, "%s_put_bigint%s", prepend_term, append_term); + break; + + case _put_float : + fprintf(stderr, "%s_put_float%s", prepend_term, append_term); + break; + + case _put_longint : + fprintf(stderr, "%s_put_longint%s", prepend_term, append_term); + break; + + case _put_list : + fprintf(stderr, "%s_put_list%s", prepend_term, append_term); + break; + + case _put_struct : + fprintf(stderr, "%s_put_struct%s", prepend_term, append_term); + break; + + case _write_x_var : + fprintf(stderr, "%s_write_x_var%s", prepend_term, append_term); + break; + + case _write_void : + fprintf(stderr, "%s_write_void%s", prepend_term, append_term); + break; + + case _write_n_voids : + fprintf(stderr, "%s_write_n_voids%s", prepend_term, append_term); + break; + + case _write_y_var : + fprintf(stderr, "%s_write_y_var%s", prepend_term, append_term); + break; + + case _write_x_val : + fprintf(stderr, "%s_write_x_val%s", prepend_term, append_term); + break; + + case _write_x_loc : + fprintf(stderr, "%s_write_x_loc%s", prepend_term, append_term); + break; + + case _write_y_val : + fprintf(stderr, "%s_write_y_val%s", prepend_term, append_term); + break; + + case _write_y_loc : + fprintf(stderr, "%s_write_y_loc%s", prepend_term, append_term); + break; + + case _write_atom : + fprintf(stderr, "%s_write_atom%s", prepend_term, append_term); + break; + + case _write_bigint : + fprintf(stderr, "%s_write_bigint%s", prepend_term, append_term); + break; + + case _write_dbterm : + fprintf(stderr, "%s_write_dbterm%s", prepend_term, append_term); + break; + + case _write_float : + fprintf(stderr, "%s_write_float%s", prepend_term, append_term); + break; + + case _write_longint : + fprintf(stderr, "%s_write_longint%s", prepend_term, append_term); + break; + + case _write_n_atoms : + fprintf(stderr, "%s_write_n_atoms%s", prepend_term, append_term); + break; + + case _write_list : + fprintf(stderr, "%s_write_list%s", prepend_term, append_term); + break; + + case _write_l_list : + fprintf(stderr, "%s_write_l_list%s", prepend_term, append_term); + break; + + case _write_struct : + fprintf(stderr, "%s_write_struct%s", prepend_term, append_term); + break; + + case _write_l_struc : + fprintf(stderr, "%s_write_l_struc%s", prepend_term, append_term); + break; + + case _save_pair_x : + fprintf(stderr, "%s_save_pair_x%s", prepend_term, append_term); + break; + + case _save_pair_x_write : + fprintf(stderr, "%s_save_pair_x_write%s", prepend_term, append_term); + break; + + case _save_pair_y : + fprintf(stderr, "%s_save_pair_y%s", prepend_term, append_term); + break; + + case _save_pair_y_write : + fprintf(stderr, "%s_save_pair_y_write%s", prepend_term, append_term); + break; + + case _save_appl_x : + fprintf(stderr, "%s_save_appl_x%s", prepend_term, append_term); + break; + + case _save_appl_x_write : + fprintf(stderr, "%s_save_appl_x_write%s", prepend_term, append_term); + break; + + case _save_appl_y : + fprintf(stderr, "%s_save_appl_y%s", prepend_term, append_term); + break; + + case _save_appl_y_write : + fprintf(stderr, "%s_save_appl_y_write%s", prepend_term, append_term); + break; + + case _jump : + fprintf(stderr, "%s_jump%s", prepend_term, append_term); + break; + + case _move_back : + fprintf(stderr, "%s_move_back%s", prepend_term, append_term); + break; + + case _skip : + fprintf(stderr, "%s_skip%s", prepend_term, append_term); + break; + + case _either : + fprintf(stderr, "%s_either%s", prepend_term, append_term); + break; + + case _or_else : + fprintf(stderr, "%s_or_else%s", prepend_term, append_term); + break; + + case _pop_n : + fprintf(stderr, "%s_pop_n%s", prepend_term, append_term); + break; + + case _pop : + fprintf(stderr, "%s_pop%s", prepend_term, append_term); + break; + + case _call_cpred : + fprintf(stderr, "%s_call_cpred%s", prepend_term, append_term); + break; + + case _execute_cpred : + fprintf(stderr, "%s_execute_cpred%s", prepend_term, append_term); + break; + + case _call_usercpred : + fprintf(stderr, "%s_call_usercpred%s", prepend_term, append_term); + break; + + case _call_c_wfail : + fprintf(stderr, "%s_call_x_wfail%s", prepend_term, append_term); + break; + + case _try_c : + fprintf(stderr, "%s_try_c%s", prepend_term, append_term); + break; + + case _retry_c : + fprintf(stderr, "%s_retry_c%s", prepend_term, append_term); + break; + +#ifdef CUT_C + case _cut_c : + fprintf(stderr, "%s_cut_c%s", prepend_term, append_term); + break; + +#endif + case _try_userc : + fprintf(stderr, "%s_try_userc%s", prepend_term, append_term); + break; + + case _retry_userc : + fprintf(stderr, "%s_retry_userc%s", prepend_term, append_term); + break; + +#ifdef CUT_C + case _cut_userc : + fprintf(stderr, "%s_cut_userc%s", prepend_term, append_term); + break; + +#endif + case _lock_pred : + fprintf(stderr, "%s_lock_pred%s", prepend_term, append_term); + break; + + case _index_pred : + fprintf(stderr, "%s_index_pred%s", prepend_term, append_term); + break; + +#ifdef THREADS + case _thread_local : + fprintf(stderr, "%s_thread_local%s", prepend_term, append_term); + break; + +#endif + case _expand_index : + fprintf(stderr, "%s_expand_index%s", prepend_term, append_term); + break; + + case _expand_clauses : + fprintf(stderr, "%s_expand_clauses%s", prepend_term, append_term); + break; + + case _undef_p : + fprintf(stderr, "%s_undef_p%s", prepend_term, append_term); + break; + + case _spy_pred : + fprintf(stderr, "%s_spy_pred%s", prepend_term, append_term); + break; + + case _try_clause : + fprintf(stderr, "%s_try_clause%s", prepend_term, append_term); + break; + + case _try_clause2 : + fprintf(stderr, "%s_try_clause2%s", prepend_term, append_term); + break; + + case _try_clause3 : + fprintf(stderr, "%s_try_clause3%s", prepend_term, append_term); + break; + + case _try_clause4 : + fprintf(stderr, "%s_try_clause4%s", prepend_term, append_term); + break; + + case _retry : + fprintf(stderr, "%s_retry%s", prepend_term, append_term); + break; + + case _retry2 : + fprintf(stderr, "%s_retry2%s", prepend_term, append_term); + break; + + case _retry3 : + fprintf(stderr, "%s_retry3%s", prepend_term, append_term); + break; + + case _retry4 : + fprintf(stderr, "%s_retry4%s", prepend_term, append_term); + break; + + case _trust : + fprintf(stderr, "%s_trust%s", prepend_term, append_term); + break; + + case _try_in : + fprintf(stderr, "%s_try_in%s", prepend_term, append_term); + break; + + case _enter_lu_pred : + fprintf(stderr, "%s_enter_lu_pred%s", prepend_term, append_term); + break; + + case _try_logical : + fprintf(stderr, "%s_try_logical%s", prepend_term, append_term); + break; + + case _retry_logical : + fprintf(stderr, "%s_retry_logical%s", prepend_term, append_term); + break; + + case _trust_logical : + fprintf(stderr, "%s_trust_logical%s", prepend_term, append_term); + break; + + case _user_switch : + fprintf(stderr, "%s_user_switch%s", prepend_term, append_term); + break; + + case _switch_on_type : + fprintf(stderr, "%s_switch_on_type%s", prepend_term, append_term); + break; + + case _switch_list_nl : + fprintf(stderr, "%s_switch_list_nl%s", prepend_term, append_term); + break; + + case _switch_on_arg_type : + fprintf(stderr, "%s_switch_on_arg_type%s", prepend_term, append_term); + break; + + case _switch_on_sub_arg_type : + fprintf(stderr, "%s_switch_on_sub_arg_type%s", prepend_term, append_term); + break; + + case _jump_if_var : + fprintf(stderr, "%s_jump_if_var%s", prepend_term, append_term); + break; + + case _jump_if_nonvar : + fprintf(stderr, "%s_jump_if_nonvar%s", prepend_term, append_term); + break; + + case _if_not_then : + fprintf(stderr, "%s_if_not_then%s", prepend_term, append_term); + break; + + case _switch_on_func : + fprintf(stderr, "%s_switch_on_func%s", prepend_term, append_term); + break; + + case _switch_on_cons : + fprintf(stderr, "%s_switch_on_cons%s", prepend_term, append_term); + break; + + case _go_on_func : + fprintf(stderr, "%s_go_on_func%s", prepend_term, append_term); + break; + + case _go_on_cons : + fprintf(stderr, "%s_go_on_cons%s", prepend_term, append_term); + break; + + case _if_func : + fprintf(stderr, "%s_if_func%s", prepend_term, append_term); + break; + + case _if_cons : + fprintf(stderr, "%s_if_cons%s", prepend_term, append_term); + break; + + case _index_dbref : + fprintf(stderr, "%s_index_dbref%s", prepend_term, append_term); + break; + + case _index_blob : + fprintf(stderr, "%s_index_blob%s", prepend_term, append_term); + break; + + case _index_long : + fprintf(stderr, "%s_index_long%s", prepend_term, append_term); + break; + +#if YAP_JIT + case _jit_handler : + fprintf(stderr, "%s_jit_handler%s", prepend_term, append_term); + break; +#endif + + case _p_atom_x : + fprintf(stderr, "%s_p_atom_x%s", prepend_term, append_term); + break; + + case _p_atom_y : + fprintf(stderr, "%s_p_atom_y%s", prepend_term, append_term); + break; + + case _p_atomic_x : + fprintf(stderr, "%s_p_atomic_x%s", prepend_term, append_term); + break; + + case _p_atomic_y : + fprintf(stderr, "%s_p_atomic_y%s", prepend_term, append_term); + break; + + case _p_integer_x : + fprintf(stderr, "%s_p_integer_x%s", prepend_term, append_term); + break; + + case _p_integer_y : + fprintf(stderr, "%s_p_integer_y%s", prepend_term, append_term); + break; + + case _p_nonvar_x : + fprintf(stderr, "%s_p_nonvar_x%s", prepend_term, append_term); + break; + + case _p_nonvar_y : + fprintf(stderr, "%s_p_nonvar_y%s", prepend_term, append_term); + break; + + case _p_number_x : + fprintf(stderr, "%s_p_number_x%s", prepend_term, append_term); + break; + + case _p_number_y : + fprintf(stderr, "%s_p_number_y%s", prepend_term, append_term); + break; + + case _p_var_x : + fprintf(stderr, "%s_p_var_x%s", prepend_term, append_term); + break; + + case _p_var_y : + fprintf(stderr, "%s_p_var_y%s", prepend_term, append_term); + break; + + case _p_db_ref_x : + fprintf(stderr, "%s_p_db_ref_x%s", prepend_term, append_term); + break; + + case _p_db_ref_y : + fprintf(stderr, "%s_p_db_ref_y%s", prepend_term, append_term); + break; + + case _p_primitive_x : + fprintf(stderr, "%s_p_primitive_x%s", prepend_term, append_term); + break; + + case _p_primitive_y : + fprintf(stderr, "%s_p_primitive_y%s", prepend_term, append_term); + break; + + case _p_compound_x : + fprintf(stderr, "%s_p_compound_x%s", prepend_term, append_term); + break; + + case _p_compound_y : + fprintf(stderr, "%s_p_compound_y%s", prepend_term, append_term); + break; + + case _p_float_x : + fprintf(stderr, "%s_p_float_x%s", prepend_term, append_term); + break; + + case _p_float_y : + fprintf(stderr, "%s_p_float_y%s", prepend_term, append_term); + break; + + case _p_plus_vv : + fprintf(stderr, "%s_p_plus_vv%s", prepend_term, append_term); + break; + + case _p_plus_vc : + fprintf(stderr, "%s_p_plus_vc%s", prepend_term, append_term); + break; + + case _p_plus_y_vv : + fprintf(stderr, "%s_p_plus_y_vv%s", prepend_term, append_term); + break; + + case _p_plus_y_vc : + fprintf(stderr, "%s_p_plus_y_vc%s", prepend_term, append_term); + break; + + case _p_minus_vv : + fprintf(stderr, "%s_p_minus_vv%s", prepend_term, append_term); + break; + + case _p_minus_cv : + fprintf(stderr, "%s_p_minus_cv%s", prepend_term, append_term); + break; + + case _p_minus_y_vv : + fprintf(stderr, "%s_p_minus_y_vv%s", prepend_term, append_term); + break; + + case _p_minus_y_cv : + fprintf(stderr, "%s_p_minus_y_cv%s", prepend_term, append_term); + break; + + case _p_times_vv : + fprintf(stderr, "%s_p_times_vv%s", prepend_term, append_term); + break; + + case _p_times_vc : + fprintf(stderr, "%s_p_times_vc%s", prepend_term, append_term); + break; + + case _p_times_y_vv : + fprintf(stderr, "%s_p_times_y_vv%s", prepend_term, append_term); + break; + + case _p_times_y_vc : + fprintf(stderr, "%s_p_times_y_vc%s", prepend_term, append_term); + break; + + case _p_div_vv : + fprintf(stderr, "%s_p_div_vv%s", prepend_term, append_term); + break; + + case _p_div_vc : + fprintf(stderr, "%s_p_div_vc%s", prepend_term, append_term); + break; + + case _p_div_cv : + fprintf(stderr, "%s_p_div_cv%s", prepend_term, append_term); + break; + + case _p_div_y_vv : + fprintf(stderr, "%s_p_div_y_vv%s", prepend_term, append_term); + break; + + case _p_div_y_vc : + fprintf(stderr, "%s_p_div_y_vc%s", prepend_term, append_term); + break; + + case _p_div_y_cv : + fprintf(stderr, "%s_p_div_y_cv%s", prepend_term, append_term); + break; + + case _p_and_vv : + fprintf(stderr, "%s_p_and_vv%s", prepend_term, append_term); + break; + + case _p_and_vc : + fprintf(stderr, "%s_p_and_vc%s", prepend_term, append_term); + break; + + case _p_and_y_vv : + fprintf(stderr, "%s_p_and_y_vv%s", prepend_term, append_term); + break; + + case _p_and_y_vc : + fprintf(stderr, "%s_p_and_y_vc%s", prepend_term, append_term); + break; + + case _p_or_vv : + fprintf(stderr, "%s_p_or_vv%s", prepend_term, append_term); + break; + + case _p_or_vc : + fprintf(stderr, "%s_p_or_vc%s", prepend_term, append_term); + break; + + case _p_or_y_vv : + fprintf(stderr, "%s_p_or_y_vv%s", prepend_term, append_term); + break; + + case _p_or_y_vc : + fprintf(stderr, "%s_p_or_y_vc%s", prepend_term, append_term); + break; + + case _p_sll_vv : + fprintf(stderr, "%s_p_sll_vv%s", prepend_term, append_term); + break; + + case _p_sll_vc : + fprintf(stderr, "%s_p_sll_vc%s", prepend_term, append_term); + break; + + case _p_sll_cv : + fprintf(stderr, "%s_p_sll_cv%s", prepend_term, append_term); + break; + + case _p_sll_y_vv : + fprintf(stderr, "%s_p_sll_y_vv%s", prepend_term, append_term); + break; + + case _p_sll_y_vc : + fprintf(stderr, "%s_p_sll_y_vc%s", prepend_term, append_term); + break; + + case _p_sll_y_cv : + fprintf(stderr, "%s_p_sll_y_cv%s", prepend_term, append_term); + break; + + case _p_slr_vv : + fprintf(stderr, "%s_p_slr_vv%s", prepend_term, append_term); + break; + + case _p_slr_vc : + fprintf(stderr, "%s_p_slr_vc%s", prepend_term, append_term); + break; + + case _p_slr_cv : + fprintf(stderr, "%s_p_slr_cv%s", prepend_term, append_term); + break; + + case _p_slr_y_vv : + fprintf(stderr, "%s_p_slr_y_vv%s", prepend_term, append_term); + break; + + case _p_slr_y_vc : + fprintf(stderr, "%s_p_slr_y_vc%s", prepend_term, append_term); + break; + + case _p_slr_y_cv : + fprintf(stderr, "%s_p_slr_y_cv%s", prepend_term, append_term); + break; + + case _call_bfunc_xx : + fprintf(stderr, "%s_call_bfunc_xx%s", prepend_term, append_term); + break; + + case _call_bfunc_yx : + fprintf(stderr, "%s_call_bfunc_yx%s", prepend_term, append_term); + break; + + case _call_bfunc_xy : + fprintf(stderr, "%s_call_bfunc_xy%s", prepend_term, append_term); + break; + + case _call_bfunc_yy : + fprintf(stderr, "%s_call_bfunc_yy%s", prepend_term, append_term); + break; + + case _p_equal : + fprintf(stderr, "%s_p_equal%s", prepend_term, append_term); + break; + + case _p_dif : + fprintf(stderr, "%s_p_dif%s", prepend_term, append_term); + break; + + case _p_eq : + fprintf(stderr, "%s_p_eq%s", prepend_term, append_term); + break; + + case _p_arg_vv : + fprintf(stderr, "%s_p_arg_vv%s", prepend_term, append_term); + break; + + case _p_arg_cv : + fprintf(stderr, "%s_p_arg_cv%s", prepend_term, append_term); + break; + + case _p_arg_y_vv : + fprintf(stderr, "%s_p_arg_y_vv%s", prepend_term, append_term); + break; + + case _p_arg_y_cv : + fprintf(stderr, "%s_p_arg_y_cv%s", prepend_term, append_term); + break; + + case _p_func2s_vv : + fprintf(stderr, "%s_p_func2s_vv%s", prepend_term, append_term); + break; + + case _p_func2s_cv : + fprintf(stderr, "%s_p_func2s_cv%s", prepend_term, append_term); + break; + + case _p_func2s_vc : + fprintf(stderr, "%s_p_func2s_vc%s", prepend_term, append_term); + break; + + case _p_func2s_y_vv : + fprintf(stderr, "%s_p_func2s_y_vv%s", prepend_term, append_term); + break; + + case _p_func2s_y_cv : + fprintf(stderr, "%s_p_func2s_y_cv%s", prepend_term, append_term); + break; + + case _p_func2s_y_vc : + fprintf(stderr, "%s_p_func2s_y_vc%s", prepend_term, append_term); + break; + + case _p_func2f_xx : + fprintf(stderr, "%s_p_func2f_xx%s", prepend_term, append_term); + break; + + case _p_func2f_xy : + fprintf(stderr, "%s_p_func2f_xy%s", prepend_term, append_term); + break; + + case _p_func2f_yx : + fprintf(stderr, "%s_p_func2f_yx%s", prepend_term, append_term); + break; + + case _p_func2f_yy : + fprintf(stderr, "%s_p_func2f_yy%s", prepend_term, append_term); + break; + + case _p_functor : + fprintf(stderr, "%s_p_functor%s", prepend_term, append_term); + break; + + case _p_execute2 : + fprintf(stderr, "%s_p_execute2%s", prepend_term, append_term); + break; + + case _p_execute : + fprintf(stderr, "%s_p_execute%s", prepend_term, append_term); + break; + + case _p_execute_tail : + fprintf(stderr, "%s_p_execute_tail%s", prepend_term, append_term); + break; + +#ifdef YAPOR + case _getwork_first_time : + fprintf(stderr, "%s_getwork_first_time%s", prepend_term, append_term); + break; + + case _getwork : + fprintf(stderr, "%s_getwork%s", prepend_term, append_term); + break; + + case _getwork_seq : + fprintf(stderr, "%s_getwork_seq%s", prepend_term, append_term); + break; + + case _sync : + fprintf(stderr, "%s_sync%s", prepend_term, append_term); + break; + +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _clause_with_cut : + fprintf(stderr, "%s_clause_with_cut%s", prepend_term, append_term); + break; + +#endif + case _table_load_answer : + fprintf(stderr, "%s_table_load_answer%s", prepend_term, append_term); + break; + + case _table_try_answer : + fprintf(stderr, "%s_table_try_answer%s", prepend_term, append_term); + break; + + case _table_try_single : + fprintf(stderr, "%s_table_try_single%s", prepend_term, append_term); + break; + + case _table_try_me : + fprintf(stderr, "%s_table_try_me%s", prepend_term, append_term); + break; + + case _table_try : + fprintf(stderr, "%s_table_try%s", prepend_term, append_term); + break; + + case _table_retry_me : + fprintf(stderr, "%s_table_retry_me%s", prepend_term, append_term); + break; + + case _table_retry : + fprintf(stderr, "%s_table_retry%s", prepend_term, append_term); + break; + + case _table_trust_me : + fprintf(stderr, "%s_table_trust_me%s", prepend_term, append_term); + break; + + case _table_trust : + fprintf(stderr, "%s_table_trust%s", prepend_term, append_term); + break; + + case _table_new_answer : + fprintf(stderr, "%s_table_new_answer%s", prepend_term, append_term); + break; + + case _table_answer_resolution : + fprintf(stderr, "%s_table_answer_resolution%s", prepend_term, append_term); + break; + + case _table_completion : + fprintf(stderr, "%s_table_completion%s", prepend_term, append_term); + break; + +#ifdef THREADS_CONSUMER_SHARING + case _table_answer_resolution_completion: + fprintf(stderr, "%s_table_answer_resolution_completion%s", prepend_term, append_term); + break; + +#endif + case _trie_do_var : + fprintf(stderr, "%s_trie_do_var%s", prepend_term, append_term); + break; + + case _trie_trust_var : + fprintf(stderr, "%s_trie_trust_var%s", prepend_term, append_term); + break; + + case _trie_try_var : + fprintf(stderr, "%s_trie_try_var%s", prepend_term, append_term); + break; + + case _trie_retry_var : + fprintf(stderr, "%s_trie_retry_var%s", prepend_term, append_term); + break; + + case _trie_do_var_in_pair : + fprintf(stderr, "%s_trie_do_var_in_pair%s", prepend_term, append_term); + break; + + case _trie_trust_var_in_pair : + fprintf(stderr, "%s_trie_trust_var_in_pair%s", prepend_term, append_term); + break; + + case _trie_try_var_in_pair : + fprintf(stderr, "%s_trie_try_var_in_pair%s", prepend_term, append_term); + break; + + case _trie_retry_var_in_pair : + fprintf(stderr, "%s_trie_retry_var_in_pair%s", prepend_term, append_term); + break; + + case _trie_do_val : + fprintf(stderr, "%s_trie_do_val%s", prepend_term, append_term); + break; + + case _trie_trust_val : + fprintf(stderr, "%s_trie_trust_val%s", prepend_term, append_term); + break; + + case _trie_try_val : + fprintf(stderr, "%s_trie_try_val%s", prepend_term, append_term); + break; + + case _trie_retry_val : + fprintf(stderr, "%s_trie_retry_val%s", prepend_term, append_term); + break; + + case _trie_do_val_in_pair : + fprintf(stderr, "%s_trie_do_val_in_pair%s", prepend_term, append_term); + break; + + case _trie_trust_val_in_pair : + fprintf(stderr, "%s_trie_trust_val_in_pair%s", prepend_term, append_term); + break; + + case _trie_try_val_in_pair : + fprintf(stderr, "%s_trie_try_val_in_pair%s", prepend_term, append_term); + break; + + case _trie_retry_val_in_pair : + fprintf(stderr, "%s_trie_retry_val_in_pair%s", prepend_term, append_term); + break; + + case _trie_do_atom : + fprintf(stderr, "%s_trie_do_atom%s", prepend_term, append_term); + break; + + case _trie_trust_atom : + fprintf(stderr, "%s_trie_trust_atom%s", prepend_term, append_term); + break; + + case _trie_try_atom : + fprintf(stderr, "%s_trie_try_atom%s", prepend_term, append_term); + break; + + case _trie_retry_atom : + fprintf(stderr, "%s_trie_retry_atom%s", prepend_term, append_term); + break; + + case _trie_do_atom_in_pair : + fprintf(stderr, "%s_trie_do_atom_in_pair%s", prepend_term, append_term); + break; + + case _trie_trust_atom_in_pair : + fprintf(stderr, "%s_trie_trust_atom_in_pair%s", prepend_term, append_term); + break; + + case _trie_try_atom_in_pair : + fprintf(stderr, "%s_trie_try_atom_in_pair%s", prepend_term, append_term); + break; + + case _trie_retry_atom_in_pair : + fprintf(stderr, "%s_trie_retry_atom_in_pair%s", prepend_term, append_term); + break; + + case _trie_do_null : + fprintf(stderr, "%s_trie_do_null%s", prepend_term, append_term); + break; + + case _trie_trust_null : + fprintf(stderr, "%s_trie_trust_null%s", prepend_term, append_term); + break; + + case _trie_try_null : + fprintf(stderr, "%s_trie_try_null%s", prepend_term, append_term); + break; + + case _trie_retry_null : + fprintf(stderr, "%s_trie_retry_null%s", prepend_term, append_term); + break; + + case _trie_do_null_in_pair : + fprintf(stderr, "%s_trie_do_null_in_pair%s", prepend_term, append_term); + break; + + case _trie_trust_null_in_pair : + fprintf(stderr, "%s_trie_trust_null_in_pair%s", prepend_term, append_term); + break; + + case _trie_try_null_in_pair : + fprintf(stderr, "%s_tri_try_null_in_paire%s", prepend_term, append_term); + break; + + case _trie_retry_null_in_pair : + fprintf(stderr, "%s_trie_retry_null_in_pair%s", prepend_term, append_term); + break; + + case _trie_do_pair : + fprintf(stderr, "%s_trie_do_pair%s", prepend_term, append_term); + break; + + case _trie_trust_pair : + fprintf(stderr, "%s_trie_trust_pair%s", prepend_term, append_term); + break; + + case _trie_try_pair : + fprintf(stderr, "%s_trie_try_pair%s", prepend_term, append_term); + break; + + case _trie_retry_pair : + fprintf(stderr, "%s_trie_retry_pair%s", prepend_term, append_term); + break; + + case _trie_do_appl : + fprintf(stderr, "%s_trie_do_appl%s", prepend_term, append_term); + break; + + case _trie_trust_appl : + fprintf(stderr, "%s_trie_trust_appl%s", prepend_term, append_term); + break; + + case _trie_try_appl : + fprintf(stderr, "%s_trie_try_appl%s", prepend_term, append_term); + break; + + case _trie_retry_appl : + fprintf(stderr, "%s_trie_retry_appl%s", prepend_term, append_term); + break; + + case _trie_do_appl_in_pair : + fprintf(stderr, "%s_trie_do_appl_in_pair%s", prepend_term, append_term); + break; + + case _trie_trust_appl_in_pair : + fprintf(stderr, "%s_trie_trust_appl_in_pair%s", prepend_term, append_term); + break; + + case _trie_try_appl_in_pair : + fprintf(stderr, "%s_trie_trty_appkl_in_pair%s", prepend_term, append_term); + break; + + case _trie_retry_appl_in_pair : + fprintf(stderr, "%s_trie_retry_appl_in_pair%s", prepend_term, append_term); + break; + + case _trie_do_extension : + fprintf(stderr, "%s_trie_do_extension%s", prepend_term, append_term); + break; + + case _trie_trust_extension : + fprintf(stderr, "%s_trie_trust_extension%s", prepend_term, append_term); + break; + + case _trie_try_extension : + fprintf(stderr, "%s_trie_try_extension%s", prepend_term, append_term); + break; + + case _trie_retry_extension : + fprintf(stderr, "%s_trie_retry_extension%s", prepend_term, append_term); + break; + + case _trie_do_double : + fprintf(stderr, "%s_trie_do_double%s", prepend_term, append_term); + break; + + case _trie_trust_double : + fprintf(stderr, "%s_trie_trust_double%s", prepend_term, append_term); + break; + + case _trie_try_double : + fprintf(stderr, "%s_trie_try_double%s", prepend_term, append_term); + break; + + case _trie_retry_double : + fprintf(stderr, "%s_trie_retry_double%s", prepend_term, append_term); + break; + + case _trie_do_longint : + fprintf(stderr, "%s_trie_do_longint%s", prepend_term, append_term); + break; + + case _trie_trust_longint : + fprintf(stderr, "%s_trie_trust_longint%s", prepend_term, append_term); + break; + + case _trie_try_longint : + fprintf(stderr, "%s_trie_try_longint%s", prepend_term, append_term); + break; + + case _trie_retry_longint : + fprintf(stderr, "%s_trie_retry_longint%s", prepend_term, append_term); + break; + + case _trie_do_gterm : + fprintf(stderr, "%s_trie_do_gterm%s", prepend_term, append_term); + break; + + case _trie_trust_gterm : + fprintf(stderr, "%s_trie_trust_gterm%s", prepend_term, append_term); + break; + + case _trie_try_gterm : + fprintf(stderr, "%s_trie_try_gterm%s", prepend_term, append_term); + break; + + case _trie_retry_gterm : + fprintf(stderr, "%s_trie_retry_gterm%s", prepend_term, append_term); + break; + +#endif + /* this instruction is hardwired */ +#ifdef YAPOR + case _or_last : + fprintf(stderr, "%s_or_last%s", prepend_term, append_term); + break; + +#else + case _or_last : + fprintf(stderr, "%s_or_last%s", prepend_term, append_term); + break; + +#endif +#if YAP_JIT + case _traced_Ystop : + fprintf(stderr, "%s_traced_Ystop%s", prepend_term, append_term); + break; + + case _traced_Nstop : + fprintf(stderr, "%s_traced_Nstop%s", prepend_term, append_term); + break; + + case _traced_try_me : + fprintf(stderr, "%s_traced_try_me%s", prepend_term, append_term); + break; + + case _traced_retry_me : + fprintf(stderr, "%s_traced_retry_me%s", prepend_term, append_term); + break; + + case _traced_trust_me : + fprintf(stderr, "%s_traced_trust_me%s", prepend_term, append_term); + break; + + case _traced_enter_profiling : + fprintf(stderr, "%s_traced_enter_profiling%s", prepend_term, append_term); + break; + + case _traced_retry_profiled : + fprintf(stderr, "%s_traced_retry_profiled%s", prepend_term, append_term); + break; + + case _traced_profiled_retry_me : + fprintf(stderr, "%s_traced_profiled_retry_me%s", prepend_term, append_term); + break; + + case _traced_profiled_trust_me : + fprintf(stderr, "%s_traced_profiled_trust_me%s", prepend_term, append_term); + break; + + case _traced_profiled_retry_logical : + fprintf(stderr, "%s_traced_profiled_retry_logical%s", prepend_term, append_term); + break; + + case _traced_profiled_trust_logical : + fprintf(stderr, "%s_traced_profiled_trust_logical%s", prepend_term, append_term); + break; + + case _traced_count_call : + fprintf(stderr, "%s_traced_count_call%s", prepend_term, append_term); + break; + + case _traced_count_retry : + fprintf(stderr, "%s_traced_count_retry%s", prepend_term, append_term); + break; + + case _traced_count_retry_me : + fprintf(stderr, "%s_traced_count_retry_me%s", prepend_term, append_term); + break; + + case _traced_count_trust_me : + fprintf(stderr, "%s_traced_count_trust_me%s", prepend_term, append_term); + break; + + case _traced_count_retry_logical : + fprintf(stderr, "%s_traced_count_retry_logical%s", prepend_term, append_term); + break; + + case _traced_count_trust_logical : + fprintf(stderr, "%s_traced_count_trust_logical%s", prepend_term, append_term); + break; + + case _traced_lock_lu : + fprintf(stderr, "%s_traced_lock_lu%s", prepend_term, append_term); + break; + + case _traced_unlock_lu : + fprintf(stderr, "%s_traced_unlock_lu%s", prepend_term, append_term); + break; + + case _traced_alloc_for_logical_pred : + fprintf(stderr, "%s_traced_alloc_for_logical_pred%s", prepend_term, append_term); + break; + + case _traced_copy_idb_term : + fprintf(stderr, "%s_traced_copy_idb_term%s", prepend_term, append_term); + break; + + case _traced_unify_idb_term : + fprintf(stderr, "%s_traced_unify_idb_term%s", prepend_term, append_term); + break; + + case _traced_ensure_space : + fprintf(stderr, "%s_traced_ensure_space%s", prepend_term, append_term); + break; + + case _traced_spy_or_trymark : + fprintf(stderr, "%s_traced_spy_or_trymark%s", prepend_term, append_term); + break; + + case _traced_try_and_mark : + fprintf(stderr, "%s_traced_try_and_mark%s", prepend_term, append_term); + break; + + case _traced_count_retry_and_mark : + fprintf(stderr, "%s_traced_count_retry_and_mark%s", prepend_term, append_term); + break; + + case _traced_profiled_retry_and_mark : + fprintf(stderr, "%s_traced_profiled_retry_and_mark%s", prepend_term, append_term); + break; + + case _traced_retry_and_mark : + fprintf(stderr, "%s_traced_retry_and_mark%s", prepend_term, append_term); + break; + + case _traced_trust_fail : + fprintf(stderr, "%s_traced_trust_fail%s", prepend_term, append_term); + break; + + case _traced_op_fail : + fprintf(stderr, "%s_traced_op_fail%s", prepend_term, append_term); + break; + + case _traced_cut : + fprintf(stderr, "%s_traced_cut%s", prepend_term, append_term); + break; + + case _traced_cut_t : + fprintf(stderr, "%s_traced_cut_t%s", prepend_term, append_term); + break; + + case _traced_cut_e : + fprintf(stderr, "%s_traced_cut_e%s", prepend_term, append_term); + break; + + case _traced_save_b_x : + fprintf(stderr, "%s_traced_save_b_x%s", prepend_term, append_term); + break; + + case _traced_save_b_y : + fprintf(stderr, "%s_traced_save_b_y%s", prepend_term, append_term); + break; + + case _traced_commit_b_x : + fprintf(stderr, "%s_traced_commit_b_x%s", prepend_term, append_term); + break; + + case _traced_commit_b_y : + fprintf(stderr, "%s_traced_commit_b_y%s", prepend_term, append_term); + break; + + case _traced_execute : + fprintf(stderr, "%s_traced_execute%s", prepend_term, append_term); + break; + + case _traced_dexecute : + fprintf(stderr, "%s_traced_dexecute%s", prepend_term, append_term); + break; + + case _traced_fcall : + fprintf(stderr, "%s_traced_fcall%s", prepend_term, append_term); + break; + + case _traced_call : + fprintf(stderr, "%s_traced_call%s", prepend_term, append_term); + break; + + case _traced_procceed : + fprintf(stderr, "%s_traced_procceed%s", prepend_term, append_term); + break; + + case _traced_allocate : + fprintf(stderr, "%s_traced_allocate%s", prepend_term, append_term); + break; + + case _traced_deallocate : + fprintf(stderr, "%s_traced_deallocate%s", prepend_term, append_term); + break; + +#ifdef BEAM + case _traced_retry_eam : + fprintf(stderr, "%s_traced_retry_eam%s", prepend_term, append_term); + break; + +#endif +#ifdef BEAM + case _traced_run_eam : + fprintf(stderr, "%s_traced_run_eam%s", prepend_term, append_term); + break; + +#endif + case _traced_get_x_var : + fprintf(stderr, "%s_traced_get_x_var%s", prepend_term, append_term); + break; + + case _traced_get_y_var : + fprintf(stderr, "%s_traced_get_y_var%s", prepend_term, append_term); + break; + + case _traced_get_yy_var : + fprintf(stderr, "%s_traced_get_yy_var%s", prepend_term, append_term); + break; + + case _traced_get_x_val : + fprintf(stderr, "%s_traced_get_x_val%s", prepend_term, append_term); + break; + + case _traced_get_y_val : + fprintf(stderr, "%s_traced_get_y_val%s", prepend_term, append_term); + break; + + case _traced_get_atom : + fprintf(stderr, "%s_traced_get_atom%s", prepend_term, append_term); + break; + + case _traced_get_2atoms : + fprintf(stderr, "%s_traced_get_2atoms%s", prepend_term, append_term); + break; + + case _traced_get_3atoms : + fprintf(stderr, "%s_traced_get_3atoms%s", prepend_term, append_term); + break; + + case _traced_get_4atoms : + fprintf(stderr, "%s_traced_get_4atoms%s", prepend_term, append_term); + break; + + case _traced_get_5atoms : + fprintf(stderr, "%s_traced_get_5atoms%s", prepend_term, append_term); + break; + + case _traced_get_6atoms : + fprintf(stderr, "%s_traced_get_6atoms%s", prepend_term, append_term); + break; + + case _traced_get_list : + fprintf(stderr, "%s_traced_get_list%s", prepend_term, append_term); + break; + + case _traced_get_struct : + fprintf(stderr, "%s_traced_get_struct%s", prepend_term, append_term); + break; + + case _traced_get_float : + fprintf(stderr, "%s_traced_get_float%s", prepend_term, append_term); + break; + + case _traced_get_longint : + fprintf(stderr, "%s_traced_get_longint%s", prepend_term, append_term); + break; + + case _traced_get_bigint : + fprintf(stderr, "%s_traced_get_bigint%s", prepend_term, append_term); + break; + + case _traced_get_dbterm : + fprintf(stderr, "%s_traced_get_dbterm%s", prepend_term, append_term); + break; + + case _traced_glist_valx : + fprintf(stderr, "%s_traced_glist_valx%s", prepend_term, append_term); + break; + + case _traced_glist_valy : + fprintf(stderr, "%s_traced_glist_valy%s", prepend_term, append_term); + break; + + case _traced_gl_void_varx : + fprintf(stderr, "%s_traced_gl_void_varx%s", prepend_term, append_term); + break; + + case _traced_gl_void_vary : + fprintf(stderr, "%s_traced_gl_void_vary%s", prepend_term, append_term); + break; + + case _traced_gl_void_valx : + fprintf(stderr, "%s_traced_gl_void_valx%s", prepend_term, append_term); + break; + + case _traced_gl_void_valy : + fprintf(stderr, "%s_traced_gl_void_valy%s", prepend_term, append_term); + break; + + case _traced_unify_x_var : + fprintf(stderr, "%s_traced_unify_x_var%s", prepend_term, append_term); + break; + + case _traced_unify_x_var_write : + fprintf(stderr, "%s_traced_unify_x_var_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_x_var : + fprintf(stderr, "%s_traced_unify_l_x_var%s", prepend_term, append_term); + break; + + case _traced_unify_l_x_var_write : + fprintf(stderr, "%s_traced_unify_l_x_var_write%s", prepend_term, append_term); + break; + + case _traced_unify_x_var2 : + fprintf(stderr, "%s_traced_unify_x_var2%s", prepend_term, append_term); + break; + + case _traced_unify_x_var2_write : + fprintf(stderr, "%s_traced_unify_x_var2_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_x_var2 : + fprintf(stderr, "%s_traced_unify_l_x_var2%s", prepend_term, append_term); + break; + + case _traced_unify_l_x_var2_write : + fprintf(stderr, "%s_traced_unify_l_x_var2_write%s", prepend_term, append_term); + break; + + case _traced_unify_y_var : + fprintf(stderr, "%s_traced_unify_y_var%s", prepend_term, append_term); + break; + + case _traced_unify_y_var_write : + fprintf(stderr, "%s_traced_unify_y_var_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_y_var : + fprintf(stderr, "%s_traced_unify_l_y_var%s", prepend_term, append_term); + break; + + case _traced_unify_l_y_var_write : + fprintf(stderr, "%s_traced_unify_l_y_var_write%s", prepend_term, append_term); + break; + + case _traced_unify_x_val : + fprintf(stderr, "%s_traced_unify_x_val%s", prepend_term, append_term); + break; + + case _traced_unify_x_val_write : + fprintf(stderr, "%s_traced_unify_x_val_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_x_val : + fprintf(stderr, "%s_traced_unify_l_x_val%s", prepend_term, append_term); + break; + + case _traced_unify_l_x_val_write : + fprintf(stderr, "%s_traced_uify_l_x_val_write%s", prepend_term, append_term); + break; + + case _traced_unify_y_val : + fprintf(stderr, "%s_traced_unify_y_val%s", prepend_term, append_term); + break; + + case _traced_unify_y_val_write : + fprintf(stderr, "%s_traced_unify_y_val_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_y_val : + fprintf(stderr, "%s_traced_unify_l_y_val%s", prepend_term, append_term); + break; + + case _traced_unify_l_y_val_write : + fprintf(stderr, "%s_traced_unify_l_y_val_write%s", prepend_term, append_term); + break; + + case _traced_unify_x_loc : + fprintf(stderr, "%s_traced_unify_x_loc%s", prepend_term, append_term); + break; + + case _traced_unify_x_loc_write : + fprintf(stderr, "%s_traced_unify_x_loc_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_x_loc : + fprintf(stderr, "%s_traced_unify_l_x_loc%s", prepend_term, append_term); + break; + + case _traced_unify_l_x_loc_write : + fprintf(stderr, "%s_traced_unify_l_x_loc_write%s", prepend_term, append_term); + break; + + case _traced_unify_y_loc : + fprintf(stderr, "%s_traced_unify_y_loc%s", prepend_term, append_term); + break; + + case _traced_unify_y_loc_write : + fprintf(stderr, "%s_traced_unify_y_loc_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_y_loc : + fprintf(stderr, "%s_traced_unify_l_y_loc%s", prepend_term, append_term); + break; + + case _traced_unify_l_y_loc_write : + fprintf(stderr, "%s_traced_unify_l_y_loc_write%s", prepend_term, append_term); + break; + + case _traced_unify_void : + fprintf(stderr, "%s_traced_unify_void%s", prepend_term, append_term); + break; + + case _traced_unify_void_write : + fprintf(stderr, "%s_traced_unify_void_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_void : + fprintf(stderr, "%s_traced_unify_l_void%s", prepend_term, append_term); + break; + + case _traced_unify_l_void_write : + fprintf(stderr, "%s_traced_unify_l_void_write%s", prepend_term, append_term); + break; + + case _traced_unify_n_voids : + fprintf(stderr, "%s_traced_unify_n_voids%s", prepend_term, append_term); + break; + + case _traced_unify_n_voids_write : + fprintf(stderr, "%s_traced_unify_n_voids_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_n_voids : + fprintf(stderr, "%s_traced_unify_l_n_voids%s", prepend_term, append_term); + break; + + case _traced_unify_l_n_voids_write : + fprintf(stderr, "%s_traced_unify_l_n_voids_write%s", prepend_term, append_term); + break; + + case _traced_unify_atom : + fprintf(stderr, "%s_traced_unify_atom%s", prepend_term, append_term); + break; + + case _traced_unify_atom_write : + fprintf(stderr, "%s_traced_unify_atom_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_atom : + fprintf(stderr, "%s_traced_unify_l_atom%s", prepend_term, append_term); + break; + + case _traced_unify_l_atom_write : + fprintf(stderr, "%s_traced_unify_l_atom_write%s", prepend_term, append_term); + break; + + case _traced_unify_n_atoms : + fprintf(stderr, "%s_traced_unify_n_atoms%s", prepend_term, append_term); + break; + + case _traced_unify_n_atoms_write : + fprintf(stderr, "%s_traced_unify_n_atoms_write%s", prepend_term, append_term); + break; + + case _traced_unify_float : + fprintf(stderr, "%s_traced_unify_float%s", prepend_term, append_term); + break; + + case _traced_unify_float_write : + fprintf(stderr, "%s_traced_unify_float_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_float : + fprintf(stderr, "%s_traced_unify_l_float%s", prepend_term, append_term); + break; + + case _traced_unify_l_float_write : + fprintf(stderr, "%s_traced_unify_l_float_write%s", prepend_term, append_term); + break; + + case _traced_unify_longint : + fprintf(stderr, "%s_traced_unify_longint%s", prepend_term, append_term); + break; + + case _traced_unify_longint_write : + fprintf(stderr, "%s_traced_unify_longint_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_longint : + fprintf(stderr, "%s_traced_unify_l_longint%s", prepend_term, append_term); + break; + + case _traced_unify_l_longint_write : + fprintf(stderr, "%s_traced_unify_l_longint_write%s", prepend_term, append_term); + break; + + case _traced_unify_bigint : + fprintf(stderr, "%s_traced_unify_bigint%s", prepend_term, append_term); + break; + + case _traced_unify_l_bigint : + fprintf(stderr, "%s_traced_unify_l_bigint%s", prepend_term, append_term); + break; + + case _traced_unify_dbterm : + fprintf(stderr, "%s_traced_unify_dbterm%s", prepend_term, append_term); + break; + + case _traced_unify_l_dbterm : + fprintf(stderr, "%s_traced_unify_l_dbterm%s", prepend_term, append_term); + break; + + case _traced_unify_list : + fprintf(stderr, "%s_traced_unify_list%s", prepend_term, append_term); + break; + + case _traced_unify_list_write : + fprintf(stderr, "%s_traced_unify_list_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_list : + fprintf(stderr, "%s_traced_unify_l_list%s", prepend_term, append_term); + break; + + case _traced_unify_l_list_write : + fprintf(stderr, "%s_traced_unify_l_list_write%s", prepend_term, append_term); + break; + + case _traced_unify_struct : + fprintf(stderr, "%s_traced_unify_struct%s", prepend_term, append_term); + break; + + case _traced_unify_struct_write : + fprintf(stderr, "%s_traced_unify_struct_write%s", prepend_term, append_term); + break; + + case _traced_unify_l_struc : + fprintf(stderr, "%s_traced_unify_l_struc%s", prepend_term, append_term); + break; + + case _traced_unify_l_struc_write : + fprintf(stderr, "%s_traced_unify_l_struc_write%s", prepend_term, append_term); + break; + + case _traced_put_x_var : + fprintf(stderr, "%s_traced_put_x_var%s", prepend_term, append_term); + break; + + case _traced_put_y_var : + fprintf(stderr, "%s_traced_put_y_var%s", prepend_term, append_term); + break; + + case _traced_put_x_val : + fprintf(stderr, "%s_traced_put_x_val%s", prepend_term, append_term); + break; + + case _traced_put_xx_val : + fprintf(stderr, "%s_traced_put_xx_val%s", prepend_term, append_term); + break; + + case _traced_put_y_val : + fprintf(stderr, "%s_traced_put_y_val%s", prepend_term, append_term); + break; + + case _traced_put_y_vals : + fprintf(stderr, "%s_traced_put_y_vals%s", prepend_term, append_term); + break; + + case _traced_put_unsafe : + fprintf(stderr, "%s_traced_put_unsafe%s", prepend_term, append_term); + break; + + case _traced_put_atom : + fprintf(stderr, "%s_traced_put_atom%s", prepend_term, append_term); + break; + + case _traced_put_dbterm : + fprintf(stderr, "%s_traced_put_dbterm%s", prepend_term, append_term); + break; + + case _traced_put_bigint : + fprintf(stderr, "%s_traced_put_bigint%s", prepend_term, append_term); + break; + + case _traced_put_float : + fprintf(stderr, "%s_traced_put_float%s", prepend_term, append_term); + break; + + case _traced_put_longint : + fprintf(stderr, "%s_traced_put_longint%s", prepend_term, append_term); + break; + + case _traced_put_list : + fprintf(stderr, "%s_traced_put_list%s", prepend_term, append_term); + break; + + case _traced_put_struct : + fprintf(stderr, "%s_traced_put_struct%s", prepend_term, append_term); + break; + + case _traced_write_x_var : + fprintf(stderr, "%s_traced_write_x_var%s", prepend_term, append_term); + break; + + case _traced_write_void : + fprintf(stderr, "%s_traced_write_void%s", prepend_term, append_term); + break; + + case _traced_write_n_voids : + fprintf(stderr, "%s_traced_write_n_voids%s", prepend_term, append_term); + break; + + case _traced_write_y_var : + fprintf(stderr, "%s_traced_write_y_var%s", prepend_term, append_term); + break; + + case _traced_write_x_val : + fprintf(stderr, "%s_traced_write_x_val%s", prepend_term, append_term); + break; + + case _traced_write_x_loc : + fprintf(stderr, "%s_traced_write_x_loc%s", prepend_term, append_term); + break; + + case _traced_write_y_val : + fprintf(stderr, "%s_traced_write_y_val%s", prepend_term, append_term); + break; + + case _traced_write_y_loc : + fprintf(stderr, "%s_traced_write_y_loc%s", prepend_term, append_term); + break; + + case _traced_write_atom : + fprintf(stderr, "%s_traced_write_atom%s", prepend_term, append_term); + break; + + case _traced_write_bigint : + fprintf(stderr, "%s_traced_write_bigint%s", prepend_term, append_term); + break; + + case _traced_write_dbterm : + fprintf(stderr, "%s_traced_write_dbterm%s", prepend_term, append_term); + break; + + case _traced_write_float : + fprintf(stderr, "%s_traced_write_float%s", prepend_term, append_term); + break; + + case _traced_write_longint : + fprintf(stderr, "%s_traced_write_longint%s", prepend_term, append_term); + break; + + case _traced_write_n_atoms : + fprintf(stderr, "%s_traced_write_n_atoms%s", prepend_term, append_term); + break; + + case _traced_write_list : + fprintf(stderr, "%s_traced_write_list%s", prepend_term, append_term); + break; + + case _traced_write_l_list : + fprintf(stderr, "%s_traced_write_l_list%s", prepend_term, append_term); + break; + + case _traced_write_struct : + fprintf(stderr, "%s_traced_write_struct%s", prepend_term, append_term); + break; + + case _traced_write_l_struc : + fprintf(stderr, "%s_traced_write_l_struc%s", prepend_term, append_term); + break; + + case _traced_save_pair_x : + fprintf(stderr, "%s_traced_save_pair_x%s", prepend_term, append_term); + break; + + case _traced_save_pair_x_write : + fprintf(stderr, "%s_traced_save_pair_x_write%s", prepend_term, append_term); + break; + + case _traced_save_pair_y : + fprintf(stderr, "%s_traced_save_pair_y%s", prepend_term, append_term); + break; + + case _traced_save_pair_y_write : + fprintf(stderr, "%s_traced_save_pair_y_write%s", prepend_term, append_term); + break; + + case _traced_save_appl_x : + fprintf(stderr, "%s_traced_save_appl_x%s", prepend_term, append_term); + break; + + case _traced_save_appl_x_write : + fprintf(stderr, "%s_traced_save_appl_x_write%s", prepend_term, append_term); + break; + + case _traced_save_appl_y : + fprintf(stderr, "%s_traced_save_appl_y%s", prepend_term, append_term); + break; + + case _traced_save_appl_y_write : + fprintf(stderr, "%s_traced_save_appl_y_write%s", prepend_term, append_term); + break; + + case _traced_jump : + fprintf(stderr, "%s_traced_jump%s", prepend_term, append_term); + break; + + case _traced_move_back : + fprintf(stderr, "%s_traced_move_back%s", prepend_term, append_term); + break; + + case _traced_skip : + fprintf(stderr, "%s_traced_skip%s", prepend_term, append_term); + break; + + case _traced_either : + fprintf(stderr, "%s_traced_either%s", prepend_term, append_term); + break; + + case _traced_or_else : + fprintf(stderr, "%s_traced_or_else%s", prepend_term, append_term); + break; + + case _traced_pop_n : + fprintf(stderr, "%s_traced_pop_n%s", prepend_term, append_term); + break; + + case _traced_pop : + fprintf(stderr, "%s_traced_pop%s", prepend_term, append_term); + break; + + case _traced_call_cpred : + fprintf(stderr, "%s_traced_call_cpred%s", prepend_term, append_term); + break; + + case _traced_execute_cpred : + fprintf(stderr, "%s_traced_execute_cpred%s", prepend_term, append_term); + break; + + case _traced_call_usercpred : + fprintf(stderr, "%s_traced_call_usercpred%s", prepend_term, append_term); + break; + + case _traced_call_c_wfail : + fprintf(stderr, "%s_traced_call_x_wfail%s", prepend_term, append_term); + break; + + case _traced_try_c : + fprintf(stderr, "%s_traced_try_c%s", prepend_term, append_term); + break; + + case _traced_retry_c : + fprintf(stderr, "%s_traced_retry_c%s", prepend_term, append_term); + break; + +#ifdef CUT_C + case _traced_cut_c : + fprintf(stderr, "%s_traced_cut_c%s", prepend_term, append_term); + break; + +#endif + case _traced_try_userc : + fprintf(stderr, "%s_traced_try_userc%s", prepend_term, append_term); + break; + + case _traced_retry_userc : + fprintf(stderr, "%s_traced_retry_userc%s", prepend_term, append_term); + break; + +#ifdef CUT_C + case _traced_cut_userc : + fprintf(stderr, "%s_traced_cut_userc%s", prepend_term, append_term); + break; + +#endif + case _traced_lock_pred : + fprintf(stderr, "%s_traced_lock_pred%s", prepend_term, append_term); + break; + + case _traced_index_pred : + fprintf(stderr, "%s_traced_index_pred%s", prepend_term, append_term); + break; + +#ifdef THREADS + case _traced_thread_local : + fprintf(stderr, "%s_traced_thread_local%s", prepend_term, append_term); + break; + +#endif + case _traced_expand_index : + fprintf(stderr, "%s_traced_expand_index%s", prepend_term, append_term); + break; + + case _traced_expand_clauses : + fprintf(stderr, "%s_traced_expand_clauses%s", prepend_term, append_term); + break; + + case _traced_undef_p : + fprintf(stderr, "%s_traced_undef_p%s", prepend_term, append_term); + break; + + case _traced_spy_pred : + fprintf(stderr, "%s_traced_spy_pred%s", prepend_term, append_term); + break; + + case _traced_try_clause : + fprintf(stderr, "%s_traced_try_clause%s", prepend_term, append_term); + break; + + case _traced_try_clause2 : + fprintf(stderr, "%s_traced_try_clause2%s", prepend_term, append_term); + break; + + case _traced_try_clause3 : + fprintf(stderr, "%s_traced_try_clause3%s", prepend_term, append_term); + break; + + case _traced_try_clause4 : + fprintf(stderr, "%s_traced_try_clause4%s", prepend_term, append_term); + break; + + case _traced_retry : + fprintf(stderr, "%s_traced_retry%s", prepend_term, append_term); + break; + + case _traced_retry2 : + fprintf(stderr, "%s_traced_retry2%s", prepend_term, append_term); + break; + + case _traced_retry3 : + fprintf(stderr, "%s_traced_retry3%s", prepend_term, append_term); + break; + + case _traced_retry4 : + fprintf(stderr, "%s_traced_retry4%s", prepend_term, append_term); + break; + + case _traced_trust : + fprintf(stderr, "%s_traced_trust%s", prepend_term, append_term); + break; + + case _traced_try_in : + fprintf(stderr, "%s_traced_try_in%s", prepend_term, append_term); + break; + + case _traced_enter_lu_pred : + fprintf(stderr, "%s_traced_enter_lu_pred%s", prepend_term, append_term); + break; + + case _traced_try_logical : + fprintf(stderr, "%s_traced_try_logical%s", prepend_term, append_term); + break; + + case _traced_retry_logical : + fprintf(stderr, "%s_traced_retry_logical%s", prepend_term, append_term); + break; + + case _traced_trust_logical : + fprintf(stderr, "%s_traced_trust_logical%s", prepend_term, append_term); + break; + + case _traced_user_switch : + fprintf(stderr, "%s_traced_user_switch%s", prepend_term, append_term); + break; + + case _traced_switch_on_type : + fprintf(stderr, "%s_traced_switch_on_type%s", prepend_term, append_term); + break; + + case _traced_switch_list_nl : + fprintf(stderr, "%s_traced_switch_list_nl%s", prepend_term, append_term); + break; + + case _traced_switch_on_arg_type : + fprintf(stderr, "%s_traced_switch_on_arg_type%s", prepend_term, append_term); + break; + + case _traced_switch_on_sub_arg_type : + fprintf(stderr, "%s_traced_switch_on_sub_arg_type%s", prepend_term, append_term); + break; + + case _traced_jump_if_var : + fprintf(stderr, "%s_traced_jump_if_var%s", prepend_term, append_term); + break; + + case _traced_jump_if_nonvar : + fprintf(stderr, "%s_traced_jump_if_nonvar%s", prepend_term, append_term); + break; + + case _traced_if_not_then : + fprintf(stderr, "%s_traced_if_not_then%s", prepend_term, append_term); + break; + + case _traced_switch_on_func : + fprintf(stderr, "%s_traced_switch_on_func%s", prepend_term, append_term); + break; + + case _traced_switch_on_cons : + fprintf(stderr, "%s_traced_switch_on_cons%s", prepend_term, append_term); + break; + + case _traced_go_on_func : + fprintf(stderr, "%s_traced_go_on_func%s", prepend_term, append_term); + break; + + case _traced_go_on_cons : + fprintf(stderr, "%s_traced_go_on_cons%s", prepend_term, append_term); + break; + + case _traced_if_func : + fprintf(stderr, "%s_traced_if_func%s", prepend_term, append_term); + break; + + case _traced_if_cons : + fprintf(stderr, "%s_traced_if_cons%s", prepend_term, append_term); + break; + + case _traced_index_dbref : + fprintf(stderr, "%s_traced_index_dbref%s", prepend_term, append_term); + break; + + case _traced_index_blob : + fprintf(stderr, "%s_traced_index_blob%s", prepend_term, append_term); + break; + + case _traced_index_long : + fprintf(stderr, "%s_traced_index_long%s", prepend_term, append_term); + break; + + case _traced_jit_handler : + fprintf(stderr, "%s_traced_jit_handler%s", prepend_term, append_term); + break; + + case _traced_p_atom_x : + fprintf(stderr, "%s_traced_p_atom_x%s", prepend_term, append_term); + break; + + case _traced_p_atom_y : + fprintf(stderr, "%s_traced_p_atom_y%s", prepend_term, append_term); + break; + + case _traced_p_atomic_x : + fprintf(stderr, "%s_traced_p_atomic_x%s", prepend_term, append_term); + break; + + case _traced_p_atomic_y : + fprintf(stderr, "%s_traced_p_atomic_y%s", prepend_term, append_term); + break; + + case _traced_p_integer_x : + fprintf(stderr, "%s_traced_p_integer_x%s", prepend_term, append_term); + break; + + case _traced_p_integer_y : + fprintf(stderr, "%s_traced_p_integer_y%s", prepend_term, append_term); + break; + + case _traced_p_nonvar_x : + fprintf(stderr, "%s_traced_p_nonvar_x%s", prepend_term, append_term); + break; + + case _traced_p_nonvar_y : + fprintf(stderr, "%s_traced_p_nonvar_y%s", prepend_term, append_term); + break; + + case _traced_p_number_x : + fprintf(stderr, "%s_traced_p_number_x%s", prepend_term, append_term); + break; + + case _traced_p_number_y : + fprintf(stderr, "%s_traced_p_number_y%s", prepend_term, append_term); + break; + + case _traced_p_var_x : + fprintf(stderr, "%s_traced_p_var_x%s", prepend_term, append_term); + break; + + case _traced_p_var_y : + fprintf(stderr, "%s_traced_p_var_y%s", prepend_term, append_term); + break; + + case _traced_p_db_ref_x : + fprintf(stderr, "%s_traced_p_db_ref_x%s", prepend_term, append_term); + break; + + case _traced_p_db_ref_y : + fprintf(stderr, "%s_traced_p_db_ref_y%s", prepend_term, append_term); + break; + + case _traced_p_primitive_x : + fprintf(stderr, "%s_traced_p_primitive_x%s", prepend_term, append_term); + break; + + case _traced_p_primitive_y : + fprintf(stderr, "%s_traced_p_primitive_y%s", prepend_term, append_term); + break; + + case _traced_p_compound_x : + fprintf(stderr, "%s_traced_p_compound_x%s", prepend_term, append_term); + break; + + case _traced_p_compound_y : + fprintf(stderr, "%s_traced_p_compound_y%s", prepend_term, append_term); + break; + + case _traced_p_float_x : + fprintf(stderr, "%s_traced_p_float_x%s", prepend_term, append_term); + break; + + case _traced_p_float_y : + fprintf(stderr, "%s_traced_p_float_y%s", prepend_term, append_term); + break; + + case _traced_p_plus_vv : + fprintf(stderr, "%s_traced_p_plus_vv%s", prepend_term, append_term); + break; + + case _traced_p_plus_vc : + fprintf(stderr, "%s_traced_p_plus_vc%s", prepend_term, append_term); + break; + + case _traced_p_plus_y_vv : + fprintf(stderr, "%s_traced_p_plus_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_plus_y_vc : + fprintf(stderr, "%s_traced_p_plus_y_vc%s", prepend_term, append_term); + break; + + case _traced_p_minus_vv : + fprintf(stderr, "%s_traced_p_minus_vv%s", prepend_term, append_term); + break; + + case _traced_p_minus_cv : + fprintf(stderr, "%s_traced_p_minus_cv%s", prepend_term, append_term); + break; + + case _traced_p_minus_y_vv : + fprintf(stderr, "%s_traced_p_minus_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_minus_y_cv : + fprintf(stderr, "%s_traced_p_minus_y_cv%s", prepend_term, append_term); + break; + + case _traced_p_times_vv : + fprintf(stderr, "%s_traced_p_times_vv%s", prepend_term, append_term); + break; + + case _traced_p_times_vc : + fprintf(stderr, "%s_traced_p_times_vc%s", prepend_term, append_term); + break; + + case _traced_p_times_y_vv : + fprintf(stderr, "%s_traced_p_times_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_times_y_vc : + fprintf(stderr, "%s_traced_p_times_y_vc%s", prepend_term, append_term); + break; + + case _traced_p_div_vv : + fprintf(stderr, "%s_traced_p_div_vv%s", prepend_term, append_term); + break; + + case _traced_p_div_vc : + fprintf(stderr, "%s_traced_p_div_vc%s", prepend_term, append_term); + break; + + case _traced_p_div_cv : + fprintf(stderr, "%s_traced_p_div_cv%s", prepend_term, append_term); + break; + + case _traced_p_div_y_vv : + fprintf(stderr, "%s_traced_p_div_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_div_y_vc : + fprintf(stderr, "%s_traced_p_div_y_vc%s", prepend_term, append_term); + break; + + case _traced_p_div_y_cv : + fprintf(stderr, "%s_traced_p_div_y_cv%s", prepend_term, append_term); + break; + + case _traced_p_and_vv : + fprintf(stderr, "%s_traced_p_and_vv%s", prepend_term, append_term); + break; + + case _traced_p_and_vc : + fprintf(stderr, "%s_traced_p_and_vc%s", prepend_term, append_term); + break; + + case _traced_p_and_y_vv : + fprintf(stderr, "%s_traced_p_and_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_and_y_vc : + fprintf(stderr, "%s_traced_p_and_y_vc%s", prepend_term, append_term); + break; + + case _traced_p_or_vv : + fprintf(stderr, "%s_traced_p_or_vv%s", prepend_term, append_term); + break; + + case _traced_p_or_vc : + fprintf(stderr, "%s_traced_p_or_vc%s", prepend_term, append_term); + break; + + case _traced_p_or_y_vv : + fprintf(stderr, "%s_traced_p_or_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_or_y_vc : + fprintf(stderr, "%s_traced_p_or_y_vc%s", prepend_term, append_term); + break; + + case _traced_p_sll_vv : + fprintf(stderr, "%s_traced_p_sll_vv%s", prepend_term, append_term); + break; + + case _traced_p_sll_vc : + fprintf(stderr, "%s_traced_p_sll_vc%s", prepend_term, append_term); + break; + + case _traced_p_sll_cv : + fprintf(stderr, "%s_traced_p_sll_cv%s", prepend_term, append_term); + break; + + case _traced_p_sll_y_vv : + fprintf(stderr, "%s_traced_p_sll_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_sll_y_vc : + fprintf(stderr, "%s_traced_p_sll_y_vc%s", prepend_term, append_term); + break; + + case _traced_p_sll_y_cv : + fprintf(stderr, "%s_traced_p_sll_y_cv%s", prepend_term, append_term); + break; + + case _traced_p_slr_vv : + fprintf(stderr, "%s_traced_p_slr_vv%s", prepend_term, append_term); + break; + + case _traced_p_slr_vc : + fprintf(stderr, "%s_traced_p_slr_vc%s", prepend_term, append_term); + break; + + case _traced_p_slr_cv : + fprintf(stderr, "%s_traced_p_slr_cv%s", prepend_term, append_term); + break; + + case _traced_p_slr_y_vv : + fprintf(stderr, "%s_traced_p_slr_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_slr_y_vc : + fprintf(stderr, "%s_traced_p_slr_y_vc%s", prepend_term, append_term); + break; + + case _traced_p_slr_y_cv : + fprintf(stderr, "%s_traced_p_slr_y_cv%s", prepend_term, append_term); + break; + + case _traced_call_bfunc_xx : + fprintf(stderr, "%s_traced_call_bfunc_xx%s", prepend_term, append_term); + break; + + case _traced_call_bfunc_yx : + fprintf(stderr, "%s_traced_call_bfunc_yx%s", prepend_term, append_term); + break; + + case _traced_call_bfunc_xy : + fprintf(stderr, "%s_traced_call_bfunc_xy%s", prepend_term, append_term); + break; + + case _traced_call_bfunc_yy : + fprintf(stderr, "%s_traced_call_bfunc_yy%s", prepend_term, append_term); + break; + + case _traced_p_equal : + fprintf(stderr, "%s_traced_p_equal%s", prepend_term, append_term); + break; + + case _traced_p_dif : + fprintf(stderr, "%s_traced_p_dif%s", prepend_term, append_term); + break; + + case _traced_p_eq : + fprintf(stderr, "%s_traced_p_eq%s", prepend_term, append_term); + break; + + case _traced_p_arg_vv : + fprintf(stderr, "%s_traced_p_arg_vv%s", prepend_term, append_term); + break; + + case _traced_p_arg_cv : + fprintf(stderr, "%s_traced_p_arg_cv%s", prepend_term, append_term); + break; + + case _traced_p_arg_y_vv : + fprintf(stderr, "%s_traced_p_arg_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_arg_y_cv : + fprintf(stderr, "%s_traced_p_arg_y_cv%s", prepend_term, append_term); + break; + + case _traced_p_func2s_vv : + fprintf(stderr, "%s_traced_p_func2s_vv%s", prepend_term, append_term); + break; + + case _traced_p_func2s_cv : + fprintf(stderr, "%s_traced_p_func2s_cv%s", prepend_term, append_term); + break; + + case _traced_p_func2s_vc : + fprintf(stderr, "%s_traced_p_func2s_vc%s", prepend_term, append_term); + break; + + case _traced_p_func2s_y_vv : + fprintf(stderr, "%s_traced_p_func2s_y_vv%s", prepend_term, append_term); + break; + + case _traced_p_func2s_y_cv : + fprintf(stderr, "%s_traced_p_func2s_y_cv%s", prepend_term, append_term); + break; + + case _traced_p_func2s_y_vc : + fprintf(stderr, "%s_traced_p_func2s_y_vc%s", prepend_term, append_term); + break; + + case _traced_p_func2f_xx : + fprintf(stderr, "%s_traced_p_func2f_xx%s", prepend_term, append_term); + break; + + case _traced_p_func2f_xy : + fprintf(stderr, "%s_traced_p_func2f_xy%s", prepend_term, append_term); + break; + + case _traced_p_func2f_yx : + fprintf(stderr, "%s_traced_p_func2f_yx%s", prepend_term, append_term); + break; + + case _traced_p_func2f_yy : + fprintf(stderr, "%s_traced_p_func2f_yy%s", prepend_term, append_term); + break; + + case _traced_p_functor : + fprintf(stderr, "%s_traced_p_functor%s", prepend_term, append_term); + break; + + case _traced_p_execute2 : + fprintf(stderr, "%s_traced_p_execute2%s", prepend_term, append_term); + break; + + case _traced_p_execute : + fprintf(stderr, "%s_traced_p_execute%s", prepend_term, append_term); + break; + + case _traced_p_execute_tail : + fprintf(stderr, "%s_traced_p_execute_tail%s", prepend_term, append_term); + break; + +#ifdef YAPOR + case _traced_getwork_first_time : + fprintf(stderr, "%s_traced_getwork_first_time%s", prepend_term, append_term); + break; + + case _traced_getwork : + fprintf(stderr, "%s_traced_getwork%s", prepend_term, append_term); + break; + + case _traced_getwork_seq : + fprintf(stderr, "%s_traced_getwork_seq%s", prepend_term, append_term); + break; + + case _traced_sync : + fprintf(stderr, "%s_traced_sync%s", prepend_term, append_term); + break; + +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _traced_clause_with_cut : + fprintf(stderr, "%s_traced_clause_with_cut%s", prepend_term, append_term); + break; + +#endif + case _traced_table_load_answer : + fprintf(stderr, "%s_traced_table_load_answer%s", prepend_term, append_term); + break; + + case _traced_table_try_answer : + fprintf(stderr, "%s_traced_table_try_answer%s", prepend_term, append_term); + break; + + case _traced_table_try_single : + fprintf(stderr, "%s_traced_table_try_single%s", prepend_term, append_term); + break; + + case _traced_table_try_me : + fprintf(stderr, "%s_traced_table_try_me%s", prepend_term, append_term); + break; + + case _traced_table_try : + fprintf(stderr, "%s_traced_table_try%s", prepend_term, append_term); + break; + + case _traced_table_retry_me : + fprintf(stderr, "%s_traced_table_retry_me%s", prepend_term, append_term); + break; + + case _traced_table_retry : + fprintf(stderr, "%s_traced_table_retry%s", prepend_term, append_term); + break; + + case _traced_table_trust_me : + fprintf(stderr, "%s_traced_table_trust_me%s", prepend_term, append_term); + break; + + case _traced_table_trust : + fprintf(stderr, "%s_traced_table_trust%s", prepend_term, append_term); + break; + + case _traced_table_new_answer : + fprintf(stderr, "%s_traced_table_new_answer%s", prepend_term, append_term); + break; + + case _traced_table_answer_resolution : + fprintf(stderr, "%s_traced_table_answer_resolution%s", prepend_term, append_term); + break; + + case _traced_table_completion : + fprintf(stderr, "%s_traced_table_completion%s", prepend_term, append_term); + break; + +#ifdef THREADS_CONSUMER_SHARING + case _traced_table_answer_resolution_completion: + fprintf(stderr, "%s_traced_table_answer_resolution_completion%s", prepend_term, append_term); + break; + +#endif + case _traced_trie_do_var : + fprintf(stderr, "%s_traced_trie_do_var%s", prepend_term, append_term); + break; + + case _traced_trie_trust_var : + fprintf(stderr, "%s_traced_trie_trust_var%s", prepend_term, append_term); + break; + + case _traced_trie_try_var : + fprintf(stderr, "%s_traced_trie_try_var%s", prepend_term, append_term); + break; + + case _traced_trie_retry_var : + fprintf(stderr, "%s_traced_trie_retry_var%s", prepend_term, append_term); + break; + + case _traced_trie_do_var_in_pair : + fprintf(stderr, "%s_traced_trie_do_var_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_trust_var_in_pair : + fprintf(stderr, "%s_traced_trie_trust_var_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_try_var_in_pair : + fprintf(stderr, "%s_traced_trie_try_var_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_retry_var_in_pair : + fprintf(stderr, "%s_traced_trie_retry_var_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_do_val : + fprintf(stderr, "%s_traced_trie_do_val%s", prepend_term, append_term); + break; + + case _traced_trie_trust_val : + fprintf(stderr, "%s_traced_trie_trust_val%s", prepend_term, append_term); + break; + + case _traced_trie_try_val : + fprintf(stderr, "%s_traced_trie_try_val%s", prepend_term, append_term); + break; + + case _traced_trie_retry_val : + fprintf(stderr, "%s_traced_trie_retry_val%s", prepend_term, append_term); + break; + + case _traced_trie_do_val_in_pair : + fprintf(stderr, "%s_traced_trie_do_val_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_trust_val_in_pair : + fprintf(stderr, "%s_traced_trie_trust_val_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_try_val_in_pair : + fprintf(stderr, "%s_traced_trie_try_val_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_retry_val_in_pair : + fprintf(stderr, "%s_traced_trie_retry_val_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_do_atom : + fprintf(stderr, "%s_traced_trie_do_atom%s", prepend_term, append_term); + break; + + case _traced_trie_trust_atom : + fprintf(stderr, "%s_traced_trie_trust_atom%s", prepend_term, append_term); + break; + + case _traced_trie_try_atom : + fprintf(stderr, "%s_traced_trie_try_atom%s", prepend_term, append_term); + break; + + case _traced_trie_retry_atom : + fprintf(stderr, "%s_traced_trie_retry_atom%s", prepend_term, append_term); + break; + + case _traced_trie_do_atom_in_pair : + fprintf(stderr, "%s_traced_trie_do_atom_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_trust_atom_in_pair : + fprintf(stderr, "%s_traced_trie_trust_atom_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_try_atom_in_pair : + fprintf(stderr, "%s_traced_trie_try_atom_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_retry_atom_in_pair : + fprintf(stderr, "%s_traced_trie_retry_atom_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_do_null : + fprintf(stderr, "%s_traced_trie_do_null%s", prepend_term, append_term); + break; + + case _traced_trie_trust_null : + fprintf(stderr, "%s_traced_trie_trust_null%s", prepend_term, append_term); + break; + + case _traced_trie_try_null : + fprintf(stderr, "%s_traced_trie_try_null%s", prepend_term, append_term); + break; + + case _traced_trie_retry_null : + fprintf(stderr, "%s_traced_trie_retry_null%s", prepend_term, append_term); + break; + + case _traced_trie_do_null_in_pair : + fprintf(stderr, "%s_traced_trie_do_null_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_trust_null_in_pair : + fprintf(stderr, "%s_traced_trie_trust_null_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_try_null_in_pair : + fprintf(stderr, "%s_traced_tri_try_null_in_paire%s", prepend_term, append_term); + break; + + case _traced_trie_retry_null_in_pair : + fprintf(stderr, "%s_traced_trie_retry_null_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_do_pair : + fprintf(stderr, "%s_traced_trie_do_pair%s", prepend_term, append_term); + break; + + case _traced_trie_trust_pair : + fprintf(stderr, "%s_traced_trie_trust_pair%s", prepend_term, append_term); + break; + + case _traced_trie_try_pair : + fprintf(stderr, "%s_traced_trie_try_pair%s", prepend_term, append_term); + break; + + case _traced_trie_retry_pair : + fprintf(stderr, "%s_traced_trie_retry_pair%s", prepend_term, append_term); + break; + + case _traced_trie_do_appl : + fprintf(stderr, "%s_traced_trie_do_appl%s", prepend_term, append_term); + break; + + case _traced_trie_trust_appl : + fprintf(stderr, "%s_traced_trie_trust_appl%s", prepend_term, append_term); + break; + + case _traced_trie_try_appl : + fprintf(stderr, "%s_traced_trie_try_appl%s", prepend_term, append_term); + break; + + case _traced_trie_retry_appl : + fprintf(stderr, "%s_traced_trie_retry_appl%s", prepend_term, append_term); + break; + + case _traced_trie_do_appl_in_pair : + fprintf(stderr, "%s_traced_trie_do_appl_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_trust_appl_in_pair : + fprintf(stderr, "%s_traced_trie_trust_appl_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_try_appl_in_pair : + fprintf(stderr, "%s_traced_trie_trty_appkl_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_retry_appl_in_pair : + fprintf(stderr, "%s_traced_trie_retry_appl_in_pair%s", prepend_term, append_term); + break; + + case _traced_trie_do_extension : + fprintf(stderr, "%s_traced_trie_do_extension%s", prepend_term, append_term); + break; + + case _traced_trie_trust_extension : + fprintf(stderr, "%s_traced_trie_trust_extension%s", prepend_term, append_term); + break; + + case _traced_trie_try_extension : + fprintf(stderr, "%s_traced_trie_try_extension%s", prepend_term, append_term); + break; + + case _traced_trie_retry_extension : + fprintf(stderr, "%s_traced_trie_retry_extension%s", prepend_term, append_term); + break; + + case _traced_trie_do_double : + fprintf(stderr, "%s_traced_trie_do_double%s", prepend_term, append_term); + break; + + case _traced_trie_trust_double : + fprintf(stderr, "%s_traced_trie_trust_double%s", prepend_term, append_term); + break; + + case _traced_trie_try_double : + fprintf(stderr, "%s_traced_trie_try_double%s", prepend_term, append_term); + break; + + case _traced_trie_retry_double : + fprintf(stderr, "%s_traced_trie_retry_double%s", prepend_term, append_term); + break; + + case _traced_trie_do_longint : + fprintf(stderr, "%s_traced_trie_do_longint%s", prepend_term, append_term); + break; + + case _traced_trie_trust_longint : + fprintf(stderr, "%s_traced_trie_trust_longint%s", prepend_term, append_term); + break; + + case _traced_trie_try_longint : + fprintf(stderr, "%s_traced_trie_try_longint%s", prepend_term, append_term); + break; + + case _traced_trie_retry_longint : + fprintf(stderr, "%s_traced_trie_retry_longint%s", prepend_term, append_term); + break; + + case _traced_trie_do_gterm : + fprintf(stderr, "%s_traced_trie_do_gterm%s", prepend_term, append_term); + break; + + case _traced_trie_trust_gterm : + fprintf(stderr, "%s_traced_trie_trust_gterm%s", prepend_term, append_term); + break; + + case _traced_trie_try_gterm : + fprintf(stderr, "%s_traced_trie_try_gterm%s", prepend_term, append_term); + break; + + case _traced_trie_retry_gterm : + fprintf(stderr, "%s_traced_trie_retry_gterm%s", prepend_term, append_term); + break; + +#endif + /* this instruction is hardwired */ +#ifdef YAPOR + case _traced_or_last : + fprintf(stderr, "%s_traced_or_last%s", prepend_term, append_term); + break; +#else + case _traced_or_last : + fprintf(stderr, "%s_traced_or_last%s", prepend_term, append_term); + break; +#endif + +#endif /* YAP_JIT */ + } + } + +void print_nop(op_numbers); + +void +print_nop(op_numbers op) { + print_op("", op, "\n"); +} diff --git a/JIT/HPP/print_preg.h b/JIT/HPP/print_preg.h new file mode 100644 index 000000000..ec191ea15 --- /dev/null +++ b/JIT/HPP/print_preg.h @@ -0,0 +1,3959 @@ +void print_preg(yamop*); + +void +print_preg(yamop* _p) { + op_numbers op; + while( (op = Yap_op_from_opcode(_p->opc)) ){ +// printf("%p -- ", _p); + switch(op){ + case _Ystop : + printf("_Ystop!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _Nstop : + printf("_Nstop!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _try_me : + printf("_try_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _retry_me : + printf("_retry_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _trust_me : + printf("_trust_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _enter_profiling : + printf("_enter_profiling!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _retry_profiled : + printf("_retry_profiled!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _profiled_retry_me : + printf("_profiled_retry_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _profiled_trust_me : + printf("_profiled_trust_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _profiled_retry_logical : + printf("_profiled_retry_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + + case _profiled_trust_logical : + printf("_profiled_trust_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + + case _count_call : + printf("_count_call!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _count_retry : + printf("_count_retry!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _count_retry_me : + printf("_count_retry_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _count_trust_me : + printf("_count_trust_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _count_retry_logical : + printf("_count_retry_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + + case _count_trust_logical : + printf("_count_trust_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + + case _lock_lu : + printf("_lock_lu!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _unlock_lu : + printf("_unlock_lu!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _alloc_for_logical_pred : + printf("_alloc_for_logical_pred!!\n"); + _p = ((yamop *)(&((_p)->u.L.next))); + break; + + case _copy_idb_term : + printf("_copy_idb_term!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _unify_idb_term : + printf("_unify_idb_term!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _ensure_space : + printf("_ensure_space!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpa.next))); + break; + + case _spy_or_trymark : + printf("_spy_or_trymark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _try_and_mark : + printf("_try_and_mark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _count_retry_and_mark : + printf("_count_retry_and_mark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _profiled_retry_and_mark : + printf("_profiled_retry_and_mark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _retry_and_mark : + printf("_retry_and_mark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _trust_fail : + printf("_trust_fail!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _op_fail : + printf("_op_fail!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _cut : + printf("_cut!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _cut_t : + printf("_cut_t!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _cut_e : + printf("_cut_e!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _save_b_x : + printf("_save_b_x!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _save_b_y : + printf("_save_b_y!!\n"); + _p = ((yamop *)(&((_p)->u.y.next))); + break; + + case _commit_b_x : + printf("_commit_b_x!!\n"); + _p = ((yamop *)(&((_p)->u.xps.next))); + break; + + case _commit_b_y : + printf("_commit_b_y!!\n"); + _p = ((yamop *)(&((_p)->u.yps.next))); + break; + + case _execute : + printf("_execute!!\n"); + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + + case _dexecute : + printf("_dexecute!!\n"); + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + + case _fcall : + printf("_fcall!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _call : + printf("_call!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _procceed : + printf("_procceed!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _allocate : + printf("_allocate!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _deallocate : + printf("_deallocate!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + +#ifdef BEAM + case _retry_eam : + printf("_retry_eam!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#endif +#ifdef BEAM + case _run_eam : + printf("_run_eam!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + +#endif + case _get_x_var : + printf("_get_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _get_y_var : + printf("_get_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _get_yy_var : + printf("_get_yy_var!!\n"); + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + + case _get_x_val : + printf("_get_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _get_y_val : + printf("_get_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _get_atom : + printf("_get_atom!!\n"); + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + + case _get_2atoms : + printf("_get_2atoms!!\n"); + _p = ((yamop *)(&((_p)->u.cc.next))); + break; + + case _get_3atoms : + printf("_get_3atoms!!\n"); + _p = ((yamop *)(&((_p)->u.ccc.next))); + break; + + case _get_4atoms : + printf("_get_4atoms!!\n"); + _p = ((yamop *)(&((_p)->u.cccc.next))); + break; + + case _get_5atoms : + printf("_get_5atoms!!\n"); + _p = ((yamop *)(&((_p)->u.ccccc.next))); + break; + + case _get_6atoms : + printf("_get_6atoms!!\n"); + _p = ((yamop *)(&((_p)->u.cccccc.next))); + break; + + case _get_list : + printf("_get_list!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _get_struct : + printf("_get_struct!!\n"); + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + + case _get_float : + printf("_get_float!!\n"); + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + + case _get_longint : + printf("_get_longint!!\n"); + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + + case _get_bigint : + printf("_get_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + + case _get_dbterm : + printf("_get_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + + case _glist_valx : + printf("_glist_valx!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _glist_valy : + printf("_glist_valy!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _gl_void_varx : + printf("_gl_void_varx!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _gl_void_vary : + printf("_gl_void_vary!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _gl_void_valx : + printf("_gl_void_valx!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _gl_void_valy : + printf("_gl_void_valy!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _unify_x_var : + printf("_unify_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_x_var_write : + printf("_unify_x_var_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_l_x_var : + printf("_unify_l_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_l_x_var_write : + printf("_unify_l_x_var_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_x_var2 : + printf("_unify_x_var2!!\n"); + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + + case _unify_x_var2_write : + printf("_unify_x_var2_write!!\n"); + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + + case _unify_l_x_var2 : + printf("_unify_l_x_var2!!\n"); + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + + case _unify_l_x_var2_write : + printf("_unify_l_x_var2_write!!\n"); + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + + case _unify_y_var : + printf("_unify_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_y_var_write : + printf("_unify_y_var_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_l_y_var : + printf("_unify_l_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_l_y_var_write : + printf("_unify_l_y_var_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_x_val : + printf("_unify_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_x_val_write : + printf("_unify_x_val_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_l_x_val : + printf("_unify_l_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_l_x_val_write : + printf("_uify_l_x_val_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_y_val : + printf("_unify_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_y_val_write : + printf("_unify_y_val_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_l_y_val : + printf("_unify_l_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_l_y_val_write : + printf("_unify_l_y_val_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_x_loc : + printf("_unify_x_loc!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_x_loc_write : + printf("_unify_x_loc_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_l_x_loc : + printf("_unify_l_x_loc!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_l_x_loc_write : + printf("_unify_l_x_loc_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _unify_y_loc : + printf("_unify_y_loc!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_y_loc_write : + printf("_unify_y_loc_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_l_y_loc : + printf("_unify_l_y_loc!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_l_y_loc_write : + printf("_unify_l_y_loc_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _unify_void : + printf("_unify_void!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _unify_void_write : + printf("_unify_void_write!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _unify_l_void : + printf("_unify_l_void!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _unify_l_void_write : + printf("_unify_l_void_write!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _unify_n_voids : + printf("_unify_n_voids!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + + case _unify_n_voids_write : + printf("_unify_n_voids_write!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + + case _unify_l_n_voids : + printf("_unify_l_n_voids!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + + case _unify_l_n_voids_write : + printf("_unify_l_n_voids_write!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + + case _unify_atom : + printf("_unify_atom!!\n"); + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + + case _unify_atom_write : + printf("_unify_atom_write!!\n"); + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + + case _unify_l_atom : + printf("_unify_l_atom!!\n"); + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + + case _unify_l_atom_write : + printf("_unify_l_atom_write!!\n"); + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + + case _unify_n_atoms : + printf("_unify_n_atoms!!\n"); + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + + case _unify_n_atoms_write : + printf("_unify_n_atoms_write!!\n"); + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + + case _unify_float : + printf("_unify_float!!\n"); + _p = ((yamop *)(&((_p)->u.od.next))); + break; + + case _unify_float_write : + printf("_unify_float_write!!\n"); + _p = ((yamop *)(&((_p)->u.od.next))); + break; + + case _unify_l_float : + printf("_unify_l_float!!\n"); + _p = ((yamop *)(&((_p)->u.od.next))); + break; + + case _unify_l_float_write : + printf("_unify_l_float_write!!\n"); + _p = ((yamop *)(&((_p)->u.od.next))); + break; + + case _unify_longint : + printf("_unify_longint!!\n"); + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + + case _unify_longint_write : + printf("_unify_longint_write!!\n"); + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + + case _unify_l_longint : + printf("_unify_l_longint!!\n"); + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + + case _unify_l_longint_write : + printf("_unify_l_longint_write!!\n"); + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + + case _unify_bigint : + printf("_unify_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + + case _unify_l_bigint : + printf("_unify_l_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + + case _unify_dbterm : + printf("_unify_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + + case _unify_l_dbterm : + printf("_unify_l_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + + case _unify_list : + printf("_unify_list!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _unify_list_write : + printf("_unify_list_write!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _unify_l_list : + printf("_unify_l_list!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _unify_l_list_write : + printf("_unify_l_list_write!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _unify_struct : + printf("_unify_struct!!\n"); + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + + case _unify_struct_write : + printf("_unify_struct_write!!\n"); + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + + case _unify_l_struc : + printf("_unify_l_struc!!\n"); + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + + case _unify_l_struc_write : + printf("_unify_l_struc_write!!\n"); + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + + case _put_x_var : + printf("_put_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _put_y_var : + printf("_put_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _put_x_val : + printf("_put_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _put_xx_val : + printf("_put_xx_val!!\n"); + _p = ((yamop *)(&((_p)->u.xxxx.next))); + break; + + case _put_y_val : + printf("_put_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _put_y_vals : + printf("_put_y_vals!!\n"); + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + + case _put_unsafe : + printf("_put_unsafe!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _put_atom : + printf("_put_atom!!\n"); + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + + case _put_dbterm : + printf("_put_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + + case _put_bigint : + printf("_put_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + + case _put_float : + printf("_put_float!!\n"); + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + + case _put_longint : + printf("_put_longint!!\n"); + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + + case _put_list : + printf("_put_list!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _put_struct : + printf("_put_struct!!\n"); + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + + case _write_x_var : + printf("_write_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _write_void : + printf("_write_void!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _write_n_voids : + printf("_write_n_voids!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _write_y_var : + printf("_write_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.y.next))); + break; + + case _write_x_val : + printf("_write_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _write_x_loc : + printf("_write_x_loc!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _write_y_val : + printf("_write_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.y.next))); + break; + + case _write_y_loc : + printf("_write_y_loc!!\n"); + _p = ((yamop *)(&((_p)->u.y.next))); + break; + + case _write_atom : + printf("_write_atom!!\n"); + _p = ((yamop *)(&((_p)->u.c.next))); + break; + + case _write_bigint : + printf("_write_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.N.next))); + break; + + case _write_dbterm : + printf("_write_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.D.next))); + break; + + case _write_float : + printf("_write_float!!\n"); + _p = ((yamop *)(&((_p)->u.d.next))); + break; + + case _write_longint : + printf("_write_longint!!\n"); + _p = ((yamop *)(&((_p)->u.i.next))); + break; + + case _write_n_atoms : + printf("_write_n_atoms!!\n"); + _p = ((yamop *)(&((_p)->u.sc.next))); + break; + + case _write_list : + printf("_write_list!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _write_l_list : + printf("_write_l_list!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _write_struct : + printf("_write_struct!!\n"); + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + + case _write_l_struc : + printf("_write_l_struc!!\n"); + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + + case _save_pair_x : + printf("_save_pair_x!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _save_pair_x_write : + printf("_save_pair_x_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _save_pair_y : + printf("_save_pair_y!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _save_pair_y_write : + printf("_save_pair_y_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _save_appl_x : + printf("_save_appl_x!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _save_appl_x_write : + printf("_save_appl_x_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _save_appl_y : + printf("_save_appl_y!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _save_appl_y_write : + printf("_save_appl_y_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _jump : + printf("_jump!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _move_back : + printf("_move_back!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _skip : + printf("_skip!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _either : + printf("_either!!\n"); + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + + case _or_else : + printf("_or_else!!\n"); + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + + case _pop_n : + printf("_pop_n!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _pop : + printf("_pop!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _call_cpred : + printf("_call_cpred!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _execute_cpred : + printf("_execute_cpred!!\n"); + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + + case _call_usercpred : + printf("_call_usercpred!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _call_c_wfail : + printf("_call_x_wfail!!\n"); + _p = ((yamop *)(&((_p)->u.slp.next))); + break; + + case _try_c : + printf("_try_c!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + + case _retry_c : + printf("_retry_c!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + +#ifdef CUT_C + case _cut_c : + printf("_cut_c!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + +#endif + case _try_userc : + printf("_try_userc!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + + case _retry_userc : + printf("_retry_userc!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + +#ifdef CUT_C + case _cut_userc : + printf("_cut_userc!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + +#endif + case _lock_pred : + printf("_lock_pred!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _index_pred : + printf("_index_pred!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#ifdef THREADS + case _thread_local : + printf("_thread_local!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#endif + case _expand_index : + printf("_expand_index!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _expand_clauses : + printf("_expand_clauses!!\n"); + _p = ((yamop *)(&((_p)->u.sssllp.next))); + break; + + case _undef_p : + printf("_undef_p!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _spy_pred : + printf("_spy_pred!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _try_clause : + printf("_try_clause!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _try_clause2 : + printf("_try_clause2!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _try_clause3 : + printf("_try_clause3!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _try_clause4 : + printf("_try_clause4!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _retry : + printf("_retry!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _retry2 : + printf("_retry2!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _retry3 : + printf("_retry3!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _retry4 : + printf("_retry4!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _trust : + printf("_trust!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _try_in : + printf("_try_in!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _enter_lu_pred : + printf("_enter_lu_pred!!\n"); + _p = ((yamop *)(&((_p)->u.Illss.next))); + break; + + case _try_logical : + printf("_try_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + + case _retry_logical : + printf("_retry_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + + case _trust_logical : + printf("_trust_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + + case _user_switch : + printf("_user_switch!!\n"); + _p = ((yamop *)(&((_p)->u.lp.next))); + break; + + case _switch_on_type : + printf("_switch_on_type!!\n"); + _p = ((yamop *)(&((_p)->u.llll.next))); + break; + + case _switch_list_nl : + printf("_switch_list_nl!!\n"); + _p = ((yamop *)(&((_p)->u.ollll.next))); + break; + + case _switch_on_arg_type : + printf("_switch_on_arg_type!!\n"); + _p = ((yamop *)(&((_p)->u.xllll.next))); + break; + + case _switch_on_sub_arg_type : + printf("_switch_on_sub_arg_type!!\n"); + _p = ((yamop *)(&((_p)->u.sllll.next))); + break; + + case _jump_if_var : + printf("_jump_if_var!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _jump_if_nonvar : + printf("_jump_if_nonvar!!\n"); + _p = ((yamop *)(&((_p)->u.xll.next))); + break; + + case _if_not_then : + printf("_if_not_then!!\n"); + _p = ((yamop *)(&((_p)->u.clll.next))); + break; + + case _switch_on_func : + printf("_switch_on_func!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _switch_on_cons : + printf("_switch_on_cons!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _go_on_func : + printf("_go_on_func!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _go_on_cons : + printf("_go_on_cons!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _if_func : + printf("_if_func!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _if_cons : + printf("_if_cons!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _index_dbref : + printf("_index_dbref!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _index_blob : + printf("_index_blob!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _index_long : + printf("_index_long!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#if YAP_JIT + case _jit_handler : + printf("_jit_handler!!\n"); + _p = ((yamop *)(&((_p)->u.jhc.next))); + break; +#endif + + case _p_atom_x : + printf("_p_atom_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_atom_y : + printf("_p_atom_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_atomic_x : + printf("_p_atomic_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_atomic_y : + printf("_p_atomic_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_integer_x : + printf("_p_integer_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_integer_y : + printf("_p_integer_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_nonvar_x : + printf("_p_nonvar_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_nonvar_y : + printf("_p_nonvar_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_number_x : + printf("_p_number_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_number_y : + printf("_p_number_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_var_x : + printf("_p_var_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_var_y : + printf("_p_var_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_db_ref_x : + printf("_p_db_ref_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_db_ref_y : + printf("_p_db_ref_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_primitive_x : + printf("_p_primitive_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_primitive_y : + printf("_p_primitive_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_compound_x : + printf("_p_compound_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_compound_y : + printf("_p_compound_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_float_x : + printf("_p_float_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _p_float_y : + printf("_p_float_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _p_plus_vv : + printf("_p_plus_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_plus_vc : + printf("_p_plus_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_plus_y_vv : + printf("_p_plus_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_plus_y_vc : + printf("_p_plus_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_minus_vv : + printf("_p_minus_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_minus_cv : + printf("_p_minus_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_minus_y_vv : + printf("_p_minus_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_minus_y_cv : + printf("_p_minus_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_times_vv : + printf("_p_times_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_times_vc : + printf("_p_times_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_times_y_vv : + printf("_p_times_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_times_y_vc : + printf("_p_times_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_div_vv : + printf("_p_div_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_div_vc : + printf("_p_div_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_div_cv : + printf("_p_div_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_div_y_vv : + printf("_p_div_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_div_y_vc : + printf("_p_div_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_div_y_cv : + printf("_p_div_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_and_vv : + printf("_p_and_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_and_vc : + printf("_p_and_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_and_y_vv : + printf("_p_and_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_and_y_vc : + printf("_p_and_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_or_vv : + printf("_p_or_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_or_vc : + printf("_p_or_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_or_y_vv : + printf("_p_or_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_or_y_vc : + printf("_p_or_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_sll_vv : + printf("_p_sll_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_sll_vc : + printf("_p_sll_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_sll_cv : + printf("_p_sll_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_sll_y_vv : + printf("_p_sll_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_sll_y_vc : + printf("_p_sll_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_sll_y_cv : + printf("_p_sll_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_slr_vv : + printf("_p_slr_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_slr_vc : + printf("_p_slr_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_slr_cv : + printf("_p_slr_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_slr_y_vv : + printf("_p_slr_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_slr_y_vc : + printf("_p_slr_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_slr_y_cv : + printf("_p_slr_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _call_bfunc_xx : + printf("_call_bfunc_xx!!\n"); + _p = ((yamop *)(&((_p)->u.plxxs.next))); + break; + + case _call_bfunc_yx : + printf("_call_bfunc_yx!!\n"); + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + + case _call_bfunc_xy : + printf("_call_bfunc_xy!!\n"); + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + + case _call_bfunc_yy : + printf("_call_bfunc_yy!!\n"); + _p = ((yamop *)(&((_p)->u.plyys.next))); + break; + + case _p_equal : + printf("_p_equal!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _p_dif : + printf("_p_dif!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _p_eq : + printf("_p_eq!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _p_arg_vv : + printf("_p_arg_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_arg_cv : + printf("_p_arg_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_arg_y_vv : + printf("_p_arg_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_arg_y_cv : + printf("_p_arg_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_func2s_vv : + printf("_p_func2s_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_func2s_cv : + printf("_p_func2s_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxc.next))); + break; + + case _p_func2s_vc : + printf("_p_func2s_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _p_func2s_y_vv : + printf("_p_func2s_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_func2s_y_cv : + printf("_p_func2s_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_func2s_y_vc : + printf("_p_func2s_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _p_func2f_xx : + printf("_p_func2f_xx!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _p_func2f_xy : + printf("_p_func2f_xy!!\n"); + _p = ((yamop *)(&((_p)->u.xxy.next))); + break; + + case _p_func2f_yx : + printf("_p_func2f_yx!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _p_func2f_yy : + printf("_p_func2f_yy!!\n"); + _p = ((yamop *)(&((_p)->u.yyx.next))); + break; + + case _p_functor : + printf("_p_functor!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _p_execute2 : + printf("_p_execute2!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _p_execute : + printf("_p_execute!!\n"); + _p = ((yamop *)(&((_p)->u.Osbmp.next))); + break; + + case _p_execute_tail : + printf("_p_execute_tail!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + +#ifdef YAPOR + case _getwork_first_time : + printf("_getwork_first_time!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _getwork : + printf("_getwork!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _getwork_seq : + printf("_getwork_seq!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _sync : + printf("_sync!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _clause_with_cut : + printf("_clause_with_cut!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#endif + case _table_load_answer : + printf("_table_load_answer!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_try_answer : + printf("_table_try_answer!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_try_single : + printf("_table_try_single!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_try_me : + printf("_table_try_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_try : + printf("_table_try!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_retry_me : + printf("_table_retry_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_retry : + printf("_table_retry!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_trust_me : + printf("_table_trust_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_trust : + printf("_table_trust!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_new_answer : + printf("_table_new_answer!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _table_answer_resolution : + printf("_table_answer_resolution!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _table_completion : + printf("_table_completion!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + +#ifdef THREADS_CONSUMER_SHARING + case _table_answer_resolution_completion: + printf("_table_answer_resolution_completion!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + +#endif + case _trie_do_var : + printf("_trie_do_var!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_var : + printf("_trie_trust_var!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_var : + printf("_trie_try_var!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_var : + printf("_trie_retry_var!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_var_in_pair : + printf("_trie_do_var_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_var_in_pair : + printf("_trie_trust_var_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_var_in_pair : + printf("_trie_try_var_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_var_in_pair : + printf("_trie_retry_var_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_val : + printf("_trie_do_val!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_val : + printf("_trie_trust_val!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_val : + printf("_trie_try_val!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_val : + printf("_trie_retry_val!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_val_in_pair : + printf("_trie_do_val_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_val_in_pair : + printf("_trie_trust_val_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_val_in_pair : + printf("_trie_try_val_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_val_in_pair : + printf("_trie_retry_val_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_atom : + printf("_trie_do_atom!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_atom : + printf("_trie_trust_atom!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_atom : + printf("_trie_try_atom!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_atom : + printf("_trie_retry_atom!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_atom_in_pair : + printf("_trie_do_atom_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_atom_in_pair : + printf("_trie_trust_atom_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_atom_in_pair : + printf("_trie_try_atom_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_atom_in_pair : + printf("_trie_retry_atom_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_null : + printf("_trie_do_null!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_null : + printf("_trie_trust_null!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_null : + printf("_trie_try_null!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_null : + printf("_trie_retry_null!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_null_in_pair : + printf("_trie_do_null_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_null_in_pair : + printf("_trie_trust_null_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_null_in_pair : + printf("_tri_try_null_in_paire!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_null_in_pair : + printf("_trie_retry_null_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_pair : + printf("_trie_do_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_pair : + printf("_trie_trust_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_pair : + printf("_trie_try_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_pair : + printf("_trie_retry_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_appl : + printf("_trie_do_appl!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_appl : + printf("_trie_trust_appl!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_appl : + printf("_trie_try_appl!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_appl : + printf("_trie_retry_appl!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_appl_in_pair : + printf("_trie_do_appl_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_appl_in_pair : + printf("_trie_trust_appl_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_appl_in_pair : + printf("_trie_trty_appkl_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_appl_in_pair : + printf("_trie_retry_appl_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_extension : + printf("_trie_do_extension!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_extension : + printf("_trie_trust_extension!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_extension : + printf("_trie_try_extension!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_extension : + printf("_trie_retry_extension!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_double : + printf("_trie_do_double!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_double : + printf("_trie_trust_double!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_double : + printf("_trie_try_double!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_double : + printf("_trie_retry_double!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_longint : + printf("_trie_do_longint!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_longint : + printf("_trie_trust_longint!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_longint : + printf("_trie_try_longint!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_longint : + printf("_trie_retry_longint!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_do_gterm : + printf("_trie_do_gterm!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_trust_gterm : + printf("_trie_trust_gterm!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_try_gterm : + printf("_trie_try_gterm!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _trie_retry_gterm : + printf("_trie_retry_gterm!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#endif + /* this instruction is hardwired */ +#ifdef YAPOR + case _or_last : + printf("_or_last!!\n"); + _p = ((yamop *)(&((_p)->u.sblp.next))); + break; + +#else + case _or_last : + printf("_or_last!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + +#endif +#if YAP_JIT + case _traced_Ystop : + printf("_Ystop!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_Nstop : + printf("_Nstop!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_try_me : + printf("_try_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_retry_me : + printf("_retry_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_trust_me : + printf("_trust_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_enter_profiling : + printf("_enter_profiling!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _traced_retry_profiled : + printf("_retry_profiled!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _traced_profiled_retry_me : + printf("_profiled_retry_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_profiled_trust_me : + printf("_profiled_trust_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_profiled_retry_logical : + printf("_profiled_retry_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + + case _traced_profiled_trust_logical : + printf("_profiled_trust_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + + case _traced_count_call : + printf("_count_call!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _traced_count_retry : + printf("_count_retry!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _traced_count_retry_me : + printf("_count_retry_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_count_trust_me : + printf("_count_trust_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_count_retry_logical : + printf("_count_retry_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + + case _traced_count_trust_logical : + printf("_count_trust_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + + case _traced_lock_lu : + printf("_lock_lu!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _traced_unlock_lu : + printf("_unlock_lu!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_alloc_for_logical_pred : + printf("_alloc_for_logical_pred!!\n"); + _p = ((yamop *)(&((_p)->u.L.next))); + break; + + case _traced_copy_idb_term : + printf("_copy_idb_term!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_unify_idb_term : + printf("_unify_idb_term!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_ensure_space : + printf("_ensure_space!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpa.next))); + break; + + case _traced_spy_or_trymark : + printf("_spy_or_trymark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_try_and_mark : + printf("_try_and_mark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_count_retry_and_mark : + printf("_count_retry_and_mark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_profiled_retry_and_mark : + printf("_profiled_retry_and_mark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_retry_and_mark : + printf("_retry_and_mark!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_trust_fail : + printf("_trust_fail!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_op_fail : + printf("_op_fail!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_cut : + printf("_cut!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _traced_cut_t : + printf("_cut_t!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _traced_cut_e : + printf("_cut_e!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _traced_save_b_x : + printf("_save_b_x!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _traced_save_b_y : + printf("_save_b_y!!\n"); + _p = ((yamop *)(&((_p)->u.y.next))); + break; + + case _traced_commit_b_x : + printf("_commit_b_x!!\n"); + _p = ((yamop *)(&((_p)->u.xps.next))); + break; + + case _traced_commit_b_y : + printf("_commit_b_y!!\n"); + _p = ((yamop *)(&((_p)->u.yps.next))); + break; + + case _traced_execute : + printf("_execute!!\n"); + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + + case _traced_dexecute : + printf("_dexecute!!\n"); + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + + case _traced_fcall : + printf("_fcall!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _traced_call : + printf("_call!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _traced_procceed : + printf("_procceed!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + + case _traced_allocate : + printf("_allocate!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_deallocate : + printf("_deallocate!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; + +#ifdef BEAM + case _traced_retry_eam : + printf("_retry_eam!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#endif +#ifdef BEAM + case _traced_run_eam : + printf("_run_eam!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + +#endif + case _traced_get_x_var : + printf("_get_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _traced_get_y_var : + printf("_get_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _traced_get_yy_var : + printf("_get_yy_var!!\n"); + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + + case _traced_get_x_val : + printf("_get_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _traced_get_y_val : + printf("_get_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _traced_get_atom : + printf("_get_atom!!\n"); + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + + case _traced_get_2atoms : + printf("_get_2atoms!!\n"); + _p = ((yamop *)(&((_p)->u.cc.next))); + break; + + case _traced_get_3atoms : + printf("_get_3atoms!!\n"); + _p = ((yamop *)(&((_p)->u.ccc.next))); + break; + + case _traced_get_4atoms : + printf("_get_4atoms!!\n"); + _p = ((yamop *)(&((_p)->u.cccc.next))); + break; + + case _traced_get_5atoms : + printf("_get_5atoms!!\n"); + _p = ((yamop *)(&((_p)->u.ccccc.next))); + break; + + case _traced_get_6atoms : + printf("_get_6atoms!!\n"); + _p = ((yamop *)(&((_p)->u.cccccc.next))); + break; + + case _traced_get_list : + printf("_get_list!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _traced_get_struct : + printf("_get_struct!!\n"); + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + + case _traced_get_float : + printf("_get_float!!\n"); + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + + case _traced_get_longint : + printf("_get_longint!!\n"); + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + + case _traced_get_bigint : + printf("_get_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + + case _traced_get_dbterm : + printf("_get_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + + case _traced_glist_valx : + printf("_glist_valx!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _traced_glist_valy : + printf("_glist_valy!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _traced_gl_void_varx : + printf("_gl_void_varx!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _traced_gl_void_vary : + printf("_gl_void_vary!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _traced_gl_void_valx : + printf("_gl_void_valx!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _traced_gl_void_valy : + printf("_gl_void_valy!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _traced_unify_x_var : + printf("_unify_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_x_var_write : + printf("_unify_x_var_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_l_x_var : + printf("_unify_l_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_l_x_var_write : + printf("_unify_l_x_var_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_x_var2 : + printf("_unify_x_var2!!\n"); + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + + case _traced_unify_x_var2_write : + printf("_unify_x_var2_write!!\n"); + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + + case _traced_unify_l_x_var2 : + printf("_unify_l_x_var2!!\n"); + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + + case _traced_unify_l_x_var2_write : + printf("_unify_l_x_var2_write!!\n"); + _p = ((yamop *)(&((_p)->u.oxx.next))); + break; + + case _traced_unify_y_var : + printf("_unify_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_y_var_write : + printf("_unify_y_var_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_l_y_var : + printf("_unify_l_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_l_y_var_write : + printf("_unify_l_y_var_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_x_val : + printf("_unify_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_x_val_write : + printf("_unify_x_val_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_l_x_val : + printf("_unify_l_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_l_x_val_write : + printf("_uify_l_x_val_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_y_val : + printf("_unify_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_y_val_write : + printf("_unify_y_val_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_l_y_val : + printf("_unify_l_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_l_y_val_write : + printf("_unify_l_y_val_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_x_loc : + printf("_unify_x_loc!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_x_loc_write : + printf("_unify_x_loc_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_l_x_loc : + printf("_unify_l_x_loc!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_l_x_loc_write : + printf("_unify_l_x_loc_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_unify_y_loc : + printf("_unify_y_loc!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_y_loc_write : + printf("_unify_y_loc_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_l_y_loc : + printf("_unify_l_y_loc!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_l_y_loc_write : + printf("_unify_l_y_loc_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_unify_void : + printf("_unify_void!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _traced_unify_void_write : + printf("_unify_void_write!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _traced_unify_l_void : + printf("_unify_l_void!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _traced_unify_l_void_write : + printf("_unify_l_void_write!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _traced_unify_n_voids : + printf("_unify_n_voids!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + + case _traced_unify_n_voids_write : + printf("_unify_n_voids_write!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + + case _traced_unify_l_n_voids : + printf("_unify_l_n_voids!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + + case _traced_unify_l_n_voids_write : + printf("_unify_l_n_voids_write!!\n"); + _p = ((yamop *)(&((_p)->u.os.next))); + break; + + case _traced_unify_atom : + printf("_unify_atom!!\n"); + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + + case _traced_unify_atom_write : + printf("_unify_atom_write!!\n"); + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + + case _traced_unify_l_atom : + printf("_unify_l_atom!!\n"); + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + + case _traced_unify_l_atom_write : + printf("_unify_l_atom_write!!\n"); + _p = ((yamop *)(&((_p)->u.oc.next))); + break; + + case _traced_unify_n_atoms : + printf("_unify_n_atoms!!\n"); + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + + case _traced_unify_n_atoms_write : + printf("_unify_n_atoms_write!!\n"); + _p = ((yamop *)(&((_p)->u.osc.next))); + break; + + case _traced_unify_float : + printf("_unify_float!!\n"); + _p = ((yamop *)(&((_p)->u.od.next))); + break; + + case _traced_unify_float_write : + printf("_unify_float_write!!\n"); + _p = ((yamop *)(&((_p)->u.od.next))); + break; + + case _traced_unify_l_float : + printf("_unify_l_float!!\n"); + _p = ((yamop *)(&((_p)->u.od.next))); + break; + + case _traced_unify_l_float_write : + printf("_unify_l_float_write!!\n"); + _p = ((yamop *)(&((_p)->u.od.next))); + break; + + case _traced_unify_longint : + printf("_unify_longint!!\n"); + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + + case _traced_unify_longint_write : + printf("_unify_longint_write!!\n"); + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + + case _traced_unify_l_longint : + printf("_unify_l_longint!!\n"); + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + + case _traced_unify_l_longint_write : + printf("_unify_l_longint_write!!\n"); + _p = ((yamop *)(&((_p)->u.oi.next))); + break; + + case _traced_unify_bigint : + printf("_unify_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + + case _traced_unify_l_bigint : + printf("_unify_l_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.oN.next))); + break; + + case _traced_unify_dbterm : + printf("_unify_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + + case _traced_unify_l_dbterm : + printf("_unify_l_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.oD.next))); + break; + + case _traced_unify_list : + printf("_unify_list!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _traced_unify_list_write : + printf("_unify_list_write!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _traced_unify_l_list : + printf("_unify_l_list!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _traced_unify_l_list_write : + printf("_unify_l_list_write!!\n"); + _p = ((yamop *)(&((_p)->u.o.next))); + break; + + case _traced_unify_struct : + printf("_unify_struct!!\n"); + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + + case _traced_unify_struct_write : + printf("_unify_struct_write!!\n"); + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + + case _traced_unify_l_struc : + printf("_unify_l_struc!!\n"); + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + + case _traced_unify_l_struc_write : + printf("_unify_l_struc_write!!\n"); + _p = ((yamop *)(&((_p)->u.ofa.next))); + break; + + case _traced_put_x_var : + printf("_put_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _traced_put_y_var : + printf("_put_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _traced_put_x_val : + printf("_put_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.xx.next))); + break; + + case _traced_put_xx_val : + printf("_put_xx_val!!\n"); + _p = ((yamop *)(&((_p)->u.xxxx.next))); + break; + + case _traced_put_y_val : + printf("_put_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _traced_put_y_vals : + printf("_put_y_vals!!\n"); + _p = ((yamop *)(&((_p)->u.yyxx.next))); + break; + + case _traced_put_unsafe : + printf("_put_unsafe!!\n"); + _p = ((yamop *)(&((_p)->u.yx.next))); + break; + + case _traced_put_atom : + printf("_put_atom!!\n"); + _p = ((yamop *)(&((_p)->u.xc.next))); + break; + + case _traced_put_dbterm : + printf("_put_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.xD.next))); + break; + + case _traced_put_bigint : + printf("_put_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.xN.next))); + break; + + case _traced_put_float : + printf("_put_float!!\n"); + _p = ((yamop *)(&((_p)->u.xd.next))); + break; + + case _traced_put_longint : + printf("_put_longint!!\n"); + _p = ((yamop *)(&((_p)->u.xi.next))); + break; + + case _traced_put_list : + printf("_put_list!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _traced_put_struct : + printf("_put_struct!!\n"); + _p = ((yamop *)(&((_p)->u.xfa.next))); + break; + + case _traced_write_x_var : + printf("_write_x_var!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _traced_write_void : + printf("_write_void!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_write_n_voids : + printf("_write_n_voids!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _traced_write_y_var : + printf("_write_y_var!!\n"); + _p = ((yamop *)(&((_p)->u.y.next))); + break; + + case _traced_write_x_val : + printf("_write_x_val!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _traced_write_x_loc : + printf("_write_x_loc!!\n"); + _p = ((yamop *)(&((_p)->u.x.next))); + break; + + case _traced_write_y_val : + printf("_write_y_val!!\n"); + _p = ((yamop *)(&((_p)->u.y.next))); + break; + + case _traced_write_y_loc : + printf("_write_y_loc!!\n"); + _p = ((yamop *)(&((_p)->u.y.next))); + break; + + case _traced_write_atom : + printf("_write_atom!!\n"); + _p = ((yamop *)(&((_p)->u.c.next))); + break; + + case _traced_write_bigint : + printf("_write_bigint!!\n"); + _p = ((yamop *)(&((_p)->u.N.next))); + break; + + case _traced_write_dbterm : + printf("_write_dbterm!!\n"); + _p = ((yamop *)(&((_p)->u.D.next))); + break; + + case _traced_write_float : + printf("_write_float!!\n"); + _p = ((yamop *)(&((_p)->u.d.next))); + break; + + case _traced_write_longint : + printf("_write_longint!!\n"); + _p = ((yamop *)(&((_p)->u.i.next))); + break; + + case _traced_write_n_atoms : + printf("_write_n_atoms!!\n"); + _p = ((yamop *)(&((_p)->u.sc.next))); + break; + + case _traced_write_list : + printf("_write_list!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_write_l_list : + printf("_write_l_list!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_write_struct : + printf("_write_struct!!\n"); + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + + case _traced_write_l_struc : + printf("_write_l_struc!!\n"); + _p = ((yamop *)(&((_p)->u.fa.next))); + break; + + case _traced_save_pair_x : + printf("_save_pair_x!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_save_pair_x_write : + printf("_save_pair_x_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_save_pair_y : + printf("_save_pair_y!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_save_pair_y_write : + printf("_save_pair_y_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_save_appl_x : + printf("_save_appl_x!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_save_appl_x_write : + printf("_save_appl_x_write!!\n"); + _p = ((yamop *)(&((_p)->u.ox.next))); + break; + + case _traced_save_appl_y : + printf("_save_appl_y!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_save_appl_y_write : + printf("_save_appl_y_write!!\n"); + _p = ((yamop *)(&((_p)->u.oy.next))); + break; + + case _traced_jump : + printf("_jump!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_move_back : + printf("_move_back!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_skip : + printf("_skip!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_either : + printf("_either!!\n"); + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + + case _traced_or_else : + printf("_or_else!!\n"); + _p = ((yamop *)(&((_p)->u.Osblp.next))); + break; + + case _traced_pop_n : + printf("_pop_n!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _traced_pop : + printf("_pop!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_call_cpred : + printf("_call_cpred!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _traced_execute_cpred : + printf("_execute_cpred!!\n"); + _p = ((yamop *)(&((_p)->u.pp.next))); + break; + + case _traced_call_usercpred : + printf("_call_usercpred!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _traced_call_c_wfail : + printf("_call_x_wfail!!\n"); + _p = ((yamop *)(&((_p)->u.slp.next))); + break; + + case _traced_try_c : + printf("_try_c!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + + case _traced_retry_c : + printf("_retry_c!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + +#ifdef CUT_C + case _traced_cut_c : + printf("_cut_c!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + +#endif + case _traced_try_userc : + printf("_try_userc!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + + case _traced_retry_userc : + printf("_retry_userc!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + +#ifdef CUT_C + case _traced_cut_userc : + printf("_cut_userc!!\n"); + _p = ((yamop *)(&((_p)->u.OtapFs.next))); + break; + +#endif + case _traced_lock_pred : + printf("_lock_pred!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_index_pred : + printf("_index_pred!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#ifdef THREADS + case _traced_thread_local : + printf("_thread_local!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#endif + case _traced_expand_index : + printf("_expand_index!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_expand_clauses : + printf("_expand_clauses!!\n"); + _p = ((yamop *)(&((_p)->u.sssllp.next))); + break; + + case _traced_undef_p : + printf("_undef_p!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_spy_pred : + printf("_spy_pred!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_try_clause : + printf("_try_clause!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_try_clause2 : + printf("_try_clause2!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_try_clause3 : + printf("_try_clause3!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_try_clause4 : + printf("_try_clause4!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_retry : + printf("_retry!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_retry2 : + printf("_retry2!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_retry3 : + printf("_retry3!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_retry4 : + printf("_retry4!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_trust : + printf("_trust!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_try_in : + printf("_try_in!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_enter_lu_pred : + printf("_enter_lu_pred!!\n"); + _p = ((yamop *)(&((_p)->u.Illss.next))); + break; + + case _traced_try_logical : + printf("_try_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + + case _traced_retry_logical : + printf("_retry_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtaLl.next))); + break; + + case _traced_trust_logical : + printf("_trust_logical!!\n"); + _p = ((yamop *)(&((_p)->u.OtILl.next))); + break; + + case _traced_user_switch : + printf("_user_switch!!\n"); + _p = ((yamop *)(&((_p)->u.lp.next))); + break; + + case _traced_switch_on_type : + printf("_switch_on_type!!\n"); + _p = ((yamop *)(&((_p)->u.llll.next))); + break; + + case _traced_switch_list_nl : + printf("_switch_list_nl!!\n"); + _p = ((yamop *)(&((_p)->u.ollll.next))); + break; + + case _traced_switch_on_arg_type : + printf("_switch_on_arg_type!!\n"); + _p = ((yamop *)(&((_p)->u.xllll.next))); + break; + + case _traced_switch_on_sub_arg_type : + printf("_switch_on_sub_arg_type!!\n"); + _p = ((yamop *)(&((_p)->u.sllll.next))); + break; + + case _traced_jump_if_var : + printf("_jump_if_var!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_jump_if_nonvar : + printf("_jump_if_nonvar!!\n"); + _p = ((yamop *)(&((_p)->u.xll.next))); + break; + + case _traced_if_not_then : + printf("_if_not_then!!\n"); + _p = ((yamop *)(&((_p)->u.clll.next))); + break; + + case _traced_switch_on_func : + printf("_switch_on_func!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _traced_switch_on_cons : + printf("_switch_on_cons!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _traced_go_on_func : + printf("_go_on_func!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _traced_go_on_cons : + printf("_go_on_cons!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _traced_if_func : + printf("_if_func!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _traced_if_cons : + printf("_if_cons!!\n"); + _p = ((yamop *)(&((_p)->u.sssl.next))); + break; + + case _traced_index_dbref : + printf("_index_dbref!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_index_blob : + printf("_index_blob!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_index_long : + printf("_index_long!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_jit_handler : + printf("_jit_handler!!\n"); + _p = ((yamop *)(&((_p)->u.jhc.next))); + break; + + case _traced_p_atom_x : + printf("_p_atom_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_atom_y : + printf("_p_atom_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_atomic_x : + printf("_p_atomic_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_atomic_y : + printf("_p_atomic_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_integer_x : + printf("_p_integer_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_integer_y : + printf("_p_integer_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_nonvar_x : + printf("_p_nonvar_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_nonvar_y : + printf("_p_nonvar_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_number_x : + printf("_p_number_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_number_y : + printf("_p_number_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_var_x : + printf("_p_var_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_var_y : + printf("_p_var_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_db_ref_x : + printf("_p_db_ref_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_db_ref_y : + printf("_p_db_ref_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_primitive_x : + printf("_p_primitive_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_primitive_y : + printf("_p_primitive_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_compound_x : + printf("_p_compound_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_compound_y : + printf("_p_compound_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_float_x : + printf("_p_float_x!!\n"); + _p = ((yamop *)(&((_p)->u.xl.next))); + break; + + case _traced_p_float_y : + printf("_p_float_y!!\n"); + _p = ((yamop *)(&((_p)->u.yl.next))); + break; + + case _traced_p_plus_vv : + printf("_p_plus_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_plus_vc : + printf("_p_plus_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_plus_y_vv : + printf("_p_plus_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_plus_y_vc : + printf("_p_plus_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_minus_vv : + printf("_p_minus_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_minus_cv : + printf("_p_minus_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_minus_y_vv : + printf("_p_minus_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_minus_y_cv : + printf("_p_minus_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_times_vv : + printf("_p_times_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_times_vc : + printf("_p_times_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_times_y_vv : + printf("_p_times_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_times_y_vc : + printf("_p_times_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_div_vv : + printf("_p_div_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_div_vc : + printf("_p_div_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_div_cv : + printf("_p_div_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_div_y_vv : + printf("_p_div_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_div_y_vc : + printf("_p_div_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_div_y_cv : + printf("_p_div_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_and_vv : + printf("_p_and_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_and_vc : + printf("_p_and_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_and_y_vv : + printf("_p_and_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_and_y_vc : + printf("_p_and_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_or_vv : + printf("_p_or_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_or_vc : + printf("_p_or_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_or_y_vv : + printf("_p_or_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_or_y_vc : + printf("_p_or_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_sll_vv : + printf("_p_sll_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_sll_vc : + printf("_p_sll_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_sll_cv : + printf("_p_sll_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_sll_y_vv : + printf("_p_sll_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_sll_y_vc : + printf("_p_sll_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_sll_y_cv : + printf("_p_sll_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_slr_vv : + printf("_p_slr_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_slr_vc : + printf("_p_slr_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_slr_cv : + printf("_p_slr_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_slr_y_vv : + printf("_p_slr_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_slr_y_vc : + printf("_p_slr_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_slr_y_cv : + printf("_p_slr_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_call_bfunc_xx : + printf("_call_bfunc_xx!!\n"); + _p = ((yamop *)(&((_p)->u.plxxs.next))); + break; + + case _traced_call_bfunc_yx : + printf("_call_bfunc_yx!!\n"); + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + + case _traced_call_bfunc_xy : + printf("_call_bfunc_xy!!\n"); + _p = ((yamop *)(&((_p)->u.plxys.next))); + break; + + case _traced_call_bfunc_yy : + printf("_call_bfunc_yy!!\n"); + _p = ((yamop *)(&((_p)->u.plyys.next))); + break; + + case _traced_p_equal : + printf("_p_equal!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_p_dif : + printf("_p_dif!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_p_eq : + printf("_p_eq!!\n"); + _p = ((yamop *)(&((_p)->u.l.next))); + break; + + case _traced_p_arg_vv : + printf("_p_arg_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_arg_cv : + printf("_p_arg_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_arg_y_vv : + printf("_p_arg_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_arg_y_cv : + printf("_p_arg_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_func2s_vv : + printf("_p_func2s_vv!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_func2s_cv : + printf("_p_func2s_cv!!\n"); + _p = ((yamop *)(&((_p)->u.xxc.next))); + break; + + case _traced_p_func2s_vc : + printf("_p_func2s_vc!!\n"); + _p = ((yamop *)(&((_p)->u.xxn.next))); + break; + + case _traced_p_func2s_y_vv : + printf("_p_func2s_y_vv!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_func2s_y_cv : + printf("_p_func2s_y_cv!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_func2s_y_vc : + printf("_p_func2s_y_vc!!\n"); + _p = ((yamop *)(&((_p)->u.yxn.next))); + break; + + case _traced_p_func2f_xx : + printf("_p_func2f_xx!!\n"); + _p = ((yamop *)(&((_p)->u.xxx.next))); + break; + + case _traced_p_func2f_xy : + printf("_p_func2f_xy!!\n"); + _p = ((yamop *)(&((_p)->u.xxy.next))); + break; + + case _traced_p_func2f_yx : + printf("_p_func2f_yx!!\n"); + _p = ((yamop *)(&((_p)->u.yxx.next))); + break; + + case _traced_p_func2f_yy : + printf("_p_func2f_yy!!\n"); + _p = ((yamop *)(&((_p)->u.yyx.next))); + break; + + case _traced_p_functor : + printf("_p_functor!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_p_execute2 : + printf("_p_execute2!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + + case _traced_p_execute : + printf("_p_execute!!\n"); + _p = ((yamop *)(&((_p)->u.Osbmp.next))); + break; + + case _traced_p_execute_tail : + printf("_p_execute_tail!!\n"); + _p = ((yamop *)(&((_p)->u.Osbpp.next))); + break; + +#ifdef YAPOR + case _traced_getwork_first_time : + printf("_getwork_first_time!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_getwork : + printf("_getwork!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_getwork_seq : + printf("_getwork_seq!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_sync : + printf("_sync!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _traced_clause_with_cut : + printf("_clause_with_cut!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#endif + case _traced_table_load_answer : + printf("_table_load_answer!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_try_answer : + printf("_table_try_answer!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_try_single : + printf("_table_try_single!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_try_me : + printf("_table_try_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_try : + printf("_table_try!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_retry_me : + printf("_table_retry_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_retry : + printf("_table_retry!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_trust_me : + printf("_table_trust_me!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_trust : + printf("_table_trust!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_new_answer : + printf("_table_new_answer!!\n"); + _p = ((yamop *)(&((_p)->u.s.next))); + break; + + case _traced_table_answer_resolution : + printf("_table_answer_resolution!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + + case _traced_table_completion : + printf("_table_completion!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + +#ifdef THREADS_CONSUMER_SHARING + case _traced_table_answer_resolution_completion: + printf("_table_answer_resolution_completion!!\n"); + _p = ((yamop *)(&((_p)->u.Otapl.next))); + break; + +#endif + case _traced_trie_do_var : + printf("_trie_do_var!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_var : + printf("_trie_trust_var!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_var : + printf("_trie_try_var!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_var : + printf("_trie_retry_var!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_var_in_pair : + printf("_trie_do_var_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_var_in_pair : + printf("_trie_trust_var_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_var_in_pair : + printf("_trie_try_var_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_var_in_pair : + printf("_trie_retry_var_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_val : + printf("_trie_do_val!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_val : + printf("_trie_trust_val!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_val : + printf("_trie_try_val!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_val : + printf("_trie_retry_val!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_val_in_pair : + printf("_trie_do_val_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_val_in_pair : + printf("_trie_trust_val_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_val_in_pair : + printf("_trie_try_val_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_val_in_pair : + printf("_trie_retry_val_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_atom : + printf("_trie_do_atom!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_atom : + printf("_trie_trust_atom!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_atom : + printf("_trie_try_atom!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_atom : + printf("_trie_retry_atom!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_atom_in_pair : + printf("_trie_do_atom_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_atom_in_pair : + printf("_trie_trust_atom_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_atom_in_pair : + printf("_trie_try_atom_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_atom_in_pair : + printf("_trie_retry_atom_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_null : + printf("_trie_do_null!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_null : + printf("_trie_trust_null!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_null : + printf("_trie_try_null!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_null : + printf("_trie_retry_null!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_null_in_pair : + printf("_trie_do_null_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_null_in_pair : + printf("_trie_trust_null_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_null_in_pair : + printf("_tri_try_null_in_paire!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_null_in_pair : + printf("_trie_retry_null_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_pair : + printf("_trie_do_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_pair : + printf("_trie_trust_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_pair : + printf("_trie_try_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_pair : + printf("_trie_retry_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_appl : + printf("_trie_do_appl!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_appl : + printf("_trie_trust_appl!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_appl : + printf("_trie_try_appl!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_appl : + printf("_trie_retry_appl!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_appl_in_pair : + printf("_trie_do_appl_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_appl_in_pair : + printf("_trie_trust_appl_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_appl_in_pair : + printf("_trie_trty_appkl_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_appl_in_pair : + printf("_trie_retry_appl_in_pair!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_extension : + printf("_trie_do_extension!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_extension : + printf("_trie_trust_extension!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_extension : + printf("_trie_try_extension!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_extension : + printf("_trie_retry_extension!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_double : + printf("_trie_do_double!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_double : + printf("_trie_trust_double!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_double : + printf("_trie_try_double!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_double : + printf("_trie_retry_double!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_longint : + printf("_trie_do_longint!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_longint : + printf("_trie_trust_longint!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_longint : + printf("_trie_try_longint!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_longint : + printf("_trie_retry_longint!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_do_gterm : + printf("_trie_do_gterm!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_trust_gterm : + printf("_trie_trust_gterm!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_try_gterm : + printf("_trie_try_gterm!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + + case _traced_trie_retry_gterm : + printf("_trie_retry_gterm!!\n"); + _p = ((yamop *)(&((_p)->u.e.next))); + break; + +#endif + /* this instruction is hardwired */ +#ifdef YAPOR + case _traced_or_last : + printf("_or_last!!\n"); + _p = ((yamop *)(&((_p)->u.sblp.next))); + break; +#else + case _traced_or_last : + printf("_or_last!!\n"); + _p = ((yamop *)(&((_p)->u.p.next))); + break; +#endif + +#endif /* YAP_JIT */ + } + } + printf("\n"); +} diff --git a/JIT/HPP/printblock.h b/JIT/HPP/printblock.h new file mode 100644 index 000000000..a00853275 --- /dev/null +++ b/JIT/HPP/printblock.h @@ -0,0 +1,5426 @@ +static inline void +print_block(YAP_BBs block) { + switch(block) { + case ENTRY: break; + case JUMPIF: break; + case YAAM_DEREF_BODY_D0PT0: + printf("YAAM_DEREF_BODY_D0PT0\n"); + break; + case YAAM_DEREF_BODY_D0PT1: + printf("YAAM_DEREF_BODY_D0PT1\n"); + break; + case YAAM_DEREF_BODY_D0S_SREG: + printf("YAAM_DEREF_BODY_D0S_SREG\n"); + break; + case YAAM_DEREF_BODY_D1PT0: + printf("YAAM_DEREF_BODY_D1PT0\n"); + break; + case YAAM_DEREF_BODY_D1PT1: + printf("YAAM_DEREF_BODY_D1PT1\n"); + break; + case YAAM_FAIL: + printf("YAAM_FAIL\n"); + break; + case YAAM_CHECK_TRAIL_TR: + printf("YAAM_CHECK_TRAIL_TR\n"); + break; + case YAAM_UNIFYBOUND_EQUALS: + printf("YAAM_UNIFYBOUND_EQUALS\n"); + break; + case YAAM_UNIFYBOUND_PAIR_NOPAIR: + printf("YAAM_UNIFYBOUND_PAIR_NOPAIR\n"); + break; + case YAAM_UNIFYBOUND_PAIR_INIT: + printf("YAAM_UNIFYBOUND_PAIR_INIT\n"); + break; + case YAAM_UNIFYBOUND_PAIR_UNIFY: + printf("YAAM_UNIFYBOUND_PAIR_UNIFY\n"); + break; + case YAAM_UNIFYBOUND_PAIR_NOUNIFY: + printf("YAAM_UNIFYBOUND_PAIR_NOUNIFY\n"); + break; + case YAAM_UNIFYBOUND_APPL_NOAPPL: + printf("YAAM_UNIFYBOUND_APPL_NOAPPL\n"); + break; + case YAAM_UNIFYBOUND_APPL_INIT: + printf("YAAM_UNIFYBOUND_APPL_INIT\n"); + break; + case YAAM_UNIFYBOUND_APPL_NOFUNCTOR: + printf("YAAM_UNIFYBOUND_APPL_NOFUNCTOR\n"); + break; + case YAAM_UNIFYBOUND_APPL_UEXTENSION: + printf("YAAM_UNIFYBOUND_APPL_UEXTENSION\n"); + break; + case YAAM_UNIFYBOUND_APPL_NOUEXTENSION: + printf("YAAM_UNIFYBOUND_APPL_NOUEXTENSION\n"); + break; + case YAAM_UNIFYBOUND_APPL_MIDDLE: + printf("YAAM_UNIFYBOUND_APPL_MIDDLE\n"); + break; + case YAAM_UNIFYBOUND_APPL_UNIFY: + printf("YAAM_UNIFYBOUND_APPL_UNIFY\n"); + break; + case YAAM_UNIFYBOUND_APPL_NOUNIFY: + printf("YAAM_UNIFYBOUND_APPL_NOUNIFY\n"); + break; + case YAAM_UNIFYBOUND_NOPAIR_NOAPPL: + printf("YAAM_UNIFYBOUND_NOPAIR_NOAPPL\n"); + break; + case NoStackExecute_Exception: + printf("NoStackExecute_Exception\n"); + break; + case NoStackDExecute_Exception: + printf("NoStackDExecute_Exception\n"); + break; + case NoStackCall_Exception: + printf("NoStackCall_Exception\n"); + break; + case NoStackDeallocate_Exception: + printf("NoStackDeallocate_Exception\n"); + break; + case NoStackFail_Exception: + printf("NoStackFail_Exception\n"); + break; + case NoStackCut_Exception: + printf("NoStackCut_Exception\n"); + break; + case NoStackCutT_Exception: + printf("NoStackCutT_Exception\n"); + break; + case NoStackCutE_Exception: + printf("NoStackCutE_Exception\n"); + break; + case NoStackCommitX_Exception: + printf("NoStackCommitX_Exception\n"); + break; + case NoStackCommitY_Exception: + printf("NoStackCommitY_Exception\n"); + break; + case NoStackEither_Exception: + printf("NoStackEither_Exception\n"); + break; + case NoStackPExecute_Exception: + printf("NoStackPExecute_Exception\n"); + break; + case NoStackPExecute2_Exception: + printf("NoStackPExecute2_Exception\n"); + break; + case NoStackPTExecute_Exception: + printf("NoStackPTExecute_Exception\n"); + break; + case TRY_ME_INSTINIT: + printf("TRY_ME_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_ME_YAPOR: + printf("TRY_ME_YAPOR\n"); + break; +#endif + case TRY_ME_END: + printf("TRY_ME_END\n"); + break; + case RETRY_ME_INSTINIT: + printf("RETRY_ME_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY_ME_FROZEN: + printf("RETRY_ME_FROZEN\n"); + break; +#else + case RETRY_ME_NOFROZEN: + printf("RETRY_ME_NOFROZEN\n"); + break; +#endif + case RETRY_ME_END: + printf("RETRY_ME_END\n"); + break; + case TRUST_ME_INSTINIT: + printf("TRUST_ME_INSTINIT\n"); + break; +#ifdef YAPOR + case TRUST_ME_YAPOR_IFSUCESS_INIT: + printf("TRUST_ME_YAPOR_IFSUCESS_INIT\n"); + break; +#ifdef FROZEN_STACKS + case TRUST_ME_YAPOR_IFSUCESS_FROZEN: + printf("TRUST_ME_YAPOR_IFSUCESS_FROZEN\n"); + break; +#endif + case TRUST_ME_YAPOR_IFSUCESS_END: + printf("TRUST_ME_YAPOR_IFSUCESS_END\n"); + break; +#endif + case TRUST_ME_NOYAPOR_INIT: + printf("TRUST_ME_NOYAPOR_INIT\n"); + break; +#ifdef FROZEN_STACKS + case TRUST_ME_NOYAPOR_FROZEN: + printf("TRUST_ME_NOYAPOR_FROZEN\n"); + break; +#endif + case TRUST_ME_NOYAPOR_END: + printf("TRUST_ME_NOYAPOR_END\n"); + break; + case TRUST_ME_END: + printf("TRUST_ME_END\n"); + break; + case ENTER_PROFILING_INSTINIT: + printf("ENTER_PROFILING_INSTINIT\n"); + break; + case RETRY_PROFILED_INSTINIT: + printf("RETRY_PROFILED_INSTINIT\n"); + break; + case PROFILED_RETRY_ME_INSTINIT: + printf("PROFILED_RETRY_ME_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case PROFILED_RETRY_ME_FROZEN: + printf("PROFILED_RETRY_ME_FROZEN\n"); + break; +#else + case PROFILED_RETRY_ME_NOFROZEN: + printf("PROFILED_RETRY_ME_NOFROZEN\n"); + break; +#endif + case PROFILED_RETRY_ME_END: + printf("PROFILED_RETRY_ME_END\n"); + break; + case PROFILED_TRUST_ME_INSTINIT: + printf("PROFILED_TRUST_ME_INSTINIT\n"); + break; +#ifdef YAPOR + case PROFILED_TRUST_ME_YAPOR_IFSUCESS_INIT: + printf("PROFILED_TRUST_ME_YAPOR_IFSUCESS_INIT\n"); + break; +#ifdef FROZEN_STACKS + case PROFILED_TRUST_ME_YAPOR_IFSUCESS_FROZEN: + printf("PROFILED_TRUST_ME_YAPOR_IFSUCESS_FROZEN\n"); + break; +#endif + case PROFILED_TRUST_ME_YAPOR_IFSUCESS_END: + printf("PROFILED_TRUST_ME_YAPOR_IFSUCESS_END\n"); + break; +#endif + case PROFILED_TRUST_ME_NOYAPOR_INIT: + printf("PROFILED_TRUST_ME_NOYAPOR_INIT\n"); + break; +#ifdef FROZEN_STACKS + case PROFILED_TRUST_ME_NOYAPOR_FROZEN: + printf("PROFILED_TRUST_ME_NOYAPOR_FROZEN\n"); + break; +#endif + case PROFILED_TRUST_ME_NOYAPOR_END: + printf("PROFILED_TRUST_ME_NOYAPOR_END\n"); + break; + case PROFILED_TRUST_ME_END: + printf("PROFILED_TRUST_ME_END\n"); + break; + case PROFILED_RETRY_LOGICAL_INSTINIT: + printf("PROFILED_RETRY_LOGICAL_INSTINIT\n"); + break; +#ifdef THREADS + case PROFILED_RETRY_LOGICAL_THREADS: + printf("PROFILED_RETRY_LOGICAL_THREADS\n"); + break; +#endif + case PROFILED_RETRY_LOGICAL_POST_THREADS: + printf("PROFILED_RETRY_LOGICAL_POST_THREADS\n"); + break; +#ifdef FROZEN_STACKS + case PROFILED_RETRY_LOGICAL_FROZEN: + printf("PROFILED_RETRY_LOGICAL_FROZEN\n"); + break; +#else + case PROFILED_RETRY_LOGICAL_NOFROZEN: + printf("PROFILED_RETRY_LOGICAL_NOFROZEN\n"); + break; +#endif + case PROFILED_RETRY_LOGICAL_END: + printf("PROFILED_RETRY_LOGICAL_END\n"); + break; + case PROFILED_TRUST_LOGICAL_INSTINIT: + printf("PROFILED_TRUST_LOGICAL_INSTINIT\n"); + break; +#if MULTIPLE_STACKS + case PROFILED_TRUST_LOGICAL_MULTIPLE_STACKS_INIT: + printf("PROFILED_TRUST_LOGICAL_MULTIPLE_STACKS_INIT\n"); + break; +#else + case PROFILED_TRUST_LOGICAL_NOMULTIPLE_STACKS_CONDOK: + printf("PROFILED_TRUST_LOGICAL_NOMULTIPLE_STACKS_CONDOK\n"); + break; +#ifdef FROZEN_STACKS + case PROFILED_TRUST_LOGICAL_FROZENIF: + printf("PROFILED_TRUST_LOGICAL_FROZENIF\n"); + break; +#endif + case PROFILED_TRUST_LOGICAL_NOMULTIPLE_STACKS_TR: + printf("PROFILED_TRUST_LOGICAL_NOMULTIPLE_STACKS_TR\n"); + break; +#endif +#ifdef YAPOR + case PROFILED_TRUST_LOGICAL_YAPOR_INIT: + printf("PROFILED_TRUST_LOGICAL_YAPOR_INIT\n"); + break; +#ifdef FROZEN_STACKS + case PROFILED_TRUST_LOGICAL_YAPOR_FROZEN: + printf("PROFILED_TRUST_LOGICAL_YAPOR_FROZEN\n"); + break; +#else + case PROFILED_TRUST_LOGICAL_YAPOR_NOFROZEN: + printf("PROFILED_TRUST_LOGICAL_YAPOR_NOFROZEN\n"); + break; +#endif + case PROFILED_TRUST_LOGICAL_YAPOR_POST_FROZEN: + printf("PROFILED_TRUST_LOGICAL_YAPOR_POST_FROZEN\n"); + break; +#endif + case PROFILED_TRUST_LOGICAL_NOYAPOR_INIT: + printf("PROFILED_TRUST_LOGICAL_NOYAPOR_INIT\n"); + break; +#ifdef FROZEN_STACKS + case PROFILED_TRUST_LOGICAL_NOYAPOR_FROZEN: + printf("PROFILED_TRUST_LOGICAL_NOYAPOR_FROZEN\n"); + break; +#endif + case PROFILED_TRUST_LOGICAL_END: + printf("PROFILED_TRUST_LOGICAL_END\n"); + break; + case COUNT_CALL_INSTINIT: + printf("COUNT_CALL_INSTINIT\n"); + break; + case COUNT_CALL_FIRSTIFOK: + printf("COUNT_CALL_FIRSTIFOK\n"); + break; + case COUNT_CALL_POST_FIRSTIF: + printf("COUNT_CALL_POST_FIRSTIF\n"); + break; + case COUNT_CALL_SECONDIFOK: + printf("COUNT_CALL_SECONDIFOK\n"); + break; + case COUNT_CALL_END: + printf("COUNT_CALL_END\n"); + break; + case COUNT_RETRY_INSTINIT: + printf("COUNT_RETRY_INSTINIT\n"); + break; + case COUNT_RETRY_FIRSTIFOK: + printf("COUNT_RETRY_FIRSTIFOK\n"); + break; + case COUNT_RETRY_POST_FIRSTIF: + printf("COUNT_RETRY_POST_FIRSTIF\n"); + break; + case COUNT_RETRY_SECONDIFOK: + printf("COUNT_RETRY_SECONDIFOK\n"); + break; + case COUNT_RETRY_END: + printf("COUNT_RETRY_END\n"); + break; + case COUNT_RETRY_ME_INSTINIT: + printf("COUNT_RETRY_ME_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case COUNT_RETRY_ME_FROZEN: + printf("COUNT_RETRY_ME_FROZEN\n"); + break; +#else + case COUNT_RETRY_ME_NOFROZEN: + printf("COUNT_RETRY_ME_NOFROZEN\n"); + break; +#endif + case COUNT_RETRY_ME_POST_FROZEN: + printf("COUNT_RETRY_ME_POST_FROZEN\n"); + break; + case COUNT_RETRY_ME_FIRSTIFOK: + printf("COUNT_RETRY_ME_FIRSTIFOK\n"); + break; + case COUNT_RETRY_ME_POST_FIRSTIF: + printf("COUNT_RETRY_ME_POST_FIRSTIF\n"); + break; + case COUNT_RETRY_ME_SECONDIFOK: + printf("COUNT_RETRY_ME_SECONDIFOK\n"); + break; + case COUNT_RETRY_ME_END: + printf("COUNT_RETRY_ME_END\n"); + break; + case COUNT_TRUST_ME_INSTINIT: + printf("COUNT_TRUST_ME_INSTINIT\n"); + break; +#ifdef YAPOR + case COUNT_TRUST_ME_YAPOR_INIT: + printf("COUNT_TRUST_ME_YAPOR_INIT\n"); + break; +#ifdef FROZEN_STACKS + case COUNT_TRUST_ME_YAPOR_FROZEN: + printf("COUNT_TRUST_ME_YAPOR_FROZEN\n"); + break; +#endif + case COUNT_TRUST_ME_YAPOR_END: + printf("COUNT_TRUST_ME_YAPOR_END\n"); + break; +#endif + case COUNT_TRUST_ME_NOYAPOR_INIT: + printf("COUNT_TRUST_ME_NOYAPOR_INIT\n"); + break; +#ifdef FROZEN_STACKS + case COUNT_TRUST_ME_NOYAPOR_FROZEN: + printf("COUNT_TRUST_ME_NOYAPOR_FROZEN\n"); + break; +#endif + case COUNT_TRUST_ME_NOYAPOR_END: + printf("COUNT_TRUST_ME_NOYAPOR_END\n"); + break; + case COUNT_TRUST_ME_POST_YAPOR: + printf("COUNT_TRUST_ME_POST_YAPOR\n"); + break; + case COUNT_TRUST_ME_FIRSTIFOK: + printf("COUNT_TRUST_ME_FIRSTIFOK\n"); + break; + case COUNT_TRUST_ME_POST_FIRSTIF: + printf("COUNT_TRUST_ME_POST_FIRSTIF\n"); + break; + case COUNT_TRUST_ME_SECONDIFOK: + printf("COUNT_TRUST_ME_SECONDIFOK\n"); + break; + case COUNT_TRUST_ME_END: + printf("COUNT_TRUST_ME_END\n"); + break; + case COUNT_RETRY_LOGICAL_INSTINIT: + printf("COUNT_RETRY_LOGICAL_INSTINIT\n"); + break; + case COUNT_RETRY_LOGICAL_POST_CHECK: + printf("COUNT_RETRY_LOGICAL_POST_CHECK\n"); + break; + case COUNT_RETRY_LOGICAL_FIRSTIFOK: + printf("COUNT_RETRY_LOGICAL_FIRSTIFOK\n"); + break; + case COUNT_RETRY_LOGICAL_POST_FIRSTIF: + printf("COUNT_RETRY_LOGICAL_POST_FIRSTIF\n"); + break; + case COUNT_RETRY_LOGICAL_SECONDIFOK: + printf("COUNT_RETRY_LOGICAL_SECONDIFOK\n"); + break; + case COUNT_RETRY_LOGICAL_POST_SECONDIF: + printf("COUNT_RETRY_LOGICAL_POST_SECONDIF\n"); + break; + case COUNT_RETRY_LOGICAL_THIRDIFOK: + printf("COUNT_RETRY_LOGICAL_THIRDIFOK\n"); + break; + case COUNT_RETRY_LOGICAL_POST_THIRDIF: + printf("COUNT_RETRY_LOGICAL_POST_THIRDIF\n"); + break; +#ifdef THREADS + case COUNT_RETRY_LOGICAL_THREADS: + printf("COUNT_RETRY_LOGICAL_THREADS\n"); + break; +#endif + case COUNT_RETRY_LOGICAL_POST_THREADS: + printf("COUNT_RETRY_LOGICAL_POST_THREADS\n"); + break; +#ifdef FROZEN_STACKS + case COUNT_RETRY_LOGICAL_FROZEN: + printf("COUNT_RETRY_LOGICAL_FROZEN\n"); + break; +#else + case COUNT_RETRY_LOGICAL_NOFROZEN: + printf("COUNT_RETRY_LOGICAL_NOFROZEN\n"); + break; +#endif + case COUNT_RETRY_LOGICAL_END: + printf("COUNT_RETRY_LOGICAL_END\n"); + break; + case COUNT_TRUST_LOGICAL_INSTINIT: + printf("COUNT_TRUST_LOGICAL_INSTINIT\n"); + break; + case COUNT_TRUST_LOGICAL_NOVALID_TIMESTAMP: + printf("COUNT_TRUST_LOGICAL_NOVALID_TIMESTAMP\n"); + break; + case COUNT_TRUST_LOGICAL_VALID_TIMESTAMP_INIT: + printf("COUNT_TRUST_LOGICAL_VALID_TIMESTAMP_INIT\n"); + break; + case COUNT_TRUST_LOGICAL_RETRIESCOUNTERZERO: + printf("COUNT_TRUST_LOGICAL_RETRIESCOUNTERZERO\n"); + break; + case COUNT_TRUST_LOGICAL_POST_RETRIESCOUNTER: + printf("COUNT_TRUST_LOGICAL_POST_RETRIESCOUNTER\n"); + break; + case COUNT_TRUST_LOGICAL_PREDENTRIESCOUNTERZERO: + printf("COUNT_TRUST_LOGICAL_PREDENTRIESCOUNTERZERO\n"); + break; + case COUNT_TRUST_LOGICAL_VALID_TIMESTAMP_END: + printf("COUNT_TRUST_LOGICAL_VALID_TIMESTAMP_END\n"); + break; +#if MULTIPLE_STACKS + case COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_INIT: + printf("COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_INIT\n"); + break; + case COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_COND1OK: + printf("COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_COND1OK\n"); + break; + case COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_COND2OK: + printf("COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_COND2OK\n"); + break; + case COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_COND2NOOK: + printf("COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_COND2NOOK\n"); + break; + case COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_POST_COND2: + printf("COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_POST_COND2\n"); + break; +#else + case COUNT_TRUST_LOGICAL_NOMULTIPLE_STACKS_CONDOK: + printf("COUNT_TRUST_LOGICAL_NOMULTIPLE_STACKS_CONDOK\n"); + break; + case COUNT_TRUST_LOGICAL_NOMULTIPLE_STACKS_TR: + printf("COUNT_TRUST_LOGICAL_NOMULTIPLE_STACKS_TR\n"); + break; + case COUNT_TRUST_LOGICAL_NOMULTIPLE_STACKS_CONDOK_NOFAILCODE: + printf("COUNT_TRUST_LOGICAL_NOMULTIPLE_STACKS_CONDOK_NOFAILCODE\n"); + break; + case COUNT_TRUST_LOGICAL_NOMULTIPLE_STACKS_CONDOK_FLAGS_ERASEDMASK: + printf("COUNT_TRUST_LOGICAL_NOMULTIPLE_STACKS_CONDOK_FLAGS_ERASEDMASK\n"); + break; + case COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_CONDOK_NOFLAGS_NOERASEDMASK: + printf("COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_CONDOK_NOFLAGS_NOERASEDMASK\n"); + break; + case COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_POST_COND: + printf("COUNT_TRUST_LOGICAL_MULTIPLE_STACKS_POST_COND\n"); + break; +#endif +#ifdef YAPOR + case COUNT_TRUST_LOGICAL_YAPOR_INIT: + printf("COUNT_TRUST_LOGICAL_YAPOR_INIT\n"); + break; +#ifdef FROZEN_STACKS + case COUNT_TRUST_LOGICAL_YAPOR_FROZEN: + printf("COUNT_TRUST_LOGICAL_YAPOR_FROZEN\n"); + break; +#else + case COUNT_TRUST_LOGICAL_YAPOR_NOFROZEN: + printf("COUNT_TRUST_LOGICAL_YAPOR_NOFROZEN\n"); + break; +#endif + case COUNT_TRUST_LOGICAL_YAPOR_POST_FROZEN: + printf("COUNT_TRUST_LOGICAL_YAPOR_POST_FROZEN\n"); + break; +#endif + case COUNT_TRUST_LOGICAL_NOYAPOR_INIT: + printf("COUNT_TRUST_LOGICAL_NOYAPOR_INIT\n"); + break; +#ifdef FROZEN_STACKS + case COUNT_TRUST_LOGICAL_NOYAPOR_FROZEN: + printf("COUNT_TRUST_LOGICAL_NOYAPOR_FROZEN\n"); + break; +#endif + case COUNT_TRUST_LOGICAL_NOYAPOR_END: + printf("COUNT_TRUST_LOGICAL_NOYAPOR_END\n"); + break; + case COUNT_TRUST_LOGICAL_END: + printf("COUNT_TRUST_LOGICAL_END\n"); + break; + case LOCK_LU_INSTINIT: + printf("LOCK_LU_INSTINIT\n"); + break; +#if PARALLEL_YAP + case LOCK_LU_PARALLEL_PP: + printf("LOCK_LU_PARALLEL_PP\n"); + break; + case LOCK_LU_PARALLEL: + printf("LOCK_LU_PARALLEL\n"); + break; +#endif + case LOCK_LU_END: + printf("LOCK_LU_END\n"); + break; + case UNLOCK_LU_INSTINIT: + printf("UNLOCK_LU_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case UNLOCK_LU_YAPOR_THREADS: + printf("UNLOCK_LU_YAPOR_THREADS\n"); + break; +#endif + case UNLOCK_LU_END: + printf("UNLOCK_LU_END\n"); + break; + case ALLOC_FOR_LOGICAL_PRED_INSTINIT: + printf("ALLOC_FOR_LOGICAL_PRED_INSTINIT\n"); + break; +#if MULTIPLE_STACKS + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS: + printf("ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS\n"); + break; +#if PARALLEL_YAP + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL: + printf("ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL\n"); + break; +#endif + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END: + printf("ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END\n"); + break; +#else + case ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT: + printf("ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT\n"); + break; + case ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IFOK: + printf("ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IFOK\n"); + break; +#endif + case ALLOC_FOR_LOGICAL_PRED_END: + printf("ALLOC_FOR_LOGICAL_PRED_END\n"); + break; + case COPY_IDB_TERM_INSTINIT: + printf("COPY_IDB_TERM_INSTINIT\n"); + break; + case COPY_IDB_TERM_INSIDEWHILE_FIRSTIFOK: + printf("COPY_IDB_TERM_INSIDEWHILE_FIRSTIFOK\n"); + break; + case COPY_IDB_TERM_INSIDEWHILE_SECONDIFOK_INIT: + printf("COPY_IDB_TERM_INSIDEWHILE_SECONDIFOK_INIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case COPY_IDB_TERM_INSIDEWHILE_SECONDIFOK_YAPOR_THREADS: + printf("COPY_IDB_TERM_INSIDEWHILE_SECONDIFOK_YAPOR_THREADS\n"); + break; +#endif + case COPY_IDB_TERM_INSIDEWHILE_SECONDIFOK_END: + printf("COPY_IDB_TERM_INSIDEWHILE_SECONDIFOK_END\n"); + break; + case COPY_IDB_TERM_INSIDEWHILE_NOFIRSTIF: + printf("COPY_IDB_TERM_INSIDEWHILE_NOFIRSTIF\n"); + break; + case COPY_IDB_TERM_INSIDEWHILE_THIRDIFOK_INIT: + printf("COPY_IDB_TERM_INSIDEWHILE_THIRDIFOK_INIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case COPY_IDB_TERM_INSIDEWHILE_THIRDIFOK_YAPOR_THREADS: + printf("COPY_IDB_TERM_INSIDEWHILE_THIRDIFOK_YAPOR_THREADS\n"); + break; +#endif + case COPY_IDB_TERM_INSIDEWHILE_THIRDIFOK_END: + printf("COPY_IDB_TERM_INSIDEWHILE_THIRDIFOK_END\n"); + break; + case COPY_IDB_TERM_OUTSIDEWHILE_NOUNIFYARG2_INIT: + printf("COPY_IDB_TERM_OUTSIDEWHILE_NOUNIFYARG2_INIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case COPY_IDB_TERM_OUTSIDEWHILE_NOUNIFYARG2_YAPOR_THREADS: + printf("COPY_IDB_TERM_OUTSIDEWHILE_NOUNIFYARG2_YAPOR_THREADS\n"); + break; +#endif + case COPY_IDB_TERM_OUTSIDEWHILE_NOUNIFYARG3_INIT: + printf("COPY_IDB_TERM_OUTSIDEWHILE_NOUNIFYARG3_INIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case COPY_IDB_TERM_OUTSIDEWHILE_NOUNIFYARG3_YAPOR_THREADS: + printf("COPY_IDB_TERM_OUTSIDEWHILE_NOUNIFYARG3_YAPOR_THREADS\n"); + break; +#endif + case COPY_IDB_TERM_SETREGS: + printf("COPY_IDB_TERM_SETREGS\n"); + break; +#if MULTIPLE_STACKS + case COPY_IDB_TERM_MULTIPLE_STACKS: + printf("COPY_IDB_TERM_MULTIPLE_STACKS\n"); + break; +#else + case COPY_IDB_TERM_NOMULTIPLE_STACKS_IFOK: + printf("COPY_IDB_TERM_NOMULTIPLE_STACKS_IFOK\n"); + break; +#endif + case COPY_IDB_TERM_POST_MULTIPLE: + printf("COPY_IDB_TERM_POST_MULTIPLE\n"); + break; +#ifdef DEPTH_LIMIT + case COPY_IDB_TERM_DEPTH: + printf("COPY_IDB_TERM_DEPTH\n"); + break; +#endif + case COPY_IDB_TERM_END: + printf("COPY_IDB_TERM_END\n"); + break; + case UNIFY_IDB_TERM_INSTINIT: + printf("UNIFY_IDB_TERM_INSTINIT\n"); + break; + case UNIFY_IDB_TERM_NOUNIFYARG2_INIT: + printf("UNIFY_IDB_TERM_NOUNIFYARG2_INIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case UNIFY_IDB_TERM_NOUNIFYARG2_YAPOR_THREADS: + printf("UNIFY_IDB_TERM_NOUNIFYARG2_YAPOR_THREADS\n"); + break; +#endif + case UNIFY_IDB_TERM_NOUNIFYARG3_INIT: + printf("UNIFY_IDB_TERM_NOUNIFYARG3_INIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case UNIFY_IDB_TERM_NOUNIFYARG3_YAPOR_THREADS: + printf("UNIFY_IDB_TERM_NOUNIFYARG3_YAPOR_THREADS\n"); + break; +#endif + case UNIFY_IDB_TERM_SETREGS: + printf("UNIFY_IDB_TERM_SETREGS\n"); + break; +#if MULTIPLE_STACKS + case UNIFY_IDB_TERM_MULTIPLE_STACKS: + printf("UNIFY_IDB_TERM_MULTIPLE_STACKS\n"); + break; +#else + case UNIFY_IDB_TERM_NOMULTIPLE_STACKS_IFOK: + printf("UNIFY_IDB_TERM_NOMULTIPLE_STACKS_IFOK\n"); + break; +#endif + case UNIFY_IDB_TERM_POST_MULTIPLE: + printf("UNIFY_IDB_TERM_POST_MULTIPLE\n"); + break; +#ifdef DEPTH_LIMIT + case UNIFY_IDB_TERM_DEPTH: + printf("UNIFY_IDB_TERM_DEPTH\n"); + break; +#endif + case UNIFY_IDB_TERM_END: + printf("UNIFY_IDB_TERM_END\n"); + break; + case ENSURE_SPACE_INSTINIT: + printf("ENSURE_SPACE_INSTINIT\n"); + break; + case ENSURE_SPACE_FIRSTIFOK_INIT: + printf("ENSURE_SPACE_FIRSTIFOK_INIT\n"); + break; +#ifdef DEPTH_LIMIT + case ENSURE_SPACE_FIRSTIFOK_DEPTH: + printf("ENSURE_SPACE_FIRSTIFOK_DEPTH\n"); + break; +#endif + case ENSURE_SPACE_FIRSTIFOK_END: + printf("ENSURE_SPACE_FIRSTIFOK_END\n"); + break; + case ENSURE_SPACE_SECONDIFOK: + printf("ENSURE_SPACE_SECONDIFOK\n"); + break; + case ENSURE_SPACE_NOSECONDIF: + printf("ENSURE_SPACE_NOSECONDIF\n"); + break; + case ENSURE_SPACE_NOFIRSTIF: + printf("ENSURE_SPACE_NOFIRSTIF\n"); + break; + case ENSURE_SPACE_END: + printf("ENSURE_SPACE_END\n"); + break; + case SPY_OR_TRYMARK_INSTINIT: + printf("SPY_OR_TRYMARK_INSTINIT\n"); + break; + case TRY_AND_MARK_INSTINIT: + printf("TRY_AND_MARK_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) +#ifdef YAPOR + case TRY_AND_MARK_YAPOR_THREADS_YAPOR: + printf("TRY_AND_MARK_YAPOR_THREADS_YAPOR\n"); + break; +#endif + case TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IFOK: + printf("TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IFOK\n"); + break; +#endif + case TRY_AND_MARK_NOYAPOR_NOTHREADS: + printf("TRY_AND_MARK_NOYAPOR_NOTHREADS\n"); + break; +#ifdef YAPOR + case TRY_AND_MARK_SET_LOAD: + printf("TRY_AND_MARK_SET_LOAD\n"); + break; +#endif + case TRY_AND_MARK_POST_SET_LOAD: + printf("TRY_AND_MARK_POST_SET_LOAD\n"); + break; +#if MULTIPLE_STACKS + case TRY_AND_MARK_MULTIPLE_STACKS: + printf("TRY_AND_MARK_MULTIPLE_STACKS\n"); + break; +#else + case TRY_AND_MARK_NOMULTIPLE_STACKS_IFOK: + printf("TRY_AND_MARK_NOMULTIPLE_STACKS_IFOK\n"); + break; +#endif + case TRY_AND_MARK_END: + printf("TRY_AND_MARK_END\n"); + break; + case COUNT_RETRY_AND_MARK_INSTINIT: + printf("COUNT_RETRY_AND_MARK_INSTINIT\n"); + break; + case PROFILED_RETRY_AND_MARK_INSTINIT: + printf("PROFILED_RETRY_AND_MARK_INSTINIT\n"); + break; + case RETRY_AND_MARK_INSTINIT: + printf("RETRY_AND_MARK_INSTINIT\n"); + break; +#ifdef YAPOR + case RETRY_AND_MARK_YAPOR: + printf("RETRY_AND_MARK_YAPOR\n"); + break; +#endif + case RETRY_AND_MARK_POST_YAPOR: + printf("RETRY_AND_MARK_POST_YAPOR\n"); + break; +#ifdef FROZEN_STACKS + case RETRY_AND_MARK_FROZEN: + printf("RETRY_AND_MARK_FROZEN\n"); + break; +#else + case RETRY_AND_MARK_NOFROZEN: + printf("RETRY_AND_MARK_NOFROZEN\n"); + break; +#endif + case RETRY_AND_MARK_POST_FROZEN: + printf("RETRY_AND_MARK_POST_FROZEN\n"); + break; +#if MULTIPLE_STACKS + case RETRY_AND_MARK_MULTIPLE_STACKS: + printf("RETRY_AND_MARK_MULTIPLE_STACKS\n"); + break; +#else + case RETRY_AND_MARK_NOMULTIPLE_STACKS_IFOK: + printf("RETRY_AND_MARK_NOMULTIPLE_STACKS_IFOK\n"); + break; +#endif + case RETRY_AND_MARK_END: + printf("RETRY_AND_MARK_END\n"); + break; + case TRUST_FAIL_INSTINIT: + printf("TRUST_FAIL_INSTINIT\n"); + break; +#ifdef CUT_C + case TRUST_FAIL_CUT_C: + printf("TRUST_FAIL_CUT_C\n"); + break; +#endif +#ifdef YAPOR + case TRUST_FAIL_YAPOR: + printf("TRUST_FAIL_YAPOR\n"); + break; +#endif + case TRUST_FAIL_NOYAPOR: + printf("TRUST_FAIL_NOYAPOR\n"); + break; +#ifdef YAPOR + case LBL_SHARED_FAIL: + printf("LBL_SHARED_FAIL\n"); + break; +#endif + case OP_FAIL_INSTINIT: + printf("OP_FAIL_INSTINIT\n"); + break; + case OP_FAIL_PP: + printf("OP_FAIL_PP\n"); + break; +#ifdef COROUTINING + case OP_FAIL_COROUTINING: + printf("OP_FAIL_COROUTINING\n"); + break; +#endif + case LBL_FAIL_INSTINIT: + printf("LBL_FAIL_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case LBL_FAIL_YAPOR_THREADS_PP: + printf("LBL_FAIL_YAPOR_THREADS_PP\n"); + break; +#endif + case LBL_FAIL_POST_YAPOR_THREADS: + printf("LBL_FAIL_POST_YAPOR_THREADS\n"); + break; + case LBL_FAIL_EQUALS: + printf("LBL_FAIL_EQUALS\n"); + break; +#ifdef LOW_LEVEL_TRACER + case LBL_FAIL_LOW_LEVEL_TRACER_INIT: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INIT\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_INIT: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_INIT\n"); + break; +#ifdef TABLING + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE1: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE1\n"); + break; +#ifdef DETERMINISTIC_TABLING + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE2_IFOK: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE2_IFOK\n"); + break; +#endif + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE2_NOIF: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE2_NOIF\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE3: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE3\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE4: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE4\n"); + break; +#endif + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE5: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE5\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE6: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE6\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE7: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE7\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE8: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE8\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE9: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE9\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE10: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE10\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE11: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE11\n"); + break; + case LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE12: + printf("LBL_FAIL_LOW_LEVEL_TRACER_INSIDEWHILE_CASE12\n"); + break; +#endif +#ifdef FROZEN_STACKS + case LBL_FAIL_FIRSTIFOK: + printf("LBL_FAIL_FIRSTIFOK\n"); + break; +#endif + case LBL_FAIL_RESTORE: + printf("LBL_FAIL_RESTORE\n"); + break; + case LBL_FAIL_GO1: + printf("LBL_FAIL_GO1\n"); + break; + case LBL_FAIL_NOEQUAL: + printf("LBL_FAIL_NOEQUAL\n"); + break; +#if defined(YAPOR_SBA) && defined(YAPOR) + case LBL_FAIL_YSBA_YAPOR_IFOK: + printf("LBL_FAIL_YSBA_YAPOR_IFOK\n"); + break; +#endif + case LBL_FAIL_RESET_VAR: + printf("LBL_FAIL_RESET_VAR\n"); + break; + case LBL_FAIL_GO2: + printf("LBL_FAIL_GO2\n"); + break; + case LBL_FAIL_PAIRTERM_INIT: + printf("LBL_FAIL_PAIRTERM_INIT\n"); + break; +#ifdef LIMIT_TABLING + case LBL_FAIL_PAIRTERM_LIMITT: + printf("LBL_FAIL_PAIRTERM_LIMITT\n"); + break; +#endif +#ifdef FROZEN_STACKS + case LBL_FAIL_PAIRTERM_FROZEN_FIRSTIFOK: + printf("LBL_FAIL_PAIRTERM_FROZEN_FIRSTIFOK\n"); + break; +#endif + case LBL_FAIL_PAIRTERM_FBIGINT: + printf("LBL_FAIL_PAIRTERM_FBIGINT\n"); + break; + case LBL_FAIL_PAIRTERM_NOFROZEN: + printf("LBL_FAIL_PAIRTERM_NOFROZEN\n"); + break; +#if MULTIPLE_STACKS + case LBL_FAIL_PAIRTERM_FLAGON: + printf("LBL_FAIL_PAIRTERM_FLAGON\n"); + break; + case LBL_FAIL_PAIRTERM_FLAGON_ERASE: + printf("LBL_FAIL_PAIRTERM_FLAGON_ERASE\n"); + break; + case LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_INIT: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_INIT\n"); + break; +#if PARALLEL_YAP + case LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_PARALLEL: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_PARALLEL\n"); + break; +#endif + case LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_POST_PARALLEL: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_POST_PARALLEL\n"); + break; + case LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_ERASE: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_ERASE\n"); + break; + case LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_NOERASE: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_NOERASE\n"); + break; + case LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_END: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFOK_END\n"); + break; + case LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_INIT: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_INIT\n"); + break; +#if PARALLEL_YAP + case LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_PARALLEL: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_PARALLEL\n"); + break; +#endif + case LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_POST_PARALLEL: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_POST_PARALLEL\n"); + break; + case LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_ERASE: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_ERASE\n"); + break; + case LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_END: + printf("LBL_FAIL_PAIRTERM_FLAGOFF_IFNOOK_END\n"); + break; + case LBL_FAIL_PAIRTERM_POSTFLAGCHECK_INIT: + printf("LBL_FAIL_PAIRTERM_POSTFLAGCHECK_INIT\n"); + break; + case LBL_FAIL_PAIRTERM_POSTFLAGCHECK_ERASE: + printf("LBL_FAIL_PAIRTERM_POSTFLAGCHECK_ERASE\n"); + break; +#else + case LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_INIT: + printf("LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_INIT\n"); + break; + case LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGON: + printf("LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGON\n"); + break; + case LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_INIT: + printf("LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_INIT\n"); + break; + case LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK_INDEXMASK_ERASEDMASK: + printf("LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK_INDEXMASK_ERASEDMASK\n"); + break; + case LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK_INDEXMASK_NOERASEDMASK: + printf("LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK_INDEXMASK_NOERASEDMASK\n"); + break; + case LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK_NOINDEXMASK: + printf("LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK_NOINDEXMASK\n"); + break; + case LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK: + printf("LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK\n"); + break; + case LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK_END: + printf("LBL_FAIL_PAIRTERM_NOMULTIPLE_STACKS_FLAGON_FLAGOFF_LOGUPDMASK_END\n"); + break; +#endif +#ifdef MULTI_ASSIGNMENT_VARIABLES + case LBL_FAIL_NOPAIRTERM_INIT: + printf("LBL_FAIL_NOPAIRTERM_INIT\n"); + break; +#ifdef FROZEN_STACKS + case LBL_FAIL_NOPAIRTERM_FROZEN: + printf("LBL_FAIL_NOPAIRTERM_FROZEN\n"); + break; +#else + case LBL_FAIL_NOPAIRTERM_NOFROZEN: + printf("LBL_FAIL_NOPAIRTERM_NOFROZEN\n"); + break; +#endif +#endif + case LBL_FAIL_END: + printf("LBL_FAIL_END\n"); + break; + case CUT_INSTINIT: + printf("CUT_INSTINIT\n"); + break; +#ifdef COROUTINING + case CUT_COROUTINING: + printf("CUT_COROUTINING\n"); + break; +#endif + case CUT_NOCOROUTINING: + printf("CUT_NOCOROUTINING\n"); + break; + case CUT_T_INSTINIT: + printf("CUT_T_INSTINIT\n"); + break; +#ifdef COROUTINING + case CUT_T_COROUTINING: + printf("CUT_T_COROUTINING\n"); + break; +#endif + case CUT_T_NOCOROUTINING: + printf("CUT_T_NOCOROUTINING\n"); + break; + case CUT_E_INSTINIT: + printf("CUT_E_INSTINIT\n"); + break; +#ifdef COROUTINING + case CUT_E_COROUTINING: + printf("CUT_E_COROUTINING\n"); + break; +#endif + case CUT_E_NOCOROUTINING: + printf("CUT_E_NOCOROUTINING\n"); + break; + case SAVE_B_X_INSTINIT: + printf("SAVE_B_X_INSTINIT\n"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case SAVE_B_X_YSBA_FROZEN: + printf("SAVE_B_X_YSBA_FROZEN\n"); + break; +#else + case SAVE_B_X_NOYSBA_NOFROZEN: + printf("SAVE_B_X_NOYSBA_NOFROZEN\n"); + break; +#endif + case SAVE_B_X_END: + printf("SAVE_B_X_END\n"); + break; + case SAVE_B_Y_INSTINIT: + printf("SAVE_B_Y_INSTINIT\n"); + break; +#if defined(YAPOR_SBA) + case SAVE_B_Y_YSBA: + printf("SAVE_B_Y_YSBA\n"); + break; +#else + case SAVE_B_Y_NOYSBA: + printf("SAVE_B_Y_NOYSBA\n"); + break; +#endif + case SAVE_B_Y_END: + printf("SAVE_B_Y_END\n"); + break; + case COMMIT_B_X_INSTINIT: + printf("COMMIT_B_X_INSTINIT\n"); + break; + case COMMIT_B_X_DO_COMMIT_B_X: + printf("COMMIT_B_X_DO_COMMIT_B_X\n"); + break; + case COMMIT_B_X_COMMIT_B_X_NVAR: + printf("COMMIT_B_X_COMMIT_B_X_NVAR\n"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case COMMIT_B_X_YSBA_FROZEN: + printf("COMMIT_B_X_YSBA_FROZEN\n"); + break; +#else + case COMMIT_B_X_NOYSBA_NOFROZEN: + printf("COMMIT_B_X_NOYSBA_NOFROZEN\n"); + break; +#endif + case COMMIT_B_X_POST_YSBA_FROZEN: + printf("COMMIT_B_X_POST_YSBA_FROZEN\n"); + break; + case COMMIT_B_X_END: + printf("COMMIT_B_X_END\n"); + break; + case COMMIT_B_Y_INSTINIT: + printf("COMMIT_B_Y_INSTINIT\n"); + break; + case COMMIT_B_Y_DO_COMMIT_B_Y: + printf("COMMIT_B_Y_DO_COMMIT_B_Y\n"); + break; + case COMMIT_B_Y_COMMIT_B_Y_NVAR: + printf("COMMIT_B_Y_COMMIT_B_Y_NVAR\n"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case COMMIT_B_Y_YSBA_FROZEN: + printf("COMMIT_B_Y_YSBA_FROZEN\n"); + break; +#else + case COMMIT_B_Y_NOYSBA_NOFROZEN: + printf("COMMIT_B_Y_NOYSBA_NOFROZEN\n"); + break; +#endif + case COMMIT_B_Y_POST_YSBA_FROZEN: + printf("COMMIT_B_Y_POST_YSBA_FROZEN\n"); + break; + case COMMIT_B_Y_END: + printf("COMMIT_B_Y_END\n"); + break; + case EXECUTE_INSTINIT: + printf("EXECUTE_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case EXECUTE_LOW_LEVEL_TRACER: + printf("EXECUTE_LOW_LEVEL_TRACER\n"); + break; +#endif + case EXECUTE_POST_LOW_LEVEL_TRACER: + printf("EXECUTE_POST_LOW_LEVEL_TRACER\n"); + break; + case EXECUTE_POST_NOCHECKING: + printf("EXECUTE_POST_NOCHECKING\n"); + break; +#ifdef DEPTH_LIMIT + case EXECUTE_DEPTH_MINOR_NOFAIL: + printf("EXECUTE_DEPTH_MINOR_NOFAIL\n"); + break; + case EXECUTE_DEPTH_NOMINOR: + printf("EXECUTE_DEPTH_NOMINOR\n"); + break; +#endif + case EXECUTE_END_END: + printf("EXECUTE_END_END\n"); + break; + case DEXECUTE_INSTINIT: + printf("DEXECUTE_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case DEXECUTE_LOW_LEVEL_TRACER: + printf("DEXECUTE_LOW_LEVEL_TRACER\n"); + break; +#endif + case DEXECUTE_POST_LOW_LEVEL_TRACER: + printf("DEXECUTE_POST_LOW_LEVEL_TRACER\n"); + break; +#ifdef DEPTH_LIMIT + case DEXECUTE_DEPTH_MINOR_NOFAIL: + printf("DEXECUTE_DEPTH_MINOR_NOFAIL\n"); + break; + case DEXECUTE_DEPTH_NOMINOR: + printf("DEXECUTE_DEPTH_NOMINOR\n"); + break; +#endif + case DEXECUTE_POST_DEPTH: + printf("DEXECUTE_POST_DEPTH\n"); + break; +#ifdef FROZEN_STACKS + case DEXECUTE_FROZEN: + printf("DEXECUTE_FROZEN\n"); + break; + case DEXECUTE_FROZEN_TOPB: + printf("DEXECUTE_FROZEN_TOPB\n"); + break; + case DEXECUTE_FROZEN_NOTOPB: + printf("DEXECUTE_FROZEN_NOTOPB\n"); + break; +#else + case DEXECUTE_NOFROZEN_ISGREATER: + printf("DEXECUTE_NOFROZEN_ISGREATER\n"); + break; + case DEXECUTE_NOFROZEN_ISNOGREATER: + printf("DEXECUTE_NOFROZEN_ISNOGREATER\n"); + break; +#endif + case DEXECUTE_END_END: + printf("DEXECUTE_END_END\n"); + break; + case FCALL_INSTINIT: + printf("FCALL_INSTINIT\n"); + break; +#ifdef DEPTH_LIMIT + case FCALL_DEPTH: + printf("FCALL_DEPTH\n"); + break; +#endif + case FCALL_END: + printf("FCALL_END\n"); + break; + case CALL_INSTINIT: + printf("CALL_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case CALL_LOW_LEVEL_TRACER: + printf("CALL_LOW_LEVEL_TRACER\n"); + break; +#endif + case CALL_POST_LOW_LEVEL_TRACER: + printf("CALL_POST_LOW_LEVEL_TRACER\n"); + break; + case CALL_POST_NOCHECKING: + printf("CALL_POST_NOCHECKING\n"); + break; +#ifdef DEPTH_LIMIT + case CALL_DEPTH_MINOR_NOFAIL: + printf("CALL_DEPTH_MINOR_NOFAIL\n"); + break; + case CALL_DEPTH_NOMINOR: + printf("CALL_DEPTH_NOMINOR\n"); + break; +#endif +#ifdef FROZEN_STACKS + case CALL_FROZEN: + printf("CALL_FROZEN\n"); + break; + case CALL_FROZEN_TOPB: + printf("CALL_FROZEN_TOPB\n"); + break; +#else + case CALL_NOFROZEN: + printf("CALL_NOFROZEN\n"); + break; +#endif + case CALL_POST_FROZEN: + printf("CALL_POST_FROZEN\n"); + break; +#ifdef YAPOR + case CALL_YAPOR: + printf("CALL_YAPOR\n"); + break; +#endif + case CALL_END_END: + printf("CALL_END_END\n"); + break; + case PROCCEED_INSTINIT: + printf("PROCCEED_INSTINIT\n"); + break; +#ifdef DEPTH_LIMIT + case PROCCEED_DEPTH: + printf("PROCCEED_DEPTH\n"); + break; +#endif + case PROCCEED_END: + printf("PROCCEED_END\n"); + break; + case ALLOCATE_INSTINIT: + printf("ALLOCATE_INSTINIT\n"); + break; +#ifdef DEPTH_LIMIT + case ALLOCATE_DEPTH: + printf("ALLOCATE_DEPTH\n"); + break; +#endif + case ALLOCATE_END: + printf("ALLOCATE_END\n"); + break; + case DEALLOCATE_INSTINIT: + printf("DEALLOCATE_INSTINIT\n"); + break; + case DEALLOCATE_POST_CHECK: + printf("DEALLOCATE_POST_CHECK\n"); + break; +#ifdef DEPTH_LIMIT + case DEALLOCATE_DEPTH: + printf("DEALLOCATE_DEPTH\n"); + break; +#endif +#ifdef FROZEN_STACKS + case DEALLOCATE_FROZEN: + printf("DEALLOCATE_FROZEN\n"); + break; + case DEALLOCATE_FROZEN_TOPB: + printf("DEALLOCATE_FROZEN_TOPB\n"); + break; + case DEALLOCATE_FROZEN_NOTOPB: + printf("DEALLOCATE_FROZEN_NOTOPB\n"); + break; +#else + case DEALLOCATE_NOFROZEN_ISGREATER: + printf("DEALLOCATE_NOFROZEN_ISGREATER\n"); + break; + case DEALLOCATE_NOFROZEN_ISNOGREATER: + printf("DEALLOCATE_NOFROZEN_ISNOGREATER\n"); + break; +#endif + case DEALLOCATE_POST_FROZEN: + printf("DEALLOCATE_POST_FROZEN\n"); + break; + case DEALLOCATE_END: + printf("DEALLOCATE_END\n"); + break; + case GET_X_VAR_INSTINIT: + printf("GET_X_VAR_INSTINIT\n"); + break; + case GET_Y_VAR_INSTINIT: + printf("GET_Y_VAR_INSTINIT\n"); + break; + case GET_YY_VAR_INSTINIT: + printf("GET_YY_VAR_INSTINIT\n"); + break; + case GET_X_VAL_INSTINIT: + printf("GET_X_VAL_INSTINIT\n"); + break; + case GET_X_VAL_GVALX_NONVAR: + printf("GET_X_VAL_GVALX_NONVAR\n"); + break; + case GET_X_VAL_GVALX_NONVAR_NONVAR: + printf("GET_X_VAL_GVALX_NONVAR_NONVAR\n"); + break; + case GET_X_VAL_GVALX_NONVAR_UNK: + printf("GET_X_VAL_GVALX_NONVAR_UNK\n"); + break; + case GET_X_VAL_GVALX_UNK: + printf("GET_X_VAL_GVALX_UNK\n"); + break; + case GET_X_VAL_GVALX_VAR_NONVAR: + printf("GET_X_VAL_GVALX_VAR_NONVAR\n"); + break; + case GET_X_VAL_GVALX_VAR_UNK: + printf("GET_X_VAL_GVALX_VAR_UNK\n"); + break; + case GET_Y_VAL_INSTINIT: + printf("GET_Y_VAL_INSTINIT\n"); + break; + case GET_Y_VAL_GVALY_NONVAR: + printf("GET_Y_VAL_GVALY_NONVAR\n"); + break; + case GET_Y_VAL_GVALY_NONVAR_NONVAR: + printf("GET_Y_VAL_GVALY_NONVAR_NONVAR\n"); + break; + case GET_Y_VAL_GVALY_NONVAR_UNK: + printf("GET_Y_VAL_GVALY_NONVAR_UNK\n"); + break; + case GET_Y_VAL_GVALY_UNK: + printf("GET_Y_VAL_GVALY_UNK\n"); + break; + case GET_Y_VAL_GVALY_VAR_NONVAR: + printf("GET_Y_VAL_GVALY_VAR_NONVAR\n"); + break; + case GET_Y_VAL_GVALY_VAR_UNK: + printf("GET_Y_VAL_GVALY_VAR_UNK\n"); + break; + case GET_ATOM_INSTINIT: + printf("GET_ATOM_INSTINIT\n"); + break; + case GET_ATOM_EQUALS: + printf("GET_ATOM_EQUALS\n"); + break; + case GET_ATOM_FAIL: + printf("GET_ATOM_FAIL\n"); + break; + case GET_ATOM_GATOM_UNK: + printf("GET_ATOM_GATOM_UNK\n"); + break; + case GET_2ATOMS_INSTINIT: + printf("GET_2ATOMS_INSTINIT\n"); + break; + case GET_2ATOMS_GATOM_2UNK: + printf("GET_2ATOMS_GATOM_2UNK\n"); + break; + case GET_2ATOMS_GATOM_2B: + printf("GET_2ATOMS_GATOM_2B\n"); + break; + case GET_2ATOMS_EQUALS: + printf("GET_2ATOMS_EQUALS\n"); + break; + case GET_2ATOMS_GATOM_2BUNK: + printf("GET_2ATOMS_GATOM_2BUNK\n"); + break; + case GET_3ATOMS_INSTINIT: + printf("GET_3ATOMS_INSTINIT\n"); + break; + case GET_3ATOMS_GATOM_3UNK: + printf("GET_3ATOMS_GATOM_3UNK\n"); + break; + case GET_3ATOMS_GATOM_3B: + printf("GET_3ATOMS_GATOM_3B\n"); + break; + case GET_3ATOMS_GATOM_3BUNK: + printf("GET_3ATOMS_GATOM_3BUNK\n"); + break; + case GET_3ATOMS_GATOM_3C: + printf("GET_3ATOMS_GATOM_3C\n"); + break; + case GET_3ATOMS_EQUALS: + printf("GET_3ATOMS_EQUALS\n"); + break; + case GET_3ATOMS_GATOM_3CUNK: + printf("GET_3ATOMS_GATOM_3CUNK\n"); + break; + case GET_4ATOMS_INSTINIT: + printf("GET_4ATOMS_INSTINIT\n"); + break; + case GET_4ATOMS_GATOM_4UNK: + printf("GET_4ATOMS_GATOM_4UNK\n"); + break; + case GET_4ATOMS_GATOM_4B: + printf("GET_4ATOMS_GATOM_4B\n"); + break; + case GET_4ATOMS_GATOM_4BUNK: + printf("GET_4ATOMS_GATOM_4BUNK\n"); + break; + case GET_4ATOMS_GATOM_4C: + printf("GET_4ATOMS_GATOM_4C\n"); + break; + case GET_4ATOMS_GATOM_4CUNK: + printf("GET_4ATOMS_GATOM_4CUNK\n"); + break; + case GET_4ATOMS_GATOM_4D: + printf("GET_4ATOMS_GATOM_4D\n"); + break; + case GET_4ATOMS_EQUALS: + printf("GET_4ATOMS_EQUALS\n"); + break; + case GET_4ATOMS_GATOM_4DUNK: + printf("GET_4ATOMS_GATOM_4DUNK\n"); + break; + case GET_5ATOMS_INSTINIT: + printf("GET_5ATOMS_INSTINIT\n"); + break; + case GET_5ATOMS_GATOM_5UNK: + printf("GET_5ATOMS_GATOM_5UNK\n"); + break; + case GET_5ATOMS_GATOM_5B: + printf("GET_5ATOMS_GATOM_5B\n"); + break; + case GET_5ATOMS_GATOM_5BUNK: + printf("GET_5ATOMS_GATOM_5BUNK\n"); + break; + case GET_5ATOMS_GATOM_5C: + printf("GET_5ATOMS_GATOM_5C\n"); + break; + case GET_5ATOMS_GATOM_5CUNK: + printf("GET_5ATOMS_GATOM_5CUNK\n"); + break; + case GET_5ATOMS_GATOM_5D: + printf("GET_5ATOMS_GATOM_5D\n"); + break; + case GET_5ATOMS_GATOM_5DUNK: + printf("GET_5ATOMS_GATOM_5DUNK\n"); + break; + case GET_5ATOMS_GATOM_5E: + printf("GET_5ATOMS_GATOM_5E\n"); + break; + case GET_5ATOMS_EQUALS: + printf("GET_5ATOMS_EQUALS\n"); + break; + case GET_5ATOMS_GATOM_5EUNK: + printf("GET_5ATOMS_GATOM_5EUNK\n"); + break; + case GET_6ATOMS_INSTINIT: + printf("GET_6ATOMS_INSTINIT\n"); + break; + case GET_6ATOMS_GATOM_6UNK: + printf("GET_6ATOMS_GATOM_6UNK\n"); + break; + case GET_6ATOMS_GATOM_6B: + printf("GET_6ATOMS_GATOM_6B\n"); + break; + case GET_6ATOMS_GATOM_6BUNK: + printf("GET_6ATOMS_GATOM_6BUNK\n"); + break; + case GET_6ATOMS_GATOM_6C: + printf("GET_6ATOMS_GATOM_6C\n"); + break; + case GET_6ATOMS_GATOM_6CUNK: + printf("GET_6ATOMS_GATOM_6CUNK\n"); + break; + case GET_6ATOMS_GATOM_6D: + printf("GET_6ATOMS_GATOM_6D\n"); + break; + case GET_6ATOMS_GATOM_6DUNK: + printf("GET_6ATOMS_GATOM_6DUNK\n"); + break; + case GET_6ATOMS_GATOM_6E: + printf("GET_6ATOMS_GATOM_6E\n"); + break; + case GET_6ATOMS_GATOM_6EUNK: + printf("GET_6ATOMS_GATOM_6EUNK\n"); + break; + case GET_6ATOMS_GATOM_6F: + printf("GET_6ATOMS_GATOM_6F\n"); + break; + case GET_6ATOMS_EQUALS: + printf("GET_6ATOMS_EQUALS\n"); + break; + case GET_6ATOMS_GATOM_6FUNK: + printf("GET_6ATOMS_GATOM_6FUNK\n"); + break; + case GET_LIST_INSTINIT: + printf("GET_LIST_INSTINIT\n"); + break; + case GET_LIST_FAIL: + printf("GET_LIST_FAIL\n"); + break; + case GET_LIST_GLIST_NONVAR: + printf("GET_LIST_GLIST_NONVAR\n"); + break; + case GET_LIST_GLIST_UNK: + printf("GET_LIST_GLIST_UNK\n"); + break; + case GET_STRUCT_INSTINIT: + printf("GET_STRUCT_INSTINIT\n"); + break; + case GET_STRUCT_GSTRUCT_NONVAR_INIT: + printf("GET_STRUCT_GSTRUCT_NONVAR_INIT\n"); + break; + case GET_STRUCT_GSTRUCT_NONVAR_END: + printf("GET_STRUCT_GSTRUCT_NONVAR_END\n"); + break; + case GET_STRUCT_GSTRUCT_UNK: + printf("GET_STRUCT_GSTRUCT_UNK\n"); + break; + case GET_FLOAT_INSTINIT: + printf("GET_FLOAT_INSTINIT\n"); + break; + case GET_FLOAT_GFLOAT_NONVAR_INIT: + printf("GET_FLOAT_GFLOAT_NONVAR_INIT\n"); + break; + case GET_FLOAT_GFLOAT_NONVAR_MIDDLE: + printf("GET_FLOAT_GFLOAT_NONVAR_MIDDLE\n"); + break; + case GET_FLOAT_GFLOAT_NONVAR_END: + printf("GET_FLOAT_GFLOAT_NONVAR_END\n"); + break; + case GET_FLOAT_GFLOAT_UNK: + printf("GET_FLOAT_GFLOAT_UNK\n"); + break; + case GET_LONGINT_INSTINIT: + printf("GET_LONGINT_INSTINIT\n"); + break; + case GET_LONGINT_GLONGINT_NONVAR_INIT: + printf("GET_LONGINT_GLONGINT_NONVAR_INIT\n"); + break; + case GET_LONGINT_GLONGINT_NONVAR_END: + printf("GET_LONGINT_GLONGINT_NONVAR_END\n"); + break; + case GET_LONGINT_GLONGINT_UNK: + printf("GET_LONGINT_GLONGINT_UNK\n"); + break; +#ifdef USE_GMP + case GET_BIGINT_INSTINIT: + printf("GET_BIGINT_INSTINIT\n"); + break; + case GET_BIGINT_GBIGINT_NONVAR_INIT: + printf("GET_BIGINT_GBIGINT_NONVAR_INIT\n"); + break; + case GET_BIGINT_GBIGINT_NONVAR_END: + printf("GET_BIGINT_GBIGINT_NONVAR_END\n"); + break; + case GET_BIGINT_GBIGINT_UNK: + printf("GET_BIGINT_GBIGINT_UNK\n"); + break; +#endif + case GET_DBTERM_INSTINIT: + printf("GET_DBTERM_INSTINIT\n"); + break; + case GET_DBTERM_GDBTERM_NONVAR: + printf("GET_DBTERM_GDBTERM_NONVAR\n"); + break; + case GET_DBTERM_GDBTERM_UNK: + printf("GET_DBTERM_GDBTERM_UNK\n"); + break; + case GLIST_VALX_INSTINIT: + printf("GLIST_VALX_INSTINIT\n"); + break; + case GLIST_VALX_GLIST_VALX_READ: + printf("GLIST_VALX_GLIST_VALX_READ\n"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR: + printf("GLIST_VALX_GLIST_VALX_NONVAR\n"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR_NONVAR: + printf("GLIST_VALX_GLIST_VALX_NONVAR_NONVAR\n"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR_UNK: + printf("GLIST_VALX_GLIST_VALX_NONVAR_UNK\n"); + break; + case GLIST_VALX_GLIST_VALX_UNK: + printf("GLIST_VALX_GLIST_VALX_UNK\n"); + break; + case GLIST_VALX_GLIST_VALX_VAR_NONVAR: + printf("GLIST_VALX_GLIST_VALX_VAR_NONVAR\n"); + break; + case GLIST_VALX_GLIST_VALX_VAR_UNK: + printf("GLIST_VALX_GLIST_VALX_VAR_UNK\n"); + break; + case GLIST_VALX_GLIST_VALX_WRITE: + printf("GLIST_VALX_GLIST_VALX_WRITE\n"); + break; + case GLIST_VALY_INSTINIT: + printf("GLIST_VALY_INSTINIT\n"); + break; + case GLIST_VALY_GLIST_VALY_READ: + printf("GLIST_VALY_GLIST_VALY_READ\n"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR: + printf("GLIST_VALY_GLIST_VALY_NONVAR\n"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR_NONVAR: + printf("GLIST_VALY_GLIST_VALY_NONVAR_NONVAR\n"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR_UNK: + printf("GLIST_VALY_GLIST_VALY_NONVAR_UNK\n"); + break; + case GLIST_VALY_GLIST_VALY_UNK: + printf("GLIST_VALY_GLIST_VALY_UNK\n"); + break; + case GLIST_VALY_GLIST_VALY_VAR_NONVAR: + printf("GLIST_VALY_GLIST_VALY_VAR_NONVAR\n"); + break; + case GLIST_VALY_GLIST_VALY_VAR_UNK: + printf("GLIST_VALY_GLIST_VALY_VAR_UNK\n"); + break; + case GLIST_VALY_GLIST_VALY_WRITE: + printf("GLIST_VALY_GLIST_VALY_WRITE\n"); + break; + case GL_VOID_VARX_INSTINIT: + printf("GL_VOID_VARX_INSTINIT\n"); + break; + case GL_VOID_VARX_GLIST_VOID_VARX_READ: + printf("GL_VOID_VARX_GLIST_VOID_VARX_READ\n"); + break; + case GL_VOID_VARX_GLIST_VOID_VAR_WRITE: + printf("GL_VOID_VARX_GLIST_VOID_VAR_WRITE\n"); + break; + case GL_VOID_VARY_INSTINIT: + printf("GL_VOID_VARY_INSTINIT\n"); + break; + case GL_VOID_VARY_GLIST_VOID_VARY_READ: + printf("GL_VOID_VARY_GLIST_VOID_VARY_READ\n"); + break; + case GL_VOID_VARY_GLIST_VOID_VARY_WRITE: + printf("GL_VOID_VARY_GLIST_VOID_VARY_WRITE\n"); + break; + case GL_VOID_VALX_INSTINIT: + printf("GL_VOID_VALX_INSTINIT\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_READ: + printf("GL_VOID_VALX_GLIST_VOID_VALX_READ\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR: + printf("GL_VOID_VALX_GLIST_VOID_VALX_NONVAR\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR: + printf("GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK: + printf("GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_UNK: + printf("GL_VOID_VALX_GLIST_VOID_VALX_UNK\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR: + printf("GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK: + printf("GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_WRITE: + printf("GL_VOID_VALX_GLIST_VOID_VALX_WRITE\n"); + break; + case GL_VOID_VALY_INSTINIT: + printf("GL_VOID_VALY_INSTINIT\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_READ: + printf("GL_VOID_VALY_GLIST_VOID_VALY_READ\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR: + printf("GL_VOID_VALY_GLIST_VOID_VALY_NONVAR\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR: + printf("GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK: + printf("GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_UNK: + printf("GL_VOID_VALY_GLIST_VOID_VALY_UNK\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR: + printf("GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK: + printf("GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_WRITE: + printf("GL_VOID_VALY_GLIST_VOID_VALY_WRITE\n"); + break; + case UNIFY_X_VAR_INSTINIT: + printf("UNIFY_X_VAR_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_X_VAR_D0ISZERO: + printf("UNIFY_X_VAR_D0ISZERO\n"); + break; +#endif + case UNIFY_X_VAR_END: + printf("UNIFY_X_VAR_END\n"); + break; + case UNIFY_X_VAR_WRITE_INSTINIT: + printf("UNIFY_X_VAR_WRITE_INSTINIT\n"); + break; + case UNIFY_L_X_VAR_INSTINIT: + printf("UNIFY_L_X_VAR_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_L_X_VAR_D0ISZERO: + printf("UNIFY_L_X_VAR_D0ISZERO\n"); + break; +#endif + case UNIFY_L_X_VAR_END: + printf("UNIFY_L_X_VAR_END\n"); + break; + case UNIFY_L_X_VAR_WRITE_INSTINIT: + printf("UNIFY_L_X_VAR_WRITE_INSTINIT\n"); + break; + case UNIFY_X_VAR2_INSTINIT: + printf("UNIFY_X_VAR2_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_X_VAR2_D0ISZERO: + printf("UNIFY_X_VAR2_D0ISZERO\n"); + break; + case UNIFY_X_VAR2_D1ISZERO: + printf("UNIFY_X_VAR2_D1ISZERO\n"); + break; +#endif + case UNIFY_X_VAR2_END: + printf("UNIFY_X_VAR2_END\n"); + break; + case UNIFY_X_VAR2_WRITE_INSTINIT: + printf("UNIFY_X_VAR2_WRITE_INSTINIT\n"); + break; + case UNIFY_L_X_VAR2_INSTINIT: + printf("UNIFY_L_X_VAR2_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_L_X_VAR2_D0ISZERO: + printf("UNIFY_L_X_VAR2_D0ISZERO\n"); + break; +#endif + case UNIFY_L_X_VAR2_D0ISNOZERO: + printf("UNIFY_L_X_VAR2_D0ISNOZERO\n"); + break; + case UNIFY_L_X_VAR2_POST_IF: + printf("UNIFY_L_X_VAR2_POST_IF\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_L_X_VAR2_D1ISZERO: + printf("UNIFY_L_X_VAR2_D1ISZERO\n"); + break; +#endif + case UNIFY_L_X_VAR2_D1ISNOZERO: + printf("UNIFY_L_X_VAR2_D1ISNOZERO\n"); + break; + case UNIFY_L_X_VAR2_END: + printf("UNIFY_L_X_VAR2_END\n"); + break; + case UNIFY_L_X_VAR2_WRITE_INSTINIT: + printf("UNIFY_L_X_VAR2_WRITE_INSTINIT\n"); + break; + case UNIFY_Y_VAR_INSTINIT: + printf("UNIFY_Y_VAR_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_Y_VAR_YAPOR_D0ISZERO: + printf("UNIFY_Y_VAR_YAPOR_D0ISZERO\n"); + break; +#endif + case UNIFY_Y_VAR_YAPOR_D0ISNOZERO: + printf("UNIFY_Y_VAR_YAPOR_D0ISNOZERO\n"); + break; + case UNIFY_Y_VAR_END: + printf("UNIFY_Y_VAR_END\n"); + break; + case UNIFY_Y_VAR_WRITE_INSTINIT: + printf("UNIFY_Y_VAR_WRITE_INSTINIT\n"); + break; + case UNIFY_L_Y_VAR_INSTINIT: + printf("UNIFY_L_Y_VAR_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_L_Y_VAR_D0ISZERO: + printf("UNIFY_L_Y_VAR_D0ISZERO\n"); + break; +#endif + case UNIFY_L_Y_VAR_D0ISNOZERO: + printf("UNIFY_L_Y_VAR_D0ISNOZERO\n"); + break; + case UNIFY_L_Y_VAR_END: + printf("UNIFY_L_Y_VAR_END\n"); + break; + case UNIFY_L_Y_VAR_WRITE_INSTINIT: + printf("UNIFY_L_Y_VAR_WRITE_INSTINIT\n"); + break; + case UNIFY_X_VAL_INSTINIT: + printf("UNIFY_X_VAL_INSTINIT\n"); + break; + case UNIFY_X_VAL_UVALX_NONVAR: + printf("UNIFY_X_VAL_UVALX_NONVAR\n"); + break; + case UNIFY_X_VAL_UVALX_NONVAR_NONVAR: + printf("UNIFY_X_VAL_UVALX_NONVAR_NONVAR\n"); + break; + case UNIFY_X_VAL_UVALX_NONVAR_UNK: + printf("UNIFY_X_VAL_UVALX_NONVAR_UNK\n"); + break; + case UNIFY_X_VAL_UVALX_UNK: + printf("UNIFY_X_VAL_UVALX_UNK\n"); + break; + case UNIFY_X_VAL_UVALX_VAR_NONVAR: + printf("UNIFY_X_VAL_UVALX_VAR_NONVAR\n"); + break; + case UNIFY_X_VAL_UVALX_VAR_UNK: + printf("UNIFY_X_VAL_UVALX_VAR_UNK\n"); + break; + case UNIFY_X_VAL_WRITE_INSTINIT: + printf("UNIFY_X_VAL_WRITE_INSTINIT\n"); + break; + case UNIFY_L_X_VAL_INSTINIT: + printf("UNIFY_L_X_VAL_INSTINIT\n"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR: + printf("UNIFY_L_X_VAL_ULVALX_NONVAR\n"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR: + printf("UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR\n"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR_UNK: + printf("UNIFY_L_X_VAL_ULVALX_NONVAR_UNK\n"); + break; + case UNIFY_L_X_VAL_ULVALX_UNK: + printf("UNIFY_L_X_VAL_ULVALX_UNK\n"); + break; + case UNIFY_L_X_VAL_ULVALX_VAR_NONVAR: + printf("UNIFY_L_X_VAL_ULVALX_VAR_NONVAR\n"); + break; + case UNIFY_L_X_VAL_ULVALX_VAR_UNK: + printf("UNIFY_L_X_VAL_ULVALX_VAR_UNK\n"); + break; + case UNIFY_L_X_VAL_WRITE_INSTINIT: + printf("UNIFY_L_X_VAL_WRITE_INSTINIT\n"); + break; + case UNIFY_Y_VAL_INSTINIT: + printf("UNIFY_Y_VAL_INSTINIT\n"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR: + printf("UNIFY_Y_VAL_UVALY_NONVAR\n"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR_NONVAR: + printf("UNIFY_Y_VAL_UVALY_NONVAR_NONVAR\n"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR_UNK: + printf("UNIFY_Y_VAL_UVALY_NONVAR_UNK\n"); + break; + case UNIFY_Y_VAL_UVALY_UNK: + printf("UNIFY_Y_VAL_UVALY_UNK\n"); + break; + case UNIFY_Y_VAL_UVALY_VAR_NONVAR: + printf("UNIFY_Y_VAL_UVALY_VAR_NONVAR\n"); + break; + case UNIFY_Y_VAL_UVALY_VAR_UNK: + printf("UNIFY_Y_VAL_UVALY_VAR_UNK\n"); + break; + case UNIFY_Y_VAL_WRITE_INSTINIT: + printf("UNIFY_Y_VAL_WRITE_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_Y_VAL_WRITE_D0ISZERO: + printf("UNIFY_Y_VAL_WRITE_D0ISZERO\n"); + break; +#endif + case UNIFY_Y_VAL_WRITE_D0ISNOZERO: + printf("UNIFY_Y_VAL_WRITE_D0ISNOZERO\n"); + break; + case UNIFY_Y_VAL_WRITE_END: + printf("UNIFY_Y_VAL_WRITE_END\n"); + break; + case UNIFY_L_Y_VAL_INSTINIT: + printf("UNIFY_L_Y_VAL_INSTINIT\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR: + printf("UNIFY_L_Y_VAL_ULVALY_NONVAR\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR: + printf("UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK: + printf("UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_UNK: + printf("UNIFY_L_Y_VAL_ULVALY_UNK\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR: + printf("UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_VAR_UNK: + printf("UNIFY_L_Y_VAL_ULVALY_VAR_UNK\n"); + break; + case UNIFY_L_Y_VAL_WRITE_INSTINIT: + printf("UNIFY_L_Y_VAL_WRITE_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_L_Y_VAL_WRITE_D0ISZERO: + printf("UNIFY_L_Y_VAL_WRITE_D0ISZERO\n"); + break; +#endif + case UNIFY_L_Y_VAL_WRITE_D0ISNOZERO: + printf("UNIFY_L_Y_VAL_WRITE_D0ISNOZERO\n"); + break; + case UNIFY_L_Y_VAL_WRITE_END: + printf("UNIFY_L_Y_VAL_WRITE_END\n"); + break; + case UNIFY_X_LOC_INSTINIT: + printf("UNIFY_X_LOC_INSTINIT\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR: + printf("UNIFY_X_LOC_UVALX_LOC_NONVAR\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR: + printf("UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK: + printf("UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_UNK: + printf("UNIFY_X_LOC_UVALX_LOC_UNK\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR: + printf("UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_VAR_UNK: + printf("UNIFY_X_LOC_UVALX_LOC_VAR_UNK\n"); + break; + case UNIFY_X_LOC_WRITE_INSTINIT: + printf("UNIFY_X_LOC_WRITE_INSTINIT\n"); + break; + case UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR: + printf("UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR\n"); + break; + case UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK: + printf("UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK\n"); + break; + case UNIFY_X_LOC_WRITE_HGREATER: + printf("UNIFY_X_LOC_WRITE_HGREATER\n"); + break; + case UNIFY_X_LOC_WRITE_HLESS: + printf("UNIFY_X_LOC_WRITE_HLESS\n"); + break; + case UNIFY_L_X_LOC_INSTINIT: + printf("UNIFY_L_X_LOC_INSTINIT\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR: + printf("UNIFY_L_X_LOC_ULVALX_LOC_NONVAR\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR: + printf("UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK: + printf("UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_UNK: + printf("UNIFY_L_X_LOC_ULVALX_LOC_UNK\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR: + printf("UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK: + printf("UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK\n"); + break; + case UNIFY_L_X_LOC_WRITE_INSTINIT: + printf("UNIFY_L_X_LOC_WRITE_INSTINIT\n"); + break; + case UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR: + printf("UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR\n"); + break; + case UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK: + printf("UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK\n"); + break; + case UNIFY_L_X_LOC_WRITE_HGREATER: + printf("UNIFY_L_X_LOC_WRITE_HGREATER\n"); + break; + case UNIFY_L_X_LOC_WRITE_HLESS: + printf("UNIFY_L_X_LOC_WRITE_HLESS\n"); + break; + case UNIFY_Y_LOC_INSTINIT: + printf("UNIFY_Y_LOC_INSTINIT\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR: + printf("UNIFY_Y_LOC_UVALY_LOC_NONVAR\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR: + printf("UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK: + printf("UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_UNK: + printf("UNIFY_Y_LOC_UVALY_LOC_UNK\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR: + printf("UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_VAR_UNK: + printf("UNIFY_Y_LOC_UVALY_LOC_VAR_UNK\n"); + break; + case UNIFY_Y_LOC_WRITE_INSTINIT: + printf("UNIFY_Y_LOC_WRITE_INSTINIT\n"); + break; + case UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR: + printf("UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR\n"); + break; + case UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK: + printf("UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK\n"); + break; + case UNIFY_Y_LOC_WRITE_HGREATER: + printf("UNIFY_Y_LOC_WRITE_HGREATER\n"); + break; + case UNIFY_Y_LOC_WRITE_HLESS: + printf("UNIFY_Y_LOC_WRITE_HLESS\n"); + break; + case UNIFY_L_Y_LOC_INSTINIT: + printf("UNIFY_L_Y_LOC_INSTINIT\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR: + printf("UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR: + printf("UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK: + printf("UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_UNK: + printf("UNIFY_L_Y_LOC_ULVALY_LOC_UNK\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR: + printf("UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK: + printf("UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK\n"); + break; + case UNIFY_L_Y_LOC_WRITE_INSTINIT: + printf("UNIFY_L_Y_LOC_WRITE_INSTINIT\n"); + break; + case UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR: + printf("UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR\n"); + break; + case UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK: + printf("UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK\n"); + break; + case UNIFY_L_Y_LOC_WRITE_HGREATER: + printf("UNIFY_L_Y_LOC_WRITE_HGREATER\n"); + break; + case UNIFY_L_Y_LOC_WRITE_HLESS: + printf("UNIFY_L_Y_LOC_WRITE_HLESS\n"); + break; + case UNIFY_VOID_INSTINIT: + printf("UNIFY_VOID_INSTINIT\n"); + break; + case UNIFY_VOID_WRITE_INSTINIT: + printf("UNIFY_VOID_WRITE_INSTINIT\n"); + break; + case UNIFY_L_VOID_INSTINIT: + printf("UNIFY_L_VOID_INSTINIT\n"); + break; + case UNIFY_L_VOID_WRITE_INSTINIT: + printf("UNIFY_L_VOID_WRITE_INSTINIT\n"); + break; + case UNIFY_N_VOIDS_INSTINIT: + printf("UNIFY_N_VOIDS_INSTINIT\n"); + break; + case UNIFY_N_VOIDS_WRITE_INSTINIT: + printf("UNIFY_N_VOIDS_WRITE_INSTINIT\n"); + break; + case UNIFY_N_VOIDS_WRITE_INSIDEFOR: + printf("UNIFY_N_VOIDS_WRITE_INSIDEFOR\n"); + break; + case UNIFY_N_VOIDS_WRITE_END: + printf("UNIFY_N_VOIDS_WRITE_END\n"); + break; + case UNIFY_L_N_VOIDS_INSTINIT: + printf("UNIFY_L_N_VOIDS_INSTINIT\n"); + break; + case UNIFY_L_N_VOIDS_WRITE_INSTINIT: + printf("UNIFY_L_N_VOIDS_WRITE_INSTINIT\n"); + break; + case UNIFY_L_N_VOIDS_WRITE_INSIDEFOR: + printf("UNIFY_L_N_VOIDS_WRITE_INSIDEFOR\n"); + break; + case UNIFY_L_N_VOIDS_WRITE_END: + printf("UNIFY_L_N_VOIDS_WRITE_END\n"); + break; + case UNIFY_ATOM_INSTINIT: + printf("UNIFY_ATOM_INSTINIT\n"); + break; + case UNIFY_ATOM_FAIL: + printf("UNIFY_ATOM_FAIL\n"); + break; + case UNIFY_ATOM_UATOM_NONVAR: + printf("UNIFY_ATOM_UATOM_NONVAR\n"); + break; + case UNIFY_ATOM_UATOM_UNK: + printf("UNIFY_ATOM_UATOM_UNK\n"); + break; + case UNIFY_ATOM_WRITE_INSTINIT: + printf("UNIFY_ATOM_WRITE_INSTINIT\n"); + break; + case UNIFY_L_ATOM_INSTINIT: + printf("UNIFY_L_ATOM_INSTINIT\n"); + break; + case UNIFY_L_ATOM_FAIL: + printf("UNIFY_L_ATOM_FAIL\n"); + break; + case UNIFY_L_ATOM_ULATOM_NONVAR: + printf("UNIFY_L_ATOM_ULATOM_NONVAR\n"); + break; + case UNIFY_L_ATOM_ULATOM_UNK: + printf("UNIFY_L_ATOM_ULATOM_UNK\n"); + break; + case UNIFY_L_ATOM_WRITE_INSTINIT: + printf("UNIFY_L_ATOM_WRITE_INSTINIT\n"); + break; + case UNIFY_N_ATOMS_INSTINIT: + printf("UNIFY_N_ATOMS_INSTINIT\n"); + break; + case UNIFY_N_ATOMS_INSIDEFOR_INIT: + printf("UNIFY_N_ATOMS_INSIDEFOR_INIT\n"); + break; + case UNIFY_N_ATOMS_INSIDEFOR_UATOM_N_VAR: + printf("UNIFY_N_ATOMS_INSIDEFOR_UATOM_N_VAR\n"); + break; + case UNIFY_N_ATOMS_END: + printf("UNIFY_N_ATOMS_END\n"); + break; + case UNIFY_N_ATOMS_WRITE_INSTINIT: + printf("UNIFY_N_ATOMS_WRITE_INSTINIT\n"); + break; + case UNIFY_N_ATOMS_WRITE_INSIDEFOR: + printf("UNIFY_N_ATOMS_WRITE_INSIDEFOR\n"); + break; + case UNIFY_N_ATOMS_WRITE_END: + printf("UNIFY_N_ATOMS_WRITE_END\n"); + break; + case UNIFY_FLOAT_INSTINIT: + printf("UNIFY_FLOAT_INSTINIT\n"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_INIT: + printf("UNIFY_FLOAT_UFLOAT_NONVAR_INIT\n"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR: + printf("UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR\n"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_END: + printf("UNIFY_FLOAT_UFLOAT_NONVAR_END\n"); + break; + case UNIFY_FLOAT_UFLOAT_UNK: + printf("UNIFY_FLOAT_UFLOAT_UNK\n"); + break; + case UNIFY_FLOAT_WRITE_INSTINIT: + printf("UNIFY_FLOAT_WRITE_INSTINIT\n"); + break; + case UNIFY_L_FLOAT_INSTINIT: + printf("UNIFY_L_FLOAT_INSTINIT\n"); + break; + case UNIFY_L_FLOAT_D0ISAPPL: + printf("UNIFY_L_FLOAT_D0ISAPPL\n"); + break; + case UNIFY_L_FLOAT_D0ISFUNC: + printf("UNIFY_L_FLOAT_D0ISFUNC\n"); + break; + case UNIFY_L_FLOAT_EQUALS: + printf("UNIFY_L_FLOAT_EQUALS\n"); + break; + case UNIFY_L_FLOAT_ULFLOAT_UNK: + printf("UNIFY_L_FLOAT_ULFLOAT_UNK\n"); + break; + case UNIFY_L_FLOAT_WRITE_INSTINIT: + printf("UNIFY_L_FLOAT_WRITE_INSTINIT\n"); + break; + case UNIFY_LONGINT_INSTINIT: + printf("UNIFY_LONGINT_INSTINIT\n"); + break; + case UNIFY_LONGINT_D0ISAPPL: + printf("UNIFY_LONGINT_D0ISAPPL\n"); + break; + case UNIFY_LONGINT_D0ISFUNC: + printf("UNIFY_LONGINT_D0ISFUNC\n"); + break; + case UNIFY_LONGINT_EQUALS: + printf("UNIFY_LONGINT_EQUALS\n"); + break; + case UNIFY_LONGINT_ULONGINT_UNK: + printf("UNIFY_LONGINT_ULONGINT_UNK\n"); + break; + case UNIFY_LONGINT_WRITE_INSTINIT: + printf("UNIFY_LONGINT_WRITE_INSTINIT\n"); + break; + case UNIFY_L_LONGINT_INSTINIT: + printf("UNIFY_L_LONGINT_INSTINIT\n"); + break; + case UNIFY_L_LONGINT_D0ISAPPL: + printf("UNIFY_L_LONGINT_D0ISAPPL\n"); + break; + case UNIFY_L_LONGINT_D0ISFUNC: + printf("UNIFY_L_LONGINT_D0ISFUNC\n"); + break; + case UNIFY_L_LONGINT_EQUALS: + printf("UNIFY_L_LONGINT_EQUALS\n"); + break; + case UNIFY_L_LONGINT_ULLONGINT_UNK: + printf("UNIFY_L_LONGINT_ULLONGINT_UNK\n"); + break; + case UNIFY_L_LONGINT_WRITE_INSTINIT: + printf("UNIFY_L_LONGINT_WRITE_INSTINIT\n"); + break; +#ifdef USE_GMP + case UNIFY_BIGINT_INSTINIT: + printf("UNIFY_BIGINT_INSTINIT\n"); + break; + case UNIFY_BIGINT_D0ISAPPL: + printf("UNIFY_BIGINT_D0ISAPPL\n"); + break; + case UNIFY_BIGINT_D1ISFUNC_GMP: + printf("UNIFY_BIGINT_D1ISFUNC_GMP\n"); + break; + case UNIFY_BIGINT_UBIGINT_UNK: + printf("UNIFY_BIGINT_UBIGINT_UNK\n"); + break; + case UNIFY_L_BIGINT_INSTINIT: + printf("UNIFY_L_BIGINT_INSTINIT\n"); + break; + case UNIFY_L_BIGINT_D0ISAPPL: + printf("UNIFY_L_BIGINT_D0ISAPPL\n"); + break; + case UNIFY_L_BIGINT_D0ISFUNC_GMP: + printf("UNIFY_L_BIGINT_D0ISFUNC_GMP\n"); + break; + case UNIFY_L_BIGINT_ULBIGINT_UNK: + printf("UNIFY_L_BIGINT_ULBIGINT_UNK\n"); + break; +#endif + case UNIFY_DBTERM_INSTINIT: + printf("UNIFY_DBTERM_INSTINIT\n"); + break; + case UNIFY_DBTERM_UDBTERM_NONVAR: + printf("UNIFY_DBTERM_UDBTERM_NONVAR\n"); + break; + case UNIFY_DBTERM_UDBTERM_UNK: + printf("UNIFY_DBTERM_UDBTERM_UNK\n"); + break; + case UNIFY_L_DBTERM_INSTINIT: + printf("UNIFY_L_DBTERM_INSTINIT\n"); + break; + case UNIFY_L_DBTERM_ULDBTERM_NONVAR: + printf("UNIFY_L_DBTERM_ULDBTERM_NONVAR\n"); + break; + case UNIFY_L_DBTERM_ULDBTERM_UNK: + printf("UNIFY_L_DBTERM_ULDBTERM_UNK\n"); + break; + case UNIFY_LIST_INSTINIT: + printf("UNIFY_LIST_INSTINIT\n"); + break; + case UNIFY_LIST_READMODE: + printf("UNIFY_LIST_READMODE\n"); + break; + case UNIFY_LIST_WRITEMODE: + printf("UNIFY_LIST_WRITEMODE\n"); + break; + case UNIFY_LIST_WRITE_INSTINIT: + printf("UNIFY_LIST_WRITE_INSTINIT\n"); + break; + case UNIFY_L_LIST_INSTINIT: + printf("UNIFY_L_LIST_INSTINIT\n"); + break; + case UNIFY_L_LIST_ULLIST_NONVAR: + printf("UNIFY_L_LIST_ULLIST_NONVAR\n"); + break; + case UNIFY_L_LIST_FAIL: + printf("UNIFY_L_LIST_FAIL\n"); + break; + case UNIFY_L_LIST_READMODE: + printf("UNIFY_L_LIST_READMODE\n"); + break; + case UNIFY_L_LIST_WRITEMODE: + printf("UNIFY_L_LIST_WRITEMODE\n"); + break; + case UNIFY_L_LIST_WRITE_INSTINIT: + printf("UNIFY_L_LIST_WRITE_INSTINIT\n"); + break; + case UNIFY_STRUCT_INSTINIT: + printf("UNIFY_STRUCT_INSTINIT\n"); + break; + case UNIFY_STRUCT_READMODE1: + printf("UNIFY_STRUCT_READMODE1\n"); + break; + case UNIFY_STRUCT_READMODE2: + printf("UNIFY_STRUCT_READMODE2\n"); + break; + case UNIFY_STRUCT_WRITEMODE: + printf("UNIFY_STRUCT_WRITEMODE\n"); + break; + case UNIFY_STRUCT_WRITE_INSTINIT: + printf("UNIFY_STRUCT_WRITE_INSTINIT\n"); + break; + case UNIFY_L_STRUC_INSTINIT: + printf("UNIFY_L_STRUC_INSTINIT\n"); + break; + case UNIFY_L_STRUC_ULSTRUCT_NONVAR: + printf("UNIFY_L_STRUC_ULSTRUCT_NONVAR\n"); + break; + case UNIFY_L_STRUC_READMODE1: + printf("UNIFY_L_STRUC_READMODE1\n"); + break; + case UNIFY_L_STRUC_READMODE2: + printf("UNIFY_L_STRUC_READMODE2\n"); + break; + case UNIFY_L_STRUC_WRITEMODE: + printf("UNIFY_L_STRUC_WRITEMODE\n"); + break; + case UNIFY_L_STRUC_WRITE_INSTINIT: + printf("UNIFY_L_STRUC_WRITE_INSTINIT\n"); + break; + case PUT_X_VAR_INSTINIT: + printf("PUT_X_VAR_INSTINIT\n"); + break; + case PUT_Y_VAR_INSTINIT: + printf("PUT_Y_VAR_INSTINIT\n"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case PUT_Y_VAR_SHARED_VAR: + printf("PUT_Y_VAR_SHARED_VAR\n"); + break; +#endif + case PUT_Y_VAR_NOSHARED_VAR: + printf("PUT_Y_VAR_NOSHARED_VAR\n"); + break; + case PUT_Y_VAR_END: + printf("PUT_Y_VAR_END\n"); + break; + case PUT_X_VAL_INSTINIT: + printf("PUT_X_VAL_INSTINIT\n"); + break; + case PUT_XX_VAL_INSTINIT: + printf("PUT_XX_VAL_INSTINIT\n"); + break; + case PUT_Y_VAL_INSTINIT: + printf("PUT_Y_VAL_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case PUT_Y_VAL_D0ISZERO: + printf("PUT_Y_VAL_D0ISZERO\n"); + break; +#endif + case PUT_Y_VAL_D0ISNOZERO: + printf("PUT_Y_VAL_D0ISNOZERO\n"); + break; + case PUT_Y_VAL_END: + printf("PUT_Y_VAL_END\n"); + break; + case PUT_Y_VALS_INSTINIT: + printf("PUT_Y_VALS_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case PUT_Y_VALS_D0ISZERO: + printf("PUT_Y_VALS_D0ISZERO\n"); + break; +#endif + case PUT_Y_VALS_D0ISNOZERO: + printf("PUT_Y_VALS_D0ISNOZERO\n"); + break; + case PUT_Y_VALS_POST_IF: + printf("PUT_Y_VALS_POST_IF\n"); + break; +#ifdef YAPOR_SBA + case PUT_Y_VALS_D1ISZERO: + printf("PUT_Y_VALS_D1ISZERO\n"); + break; +#endif + case PUT_Y_VALS_D1ISNOZERO: + printf("PUT_Y_VALS_D1ISNOZERO\n"); + break; + case PUT_Y_VALS_END: + printf("PUT_Y_VALS_END\n"); + break; + case PUT_UNSAFE_INSTINIT: + printf("PUT_UNSAFE_INSTINIT\n"); + break; + case PUT_UNSAFE_PUNSAFE_NONVAR: + printf("PUT_UNSAFE_PUNSAFE_NONVAR\n"); + break; + case PUT_UNSAFE_SAFEVAR: + printf("PUT_UNSAFE_SAFEVAR\n"); + break; + case PUT_UNSAFE_UNSAFEVAR: + printf("PUT_UNSAFE_UNSAFEVAR\n"); + break; + case PUT_ATOM_INSTINIT: + printf("PUT_ATOM_INSTINIT\n"); + break; + case PUT_DBTERM_INSTINIT: + printf("PUT_DBTERM_INSTINIT\n"); + break; + case PUT_BIGINT_INSTINIT: + printf("PUT_BIGINT_INSTINIT\n"); + break; + case PUT_FLOAT_INSTINIT: + printf("PUT_FLOAT_INSTINIT\n"); + break; + case PUT_LONGINT_INSTINIT: + printf("PUT_LONGINT_INSTINIT\n"); + break; + case PUT_LIST_INSTINIT: + printf("PUT_LIST_INSTINIT\n"); + break; + case PUT_STRUCT_INSTINIT: + printf("PUT_STRUCT_INSTINIT\n"); + break; + case WRITE_X_VAR_INSTINIT: + printf("WRITE_X_VAR_INSTINIT\n"); + break; + case WRITE_VOID_INSTINIT: + printf("WRITE_VOID_INSTINIT\n"); + break; + case WRITE_N_VOIDS_INSTINIT: + printf("WRITE_N_VOIDS_INSTINIT\n"); + break; + case WRITE_N_VOIDS_INSIDEFOR: + printf("WRITE_N_VOIDS_INSIDEFOR\n"); + break; + case WRITE_N_VOIDS_END: + printf("WRITE_N_VOIDS_END\n"); + break; + case WRITE_Y_VAR_INSTINIT: + printf("WRITE_Y_VAR_INSTINIT\n"); + break; + case WRITE_X_VAL_INSTINIT: + printf("WRITE_X_VAL_INSTINIT\n"); + break; + case WRITE_X_LOC_INSTINIT: + printf("WRITE_X_LOC_INSTINIT\n"); + break; + case WRITE_X_LOC_W_X_BOUND: + printf("WRITE_X_LOC_W_X_BOUND\n"); + break; +#ifdef FROZEN_STACKS + case WRITE_X_LOC_IFOK_FROZEN: + printf("WRITE_X_LOC_IFOK_FROZEN\n"); + break; +#else + case WRITE_X_LOC_IFOK_NOFROZEN: + printf("WRITE_X_LOC_IFOK_NOFROZEN\n"); + break; +#endif + case WRITE_X_LOC_IFOK_END: + printf("WRITE_X_LOC_IFOK_END\n"); + break; + case WRITE_X_LOC_NOIF: + printf("WRITE_X_LOC_NOIF\n"); + break; + case WRITE_Y_VAL_INSTINIT: + printf("WRITE_Y_VAL_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case WRITE_Y_VAL_D0ISZERO: + printf("WRITE_Y_VAL_D0ISZERO\n"); + break; +#endif + case WRITE_Y_VAL_D0ISNOZERO: + printf("WRITE_Y_VAL_D0ISNOZERO\n"); + break; + case WRITE_Y_VAL_END: + printf("WRITE_Y_VAL_END\n"); + break; + case WRITE_Y_LOC_INSTINIT: + printf("WRITE_Y_LOC_INSTINIT\n"); + break; + case WRITE_Y_LOC_W_Y_BOUND: + printf("WRITE_Y_LOC_W_Y_BOUND\n"); + break; + case WRITE_Y_LOC_IFOK_INIT: + printf("WRITE_Y_LOC_IFOK_INIT\n"); + break; +#ifdef FROZEN_STACKS + case WRITE_Y_LOC_IFOK_FROZEN: + printf("WRITE_Y_LOC_IFOK_FROZEN\n"); + break; +#else + case WRITE_Y_LOC_IFOK_NOFROZEN: + printf("WRITE_Y_LOC_IFOK_NOFROZEN\n"); + break; +#endif + case WRITE_Y_LOC_IFOK_END: + printf("WRITE_Y_LOC_IFOK_END\n"); + break; + case WRITE_Y_LOC_NOIF: + printf("WRITE_Y_LOC_NOIF\n"); + break; + case WRITE_ATOM_INSTINIT: + printf("WRITE_ATOM_INSTINIT\n"); + break; + case WRITE_BIGINT_INSTINIT: + printf("WRITE_BIGINT_INSTINIT\n"); + break; + case WRITE_DBTERM_INSTINIT: + printf("WRITE_DBTERM_INSTINIT\n"); + break; + case WRITE_FLOAT_INSTINIT: + printf("WRITE_FLOAT_INSTINIT\n"); + break; + case WRITE_LONGIT_INSTINIT: + printf("WRITE_LONGIT_INSTINIT\n"); + break; + case WRITE_N_ATOMS_INSTINIT: + printf("WRITE_N_ATOMS_INSTINIT\n"); + break; + case WRITE_N_ATOMS_INSIDEFOR: + printf("WRITE_N_ATOMS_INSIDEFOR\n"); + break; + case WRITE_N_ATOMS_END: + printf("WRITE_N_ATOMS_END\n"); + break; + case WRITE_LIST_INSTINIT: + printf("WRITE_LIST_INSTINIT\n"); + break; + case WRITE_L_LIST_INSTINIT: + printf("WRITE_L_LIST_INSTINIT\n"); + break; + case WRITE_STRUCT_INSTINIT: + printf("WRITE_STRUCT_INSTINIT\n"); + break; + case WRITE_L_STRUC_INSTINIT: + printf("WRITE_L_STRUC_INSTINIT\n"); + break; + case SAVE_PAIR_X_INSTINIT: + printf("SAVE_PAIR_X_INSTINIT\n"); + break; + case SAVE_PAIR_X_WRITE_INSTINIT: + printf("SAVE_PAIR_X_WRITE_INSTINIT\n"); + break; + case SAVE_PAIR_Y_INSTINIT: + printf("SAVE_PAIR_Y_INSTINIT\n"); + break; + case SAVE_PAIR_Y_WRITE_INSTINIT: + printf("SAVE_PAIR_Y_WRITE_INSTINIT\n"); + break; + case SAVE_APPL_X_INSTINIT: + printf("SAVE_APPL_X_INSTINIT\n"); + break; + case SAVE_APPL_X_WRITE_INSTINIT: + printf("SAVE_APPL_X_WRITE_INSTINIT\n"); + break; + case SAVE_APPL_Y_INSTINIT: + printf("SAVE_APPL_Y_INSTINIT\n"); + break; + case SAVE_APPL_Y_WRITE_INSTINIT: + printf("SAVE_APPL_Y_WRITE_INSTINIT\n"); + break; + case JUMP_INSTINIT: + printf("JUMP_INSTINIT\n"); + break; + case MOVE_BACK_INSTINIT: + printf("MOVE_BACK_INSTINIT\n"); + break; + case SKIP_INSTINIT: + printf("SKIP_INSTINIT\n"); + break; + case EITHER_INSTINIT: + printf("EITHER_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case EITHER_LOW_LEVEL_TRACER: + printf("EITHER_LOW_LEVEL_TRACER\n"); + break; +#endif + case EITHER_POST_COROUTINING: + printf("EITHER_POST_COROUTINING\n"); + break; +#ifdef FROZEN_STACKS + case EITHER_FROZEN: + printf("EITHER_FROZEN\n"); + break; + case EITHER_FROZEN_TOPB: + printf("EITHER_FROZEN_TOPB\n"); + break; +#else + case EITHER_NOFROZEN: + printf("EITHER_NOFROZEN\n"); + break; +#endif + case EITHER_POST_FROZEN: + printf("EITHER_POST_FROZEN\n"); + break; +#ifdef YAPOR + case EITHER_YAPOR: + printf("EITHER_YAPOR\n"); + break; +#endif + case EITHER_END: + printf("EITHER_END\n"); + break; + case OR_ELSE_INSTINIT: + printf("OR_ELSE_INSTINIT\n"); + break; +#ifdef DEPTH_LIMIT + case OR_ELSE_DEPTH: + printf("OR_ELSE_DEPTH\n"); + break; +#endif + case OR_ELSE_POST_DEPTH: + printf("OR_ELSE_POST_DEPTH\n"); + break; +#ifdef YAPOR + case OR_ELSE_YAPOR: + printf("OR_ELSE_YAPOR\n"); + break; +#endif + case OR_ELSE_END: + printf("OR_ELSE_END\n"); + break; + case OR_LAST_INSTINIT: + printf("OR_LAST_INSTINIT\n"); + break; +#ifdef YAPOR + case OR_LAST_IFOK_INIT: + printf("OR_LAST_IFOK_INIT\n"); + break; +#ifdef DEPTH_LIMIT + case OR_LAST_IFOK_DEPTH: + printf("OR_LAST_IFOK_DEPTH\n"); + break; +#endif + case OR_LAST_IFOK_END: + printf("OR_LAST_IFOK_END\n"); + break; +#endif + case OR_LAST_NOIF_INIT: + printf("OR_LAST_NOIF_INIT\n"); + break; +#ifdef DEPTH_LIMIT + case OR_LAST_NOIF_DEPTH: + printf("OR_LAST_NOIF_DEPTH\n"); + break; +#endif + case OR_LAST_NOIF_END: + printf("OR_LAST_NOIF_END\n"); + break; +#ifdef YAPOR + case OR_LAST_YAPOR: + printf("OR_LAST_YAPOR\n"); + break; +#else + case OR_LAST_NOYAPOR: + printf("OR_LAST_NOYAPOR\n"); + break; +#endif + case OR_LAST_END: + printf("OR_LAST_END\n"); + break; + case POP_N_INSTINIT: + printf("POP_N_INSTINIT\n"); + break; + case POP_N_IFOK: + printf("POP_N_IFOK\n"); + break; + case POP_N_NOIF: + printf("POP_N_NOIF\n"); + break; + case POP_INSTINIT: + printf("POP_INSTINIT\n"); + break; + case POP_IFOK: + printf("POP_IFOK\n"); + break; + case POP_NOIF: + printf("POP_NOIF\n"); + break; + case CALL_CPRED_INSTINIT: + printf("CALL_CPRED_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case CALL_CPRED_FROZEN_INIT: + printf("CALL_CPRED_FROZEN_INIT\n"); + break; + case CALL_CPRED_TOPB: + printf("CALL_CPRED_TOPB\n"); + break; + case CALL_CPRED_NOTOPB: + printf("CALL_CPRED_NOTOPB\n"); + break; +#else + case CALL_CPRED_NOFROZEN: + printf("CALL_CPRED_NOFROZEN\n"); + break; +#endif +#ifdef LOW_LEVEL_TRACER + case CALL_CPRED_LOW_LEVEL_TRACER: + printf("CALL_CPRED_LOW_LEVEL_TRACER\n"); + break; +#endif + case CALL_CPRED_POST_LOW_LEVEL_TRACER: + printf("CALL_CPRED_POST_LOW_LEVEL_TRACER\n"); + break; +#ifdef SHADOW_S + case CALL_CPRED_SETSREG: + printf("CALL_CPRED_SETSREG\n"); + break; +#endif + case CALL_CPRED_END: + printf("CALL_CPRED_END\n"); + break; + case EXECUTE_CPRED_INSTINIT: + printf("EXECUTE_CPRED_INSTINIT\n"); + break; + case EXECUTE_CPRED_POST_CHECK_TRAIL: + printf("EXECUTE_CPRED_POST_CHECK_TRAIL\n"); + break; +#ifdef FROZEN_STACKS + case EXECUTE_CPRED_FROZEN: + printf("EXECUTE_CPRED_FROZEN\n"); + break; + case EXECUTE_CPRED_TOPB: + printf("EXECUTE_CPRED_TOPB\n"); + break; + case EXECUTE_CPRED_NOTOPB: + printf("EXECUTE_CPRED_NOTOPB\n"); + break; +#else + case EXECUTE_CPRED_NOFROZEN: + printf("EXECUTE_CPRED_NOFROZEN\n"); + break; +#endif + case EXECUTE_CPRED_POST_FROZEN: + printf("EXECUTE_CPRED_POST_FROZEN\n"); + break; +#ifdef LOW_LEVEL_TRACER + case EXECUTE_CPRED_LOW_LEVEL_TRACER: + printf("EXECUTE_CPRED_LOW_LEVEL_TRACER\n"); + break; +#endif + case EXECUTE_CPRED_POST_LOW_LEVEL_TRACER: + printf("EXECUTE_CPRED_POST_LOW_LEVEL_TRACER\n"); + break; + case EXECUTE_CPRED_SAVE_PC: + printf("EXECUTE_CPRED_SAVE_PC\n"); + break; +#ifdef DEPTH_LIMIT + case EXECUTE_CPRED_DEPTH_MINOR_NOFAIL: + printf("EXECUTE_CPRED_DEPTH_MINOR_NOFAIL\n"); + break; + case EXECUTE_CPRED_DEPTH_NOMINOR: + printf("EXECUTE_CPRED_DEPTH_NOMINOR\n"); + break; +#endif + case EXECUTE_CPRED_POST_DEPTH: + printf("EXECUTE_CPRED_POST_DEPTH\n"); + break; +#ifdef SHADOW_S + case EXECUTE_CPRED_SHADOW_S: + printf("EXECUTE_CPRED_SHADOW_S\n"); + break; +#endif + case EXECUTE_CPRED_FAIL: + printf("EXECUTE_CPRED_FAIL\n"); + break; + case EXECUTE_CPRED_IFOK_INIT: + printf("EXECUTE_CPRED_IFOK_INIT\n"); + break; +#ifdef DEPTH_LIMIT + case EXECUTE_CPRED_IFOK_DEPTH: + printf("EXECUTE_CPRED_IFOK_DEPTH\n"); + break; +#endif + case EXECUTE_CPRED_WRITEBACK: + printf("EXECUTE_CPRED_WRITEBACK\n"); + break; + case EXECUTE_CPRED_NOIF: + printf("EXECUTE_CPRED_NOIF\n"); + break; + case EXECUTE_CPRED_END: + printf("EXECUTE_CPRED_END\n"); + break; + case CALL_USERCPRED_INSTINIT: + printf("CALL_USERCPRED_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case CALL_USERCPRED_LOW_LEVEL_TRACER: + printf("CALL_USERCPRED_LOW_LEVEL_TRACER\n"); + break; +#endif +#ifdef FROZEN_STACKS + case CALL_USERCPRED_FROZEN: + printf("CALL_USERCPRED_FROZEN\n"); + break; + case CALL_USERCPRED_TOPB: + printf("CALL_USERCPRED_TOPB\n"); + break; + case CALL_USERCPRED_NOTOPB: + printf("CALL_USERCPRED_NOTOPB\n"); + break; +#else + case CALL_USERCPRED_NOFROZEN: + printf("CALL_USERCPRED_NOFROZEN\n"); + break; +#endif + case CALL_USERCPRED_POST_FROZEN: + printf("CALL_USERCPRED_POST_FROZEN\n"); + break; + case CALL_USERCPRED_EX: + printf("CALL_USERCPRED_EX\n"); + break; + case CALL_USERCPRED_FAIL: + printf("CALL_USERCPRED_FAIL\n"); + break; + case CALL_USERCPRED_END: + printf("CALL_USERCPRED_END\n"); + break; + case LOCK_PRED_INSTINIT: + printf("LOCK_PRED_INSTINIT\n"); + break; + case LOCK_PRED_FIRSTIFOK: + printf("LOCK_PRED_FIRSTIFOK\n"); + break; + case LOCK_PRED_SECONDTIFOK: + printf("LOCK_PRED_SECONDTIFOK\n"); + break; + case LOCK_PRED_END: + printf("LOCK_PRED_END\n"); + break; + case INDEX_PRED_INSTINIT: + printf("INDEX_PRED_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case INDEX_PRED_YAPOR_THREADS_NOPP: + printf("INDEX_PRED_YAPOR_THREADS_NOPP\n"); + break; + case INDEX_PRED_YAPOR_THREADS_NOEQUAL_NOPP: + printf("INDEX_PRED_YAPOR_THREADS_NOEQUAL_NOPP\n"); + break; + case INDEX_PRED_YAPOR_THREADS_NOEQUAL: + printf("INDEX_PRED_YAPOR_THREADS_NOEQUAL\n"); + break; +#endif + case INDEX_PRED_NOYAPOR_NOTHREADS: + printf("INDEX_PRED_NOYAPOR_NOTHREADS\n"); + break; + case INDEX_PRED_UNLOCK: + printf("INDEX_PRED_UNLOCK\n"); + break; + case INDEX_PRED_END: + printf("INDEX_PRED_END\n"); + break; +#if THREADS + case THREAD_LOCAL_INSTINIT: + printf("THREAD_LOCAL_INSTINIT\n"); + break; +#endif + case EXPAND_INDEX_INSTINIT: + printf("EXPAND_INDEX_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_INDEX_YAPOR_THREADS_NOPP: + printf("EXPAND_INDEX_YAPOR_THREADS_NOPP\n"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT: + printf("EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT\n"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK: + printf("EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK\n"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_END: + printf("EXPAND_INDEX_YAPOR_THREADS_IFOK_END\n"); + break; +#endif +#ifdef SHADOW_S + case EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS: + printf("EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS\n"); + break; +#endif + case EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS: + printf("EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS\n"); + break; +#ifdef SHADOW_S + case EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG: + printf("EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG\n"); + break; +#endif + case EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG: + printf("EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_INDEX_UNLOCK: + printf("EXPAND_INDEX_UNLOCK\n"); + break; +#endif + case EXPAND_INDEX_END: + printf("EXPAND_INDEX_END\n"); + break; + case EXPAND_CLAUSES_INSTINIT: + printf("EXPAND_CLAUSES_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_CLAUSES_YAPOR_THREADS_NOPP: + printf("EXPAND_CLAUSES_YAPOR_THREADS_NOPP\n"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT: + printf("EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT\n"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK: + printf("EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK\n"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END: + printf("EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END\n"); + break; +#endif + case EXPAND_CLAUSES_NOYAPOR_NOTHREADS: + printf("EXPAND_CLAUSES_NOYAPOR_NOTHREADS\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_CLAUSES_UNLOCK: + printf("EXPAND_CLAUSES_UNLOCK\n"); + break; +#endif + case EXPAND_CLAUSES_END: + printf("EXPAND_CLAUSES_END\n"); + break; + case UNDEF_P_INSTINIT: + printf("UNDEF_P_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case UNDEF_P_SETPP: + printf("UNDEF_P_SETPP\n"); + break; +#endif + case UNDEF_P_UNLOCKANDFAIL: + printf("UNDEF_P_UNLOCKANDFAIL\n"); + break; + case UNDEF_P_POST_FIRSTIF: + printf("UNDEF_P_POST_FIRSTIF\n"); + break; + case UNDEF_P_D0ISZERO: + printf("UNDEF_P_D0ISZERO\n"); + break; + case UNDEF_P_D0ISNOZERO_INIT: + printf("UNDEF_P_D0ISNOZERO_INIT\n"); + break; + case UNDEF_P_D0ISNOZERO_INSIDEFOR_INIT: + printf("UNDEF_P_D0ISNOZERO_INSIDEFOR_INIT\n"); + break; + case UNDEF_P_D0ISNOZERO_INSIDEFOR_UNDEF_NONVAR: + printf("UNDEF_P_D0ISNOZERO_INSIDEFOR_UNDEF_NONVAR\n"); + break; + case UNDEF_P_D0ISNOZERO_INSIDEFOR_SAFEVAR: + printf("UNDEF_P_D0ISNOZERO_INSIDEFOR_SAFEVAR\n"); + break; + case UNDEF_P_D0ISNOZERO_INSIDEFOR_UNSAFEVAR: + printf("UNDEF_P_D0ISNOZERO_INSIDEFOR_UNSAFEVAR\n"); + break; + case UNDEF_P_POST_SECONDIF: + printf("UNDEF_P_POST_SECONDIF\n"); + break; +#ifdef LOW_LEVEL_TRACER + case UNDEF_P_LOW_LEVEL_TRACER: + printf("UNDEF_P_LOW_LEVEL_TRACER\n"); + break; +#endif + case UNDEF_P_END: + printf("UNDEF_P_END\n"); + break; + case SPY_PRED_INSTINIT: + printf("SPY_PRED_INSTINIT\n"); + break; + case SPY_PRED_FIRSTIFOK: + printf("SPY_PRED_FIRSTIFOK\n"); + break; + case SPY_PRED_SECONDIFOK_INIT: + printf("SPY_PRED_SECONDIFOK_INIT\n"); + break; + case SPY_PRED_SECONDIFOK_FIRSTIFOK: + printf("SPY_PRED_SECONDIFOK_FIRSTIFOK\n"); + break; + case SPY_PRED_SECONDIFOK_POST_FIRSTIF: + printf("SPY_PRED_SECONDIFOK_POST_FIRSTIF\n"); + break; + case SPY_PRED_SECONDIFOK_SECONDIFOK: + printf("SPY_PRED_SECONDIFOK_SECONDIFOK\n"); + break; + case SPY_PRED_SECONDIFOK_THIRDIFOK: + printf("SPY_PRED_SECONDIFOK_THIRDIFOK\n"); + break; + case SPY_PRED_THIRDIFOK_INIT: + printf("SPY_PRED_THIRDIFOK_INIT\n"); + break; + case SPY_PRED_THIRDIFOK_FIRSTIFOK: + printf("SPY_PRED_THIRDIFOK_FIRSTIFOK\n"); + break; + case SPY_PRED_FOURTHIFOK: + printf("SPY_PRED_FOURTHIFOK\n"); + break; + case SPY_PRED_POST_FOURTHIF: + printf("SPY_PRED_POST_FOURTHIF\n"); + break; + case SPY_PRED_D0ISZERO: + printf("SPY_PRED_D0ISZERO\n"); + break; + case SPY_PRED_D0ISNOZERO_INIT: + printf("SPY_PRED_D0ISNOZERO_INIT\n"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT: + printf("SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT\n"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR: + printf("SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR\n"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR: + printf("SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR\n"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR: + printf("SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR\n"); + break; + case SPY_PRED_POST_IFS: + printf("SPY_PRED_POST_IFS\n"); + break; +#ifdef THREADS + case SPY_PRED_THREADS_LOCK: + printf("SPY_PRED_THREADS_LOCK\n"); + break; +#endif + case SPY_PRED_POST_LOCK: + printf("SPY_PRED_POST_LOCK\n"); + break; +#ifdef THREADS + case SPY_PRED_THREADS_UNLOCK: + printf("SPY_PRED_THREADS_UNLOCK\n"); + break; +#endif + case SPY_PRED_POST_UNLOCK: + printf("SPY_PRED_POST_UNLOCK\n"); + break; +#ifdef LOW_LEVEL_TRACER + case SPY_PRED_LOW_LEVEL_TRACER: + printf("SPY_PRED_LOW_LEVEL_TRACER\n"); + break; +#endif + case SPY_PRED_END: + printf("SPY_PRED_END\n"); + break; + case TRY_CLAUSE_INSTINIT: + printf("TRY_CLAUSE_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_CLAUSE_YAPOR: + printf("TRY_CLAUSE_YAPOR\n"); + break; +#endif + case TRY_CLAUSE_END: + printf("TRY_CLAUSE_END\n"); + break; + case TRY_CLAUSE2_INSTINIT: + printf("TRY_CLAUSE2_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_CLAUSE2_YAPOR: + printf("TRY_CLAUSE2_YAPOR\n"); + break; +#endif + case TRY_CLAUSE2_END: + printf("TRY_CLAUSE2_END\n"); + break; + case TRY_CLAUSE3_INSTINIT: + printf("TRY_CLAUSE3_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_CLAUSE3_YAPOR: + printf("TRY_CLAUSE3_YAPOR\n"); + break; +#endif + case TRY_CLAUSE3_END: + printf("TRY_CLAUSE3_END\n"); + break; + case TRY_CLAUSE4_INSTINIT: + printf("TRY_CLAUSE4_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_CLAUSE4_YAPOR: + printf("TRY_CLAUSE4_YAPOR\n"); + break; +#endif + case TRY_CLAUSE4_END: + printf("TRY_CLAUSE4_END\n"); + break; + case RETRY_INSTINIT: + printf("RETRY_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY_FROZEN: + printf("RETRY_FROZEN\n"); + break; +#else + case RETRY_NOFROZEN: + printf("RETRY_NOFROZEN\n"); + break; +#endif + case RETRY_END: + printf("RETRY_END\n"); + break; + case RETRY2_INSTINIT: + printf("RETRY2_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY2_FROZEN: + printf("RETRY2_FROZEN\n"); + break; +#else + case RETRY2_NOFROZEN: + printf("RETRY2_NOFROZEN\n"); + break; +#endif + case RETRY2_END: + printf("RETRY2_END\n"); + break; + case RETRY3_INSTINIT: + printf("RETRY3_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY3_FROZEN: + printf("RETRY3_FROZEN\n"); + break; +#else + case RETRY3_NOFROZEN: + printf("RETRY3_NOFROZEN\n"); + break; +#endif + case RETRY3_END: + printf("RETRY3_END\n"); + break; + case RETRY4_INSTINIT: + printf("RETRY4_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY4_FROZEN: + printf("RETRY4_FROZEN\n"); + break; +#else + case RETRY4_NOFROZEN: + printf("RETRY4_NOFROZEN\n"); + break; +#endif + case RETRY4_END: + printf("RETRY4_END\n"); + break; + case TRUST_INSTINIT: + printf("TRUST_INSTINIT\n"); + break; +#ifdef YAPOR + case TRUST_IFOK_INIT: + printf("TRUST_IFOK_INIT\n"); + break; +#ifdef FROZEN_STACKS + case TRUST_IFOK_FROZEN: + printf("TRUST_IFOK_FROZEN\n"); + break; +#endif + case TRUST_IFOK_END: + printf("TRUST_IFOK_END\n"); + break; +#endif + case TRUST_NOIF_INIT: + printf("TRUST_NOIF_INIT\n"); + break; +#ifdef FROZEN_STACKS + case TRUST_NOIF_FROZEN: + printf("TRUST_NOIF_FROZEN\n"); + break; +#endif + case TRUST_END: + printf("TRUST_END\n"); + break; + case TRY_IN_INSTINIT: + printf("TRY_IN_INSTINIT\n"); + break; + case USER_SWITCH_INSTINIT: + printf("USER_SWITCH_INSTINIT\n"); + break; + case SWITCH_ON_TYPE_INSTINIT: + printf("SWITCH_ON_TYPE_INSTINIT\n"); + break; + case SWITCH_LIST_NL_INSTINIT: + printf("SWITCH_LIST_NL_INSTINIT\n"); + break; + case SWITCH_ON_ARG_TYPE_INSTINIT: + printf("SWITCH_ON_ARG_TYPE_INSTINIT\n"); + break; + case SWITCH_ON_SUB_ARG_TYPE_INSTINIT: + printf("SWITCH_ON_SUB_ARG_TYPE_INSTINIT\n"); + break; + case JUMP_IF_VAR_INSTINIT: + printf("JUMP_IF_VAR_INSTINIT\n"); + break; + case JUMP_IF_NONVAR_INSTINIT: + printf("JUMP_IF_NONVAR_INSTINIT\n"); + break; + case IF_NOT_THEN_INSTINIT: + printf("IF_NOT_THEN_INSTINIT\n"); + break; + case IF_NOT_THEN_END: + printf("IF_NOT_THEN_END\n"); + break; + case SWITCH_ON_FUNC_INSTINIT: + printf("SWITCH_ON_FUNC_INSTINIT\n"); + break; + case SWITCH_ON_CONS_INSTINIT: + printf("SWITCH_ON_CONS_INSTINIT\n"); + break; + case GO_ON_FUNC_INSTINIT: + printf("GO_ON_FUNC_INSTINIT\n"); + break; + case GO_ON_CONS_INSTINIT: + printf("GO_ON_CONS_INSTINIT\n"); + break; + case IF_FUNC_INSTINIT: + printf("IF_FUNC_INSTINIT\n"); + break; + case IF_CONS_INSTINIT: + printf("IF_CONS_INSTINIT\n"); + break; + case INDEX_DBREF_INSTINIT: + printf("INDEX_DBREF_INSTINIT\n"); + break; + case INDEX_BLOB_INSTINIT: + printf("INDEX_BLOB_INSTINIT\n"); + break; + case INDEX_LONG_INSTINIT: + printf("INDEX_LONG_INSTINIT\n"); + break; + case JIT_HANDLER_INSTINIT: + printf("JIT_HANDLER_INSTINIT\n"); + break; + case P_ATOM_X_INSTINIT: + printf("P_ATOM_X_INSTINIT\n"); + break; + case P_ATOM_X_IFOK: + printf("P_ATOM_X_IFOK\n"); + break; + case P_ATOM_X_NOIF: + printf("P_ATOM_X_NOIF\n"); + break; + case P_ATOM_X_END: + printf("P_ATOM_X_END\n"); + break; + case P_ATOM_Y_INSTINIT: + printf("P_ATOM_Y_INSTINIT\n"); + break; + case P_ATOM_Y_IFOK: + printf("P_ATOM_Y_IFOK\n"); + break; + case P_ATOM_Y_NOIF: + printf("P_ATOM_Y_NOIF\n"); + break; + case P_ATOM_Y_END: + printf("P_ATOM_Y_END\n"); + break; + case P_ATOMIC_X_INSTINIT: + printf("P_ATOMIC_X_INSTINIT\n"); + break; + case P_ATOMIC_X_NONVAR: + printf("P_ATOMIC_X_NONVAR\n"); + break; + case P_ATOMIC_X_VAR: + printf("P_ATOMIC_X_VAR\n"); + break; + case P_ATOMIC_X_END: + printf("P_ATOMIC_X_END\n"); + break; + case P_ATOMIC_Y_INSTINIT: + printf("P_ATOMIC_Y_INSTINIT\n"); + break; + case P_ATOMIC_Y_NONVAR: + printf("P_ATOMIC_Y_NONVAR\n"); + break; + case P_ATOMIC_Y_VAR: + printf("P_ATOMIC_Y_VAR\n"); + break; + case P_ATOMIC_Y_END: + printf("P_ATOMIC_Y_END\n"); + break; + case P_INTEGER_X_INSTINIT: + printf("P_INTEGER_X_INSTINIT\n"); + break; + case P_INTEGER_X_INT: + printf("P_INTEGER_X_INT\n"); + break; + case P_INTEGER_X_FUNCTORINT: + printf("P_INTEGER_X_FUNCTORINT\n"); + break; + case P_INTEGER_X_FUNCTORDEFAULT: + printf("P_INTEGER_X_FUNCTORDEFAULT\n"); + break; + case P_INTEGER_X_POST_IF: + printf("P_INTEGER_X_POST_IF\n"); + break; + case P_INTEGER_X_INTEGER_X_UNK: + printf("P_INTEGER_X_INTEGER_X_UNK\n"); + break; + case P_INTEGER_Y_INSTINIT: + printf("P_INTEGER_Y_INSTINIT\n"); + break; + case P_INTEGER_Y_INT: + printf("P_INTEGER_Y_INT\n"); + break; + case P_INTEGER_Y_FUNCTORINT: + printf("P_INTEGER_Y_FUNCTORINT\n"); + break; + case P_INTEGER_Y_FUNCTORDEFAULT: + printf("P_INTEGER_Y_FUNCTORDEFAULT\n"); + break; + case P_INTEGER_Y_POST_IF: + printf("P_INTEGER_Y_POST_IF\n"); + break; + case P_INTEGER_Y_INTEGER_Y_UNK: + printf("P_INTEGER_Y_INTEGER_Y_UNK\n"); + break; + case P_NONVAR_X_INSTINIT: + printf("P_NONVAR_X_INSTINIT\n"); + break; + case P_NONVAR_X_NONVAR_X_NVAR: + printf("P_NONVAR_X_NONVAR_X_NVAR\n"); + break; + case P_NONVAR_X_NONVAR_X_UNK: + printf("P_NONVAR_X_NONVAR_X_UNK\n"); + break; + case P_NONVAR_Y_INSTINIT: + printf("P_NONVAR_Y_INSTINIT\n"); + break; + case P_NONVAR_Y_NONVAR_Y_NVAR: + printf("P_NONVAR_Y_NONVAR_Y_NVAR\n"); + break; + case P_NONVAR_Y_NONVAR_Y_UNK: + printf("P_NONVAR_Y_NONVAR_Y_UNK\n"); + break; + case P_NUMBER_X_INSTINIT: + printf("P_NUMBER_X_INSTINIT\n"); + break; + case P_NUMBER_X_INT: + printf("P_NUMBER_X_INT\n"); + break; + case P_NUMBER_X_FUNCTORINT: + printf("P_NUMBER_X_FUNCTORINT\n"); + break; + case P_NUMBER_X_FUNCTORDEFAULT: + printf("P_NUMBER_X_FUNCTORDEFAULT\n"); + break; + case P_NUMBER_X_POST_IF: + printf("P_NUMBER_X_POST_IF\n"); + break; + case P_NUMBER_X_NUMBER_X_UNK: + printf("P_NUMBER_X_NUMBER_X_UNK\n"); + break; + case P_NUMBER_Y_INSTINIT: + printf("P_NUMBER_Y_INSTINIT\n"); + break; + case P_NUMBER_Y_INT: + printf("P_NUMBER_Y_INT\n"); + break; + case P_NUMBER_Y_FUNCTORINT: + printf("P_NUMBER_Y_FUNCTORINT\n"); + break; + case P_NUMBER_Y_FUNCTORDEFAULT: + printf("P_NUMBER_Y_FUNCTORDEFAULT\n"); + break; + case P_NUMBER_Y_POST_IF: + printf("P_NUMBER_Y_POST_IF\n"); + break; + case P_NUMBER_Y_NUMBER_Y_UNK: + printf("P_NUMBER_Y_NUMBER_Y_UNK\n"); + break; + case P_VAR_X_INSTINIT: + printf("P_VAR_X_INSTINIT\n"); + break; + case P_VAR_X_NONVAR: + printf("P_VAR_X_NONVAR\n"); + break; + case P_VAR_X_VAR_X_UNK: + printf("P_VAR_X_VAR_X_UNK\n"); + break; + case P_VAR_Y_INSTINIT: + printf("P_VAR_Y_INSTINIT\n"); + break; + case P_VAR_Y_NONVAR: + printf("P_VAR_Y_NONVAR\n"); + break; + case P_VAR_Y_VAR_Y_UNK: + printf("P_VAR_Y_VAR_Y_UNK\n"); + break; + case P_DB_REF_X_INSTINIT: + printf("P_DB_REF_X_INSTINIT\n"); + break; + case P_DB_REF_X_DBREF: + printf("P_DB_REF_X_DBREF\n"); + break; + case P_DB_REF_X_NODBREF: + printf("P_DB_REF_X_NODBREF\n"); + break; + case P_DB_REF_X_DBREF_X_UNK: + printf("P_DB_REF_X_DBREF_X_UNK\n"); + break; + case P_DB_REF_Y_INSTINIT: + printf("P_DB_REF_Y_INSTINIT\n"); + break; + case P_DB_REF_Y_DBREF: + printf("P_DB_REF_Y_DBREF\n"); + break; + case P_DB_REF_Y_NODBREF: + printf("P_DB_REF_Y_NODBREF\n"); + break; + case P_DB_REF_Y_DBREF_Y_UNK: + printf("P_DB_REF_Y_DBREF_Y_UNK\n"); + break; + case P_PRIMITIVE_X_INSTINIT: + printf("P_PRIMITIVE_X_INSTINIT\n"); + break; + case P_PRIMITIVE_X_PRIMITIVE: + printf("P_PRIMITIVE_X_PRIMITIVE\n"); + break; + case P_PRIMITIVE_X_NOPRIMITIVE: + printf("P_PRIMITIVE_X_NOPRIMITIVE\n"); + break; + case P_PRIMITIVE_X_PRIMI_X_UNK: + printf("P_PRIMITIVE_X_PRIMI_X_UNK\n"); + break; + case P_PRIMITIVE_Y_INSTINIT: + printf("P_PRIMITIVE_Y_INSTINIT\n"); + break; + case P_PRIMITIVE_Y_PRIMITIVE: + printf("P_PRIMITIVE_Y_PRIMITIVE\n"); + break; + case P_PRIMITIVE_Y_NOPRIMITIVE: + printf("P_PRIMITIVE_Y_NOPRIMITIVE\n"); + break; + case P_PRIMITIVE_Y_PRIMI_Y_UNK: + printf("P_PRIMITIVE_Y_PRIMI_Y_UNK\n"); + break; + case P_COMPOUND_X_INSTINIT: + printf("P_COMPOUND_X_INSTINIT\n"); + break; + case P_COMPOUND_X_PAIR: + printf("P_COMPOUND_X_PAIR\n"); + break; + case P_COMPOUND_X_APPL_IFOK: + printf("P_COMPOUND_X_APPL_IFOK\n"); + break; + case P_COMPOUND_X_APPL: + printf("P_COMPOUND_X_APPL\n"); + break; + case P_COMPOUND_X_NOAPPL: + printf("P_COMPOUND_X_NOAPPL\n"); + break; + case P_COMPOUND_X_COMPOUND_X_UNK: + printf("P_COMPOUND_X_COMPOUND_X_UNK\n"); + break; + case P_COMPOUND_Y_INSTINIT: + printf("P_COMPOUND_Y_INSTINIT\n"); + break; + case P_COMPOUND_Y_PAIR: + printf("P_COMPOUND_Y_PAIR\n"); + break; + case P_COMPOUND_Y_APPL_IFOK: + printf("P_COMPOUND_Y_APPL_IFOK\n"); + break; + case P_COMPOUND_Y_APPL: + printf("P_COMPOUND_Y_APPL\n"); + break; + case P_COMPOUND_Y_NOAPPL: + printf("P_COMPOUND_Y_NOAPPL\n"); + break; + case P_COMPOUND_Y_COMPOUND_Y_UNK: + printf("P_COMPOUND_Y_COMPOUND_Y_UNK\n"); + break; + case P_FLOAT_X_INSTINIT: + printf("P_FLOAT_X_INSTINIT\n"); + break; + case P_FLOAT_X_FLOAT: + printf("P_FLOAT_X_FLOAT\n"); + break; + case P_FLOAT_X_POST_IF: + printf("P_FLOAT_X_POST_IF\n"); + break; + case P_FLOAT_X_FLOAT_X_UNK: + printf("P_FLOAT_X_FLOAT_X_UNK\n"); + break; + case P_FLOAT_Y_INSTINIT: + printf("P_FLOAT_Y_INSTINIT\n"); + break; + case P_FLOAT_Y_FLOAT: + printf("P_FLOAT_Y_FLOAT\n"); + break; + case P_FLOAT_Y_POST_IF: + printf("P_FLOAT_Y_POST_IF\n"); + break; + case P_FLOAT_Y_FLOAT_Y_UNK: + printf("P_FLOAT_Y_FLOAT_Y_UNK\n"); + break; + case P_PLUS_VV_INSTINIT: + printf("P_PLUS_VV_INSTINIT\n"); + break; + case P_PLUS_VV_PLUS_VV_NVAR: + printf("P_PLUS_VV_PLUS_VV_NVAR\n"); + break; + case P_PLUS_VV_INTTERM: + printf("P_PLUS_VV_INTTERM\n"); + break; + case P_PLUS_VV_NOINTTERM: + printf("P_PLUS_VV_NOINTTERM\n"); + break; + case P_PLUS_VV_D0EQUALS0L: + printf("P_PLUS_VV_D0EQUALS0L\n"); + break; + case P_PLUS_VV_NVAR_END: + printf("P_PLUS_VV_NVAR_END\n"); + break; + case P_PLUS_VV_PLUS_VV_UNK: + printf("P_PLUS_VV_PLUS_VV_UNK\n"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_UNK: + printf("P_PLUS_VV_PLUS_VV_NVAR_UNK\n"); + break; + case P_PLUS_VC_INSTINIT: + printf("P_PLUS_VC_INSTINIT\n"); + break; + case P_PLUS_VC_INTTERM: + printf("P_PLUS_VC_INTTERM\n"); + break; + case P_PLUS_VC_NOINTTERM: + printf("P_PLUS_VC_NOINTTERM\n"); + break; + case P_PLUS_VC_D0EQUALS0L: + printf("P_PLUS_VC_D0EQUALS0L\n"); + break; + case P_PLUS_VC_NVAR_END: + printf("P_PLUS_VC_NVAR_END\n"); + break; + case P_PLUS_VC_PLUS_VC_UNK: + printf("P_PLUS_VC_PLUS_VC_UNK\n"); + break; + case P_PLUS_Y_VV_INSTINIT: + printf("P_PLUS_Y_VV_INSTINIT\n"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR: + printf("P_PLUS_Y_VV_PLUS_Y_VV_NVAR\n"); + break; + case P_PLUS_Y_VV_INTTERM: + printf("P_PLUS_Y_VV_INTTERM\n"); + break; + case P_PLUS_Y_VV_NOINTTERM: + printf("P_PLUS_Y_VV_NOINTTERM\n"); + break; + case P_PLUS_Y_VV_D0EQUALS0L: + printf("P_PLUS_Y_VV_D0EQUALS0L\n"); + break; + case P_PLUS_Y_VV_NVAR_END: + printf("P_PLUS_Y_VV_NVAR_END\n"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_UNK: + printf("P_PLUS_Y_VV_PLUS_Y_VV_UNK\n"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK: + printf("P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK\n"); + break; + case P_PLUS_Y_VC_INSTINIT: + printf("P_PLUS_Y_VC_INSTINIT\n"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_NVAR: + printf("P_PLUS_Y_VC_PLUS_Y_VC_NVAR\n"); + break; + case P_PLUS_Y_VC_INTTERM: + printf("P_PLUS_Y_VC_INTTERM\n"); + break; + case P_PLUS_Y_VC_NOINTTERM: + printf("P_PLUS_Y_VC_NOINTTERM\n"); + break; + case P_PLUS_Y_VC_D0EQUALS0L: + printf("P_PLUS_Y_VC_D0EQUALS0L\n"); + break; + case P_PLUS_Y_VC_NVAR_END: + printf("P_PLUS_Y_VC_NVAR_END\n"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_UNK: + printf("P_PLUS_Y_VC_PLUS_Y_VC_UNK\n"); + break; + case P_MINUS_VV_INSTINIT: + printf("P_MINUS_VV_INSTINIT\n"); + break; + case P_MINUS_VV_MINUS_VV_NVAR: + printf("P_MINUS_VV_MINUS_VV_NVAR\n"); + break; + case P_MINUS_VV_INTTERM: + printf("P_MINUS_VV_INTTERM\n"); + break; + case P_MINUS_VV_NOINTTERM: + printf("P_MINUS_VV_NOINTTERM\n"); + break; + case P_MINUS_VV_D0EQUALS0L: + printf("P_MINUS_VV_D0EQUALS0L\n"); + break; + case P_MINUS_VV_NVAR_END: + printf("P_MINUS_VV_NVAR_END\n"); + break; + case P_MINUS_VV_MINUS_VV_UNK: + printf("P_MINUS_VV_MINUS_VV_UNK\n"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_UNK: + printf("P_MINUS_VV_MINUS_VV_NVAR_UNK\n"); + break; + case P_MINUS_CV_INSTINIT: + printf("P_MINUS_CV_INSTINIT\n"); + break; + case P_MINUS_CV_MINUS_CV_NVAR: + printf("P_MINUS_CV_MINUS_CV_NVAR\n"); + break; + case P_MINUS_CV_INTTERM: + printf("P_MINUS_CV_INTTERM\n"); + break; + case P_MINUS_CV_NOINTTERM: + printf("P_MINUS_CV_NOINTTERM\n"); + break; + case P_MINUS_CV_D0EQUALS0L: + printf("P_MINUS_CV_D0EQUALS0L\n"); + break; + case P_MINUS_CV_NVAR_END: + printf("P_MINUS_CV_NVAR_END\n"); + break; + case P_MINUS_CV_MINUS_CV_UNK: + printf("P_MINUS_CV_MINUS_CV_UNK\n"); + break; + case P_MINUS_Y_VV_INSTINIT: + printf("P_MINUS_Y_VV_INSTINIT\n"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_NVAR: + printf("P_MINUS_Y_VV_MINUS_Y_VV_NVAR\n"); + break; + case P_MINUS_Y_VV_INTTERM: + printf("P_MINUS_Y_VV_INTTERM\n"); + break; + case P_MINUS_Y_VV_NOINTTERM: + printf("P_MINUS_Y_VV_NOINTTERM\n"); + break; + case P_MINUS_Y_VV_D0EQUALS0L: + printf("P_MINUS_Y_VV_D0EQUALS0L\n"); + break; + case P_MINUS_Y_VV_NVAR_END: + printf("P_MINUS_Y_VV_NVAR_END\n"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_UNK: + printf("P_MINUS_Y_VV_MINUS_Y_VV_UNK\n"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK: + printf("P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK\n"); + break; + case P_MINUS_Y_CV_INSTINIT: + printf("P_MINUS_Y_CV_INSTINIT\n"); + break; + case P_MINUS_Y_CV_MINUS_Y_CV_NVAR: + printf("P_MINUS_Y_CV_MINUS_Y_CV_NVAR\n"); + break; + case P_MINUS_Y_CV_INTTERM: + printf("P_MINUS_Y_CV_INTTERM\n"); + break; + case P_MINUS_Y_CV_NOINTTERM: + printf("P_MINUS_Y_CV_NOINTTERM\n"); + break; + case P_MINUS_Y_CV_D0EQUALS0L: + printf("P_MINUS_Y_CV_D0EQUALS0L\n"); + break; + case P_MINUS_Y_CV_NVAR_END: + printf("P_MINUS_Y_CV_NVAR_END\n"); + break; + case P_MINUS_Y_CV_MINUS_Y_CV_UNK: + printf("P_MINUS_Y_CV_MINUS_Y_CV_UNK\n"); + break; + case P_TIMES_VV_INSTINIT: + printf("P_TIMES_VV_INSTINIT\n"); + break; + case P_TIMES_VV_TIMES_VV_NVAR: + printf("P_TIMES_VV_TIMES_VV_NVAR\n"); + break; + case P_TIMES_VV_INTTERM: + printf("P_TIMES_VV_INTTERM\n"); + break; + case P_TIMES_VV_NOINTTERM: + printf("P_TIMES_VV_NOINTTERM\n"); + break; + case P_TIMES_VV_D0EQUALS0L: + printf("P_TIMES_VV_D0EQUALS0L\n"); + break; + case P_TIMES_VV_NVAR_END: + printf("P_TIMES_VV_NVAR_END\n"); + break; + case P_TIMES_VV_TIMES_VV_UNK: + printf("P_TIMES_VV_TIMES_VV_UNK\n"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_UNK: + printf("P_TIMES_VV_TIMES_VV_NVAR_UNK\n"); + break; + case P_TIMES_VC_INSTINIT: + printf("P_TIMES_VC_INSTINIT\n"); + break; + case P_TIMES_VC_TIMES_VC_NVAR: + printf("P_TIMES_VC_TIMES_VC_NVAR\n"); + break; + case P_TIMES_VC_INTTERM: + printf("P_TIMES_VC_INTTERM\n"); + break; + case P_TIMES_VC_NOINTTERM: + printf("P_TIMES_VC_NOINTTERM\n"); + break; + case P_TIMES_VC_D0EQUALS0L: + printf("P_TIMES_VC_D0EQUALS0L\n"); + break; + case P_TIMES_VC_NVAR_END: + printf("P_TIMES_VC_NVAR_END\n"); + break; + case P_TIMES_VC_TIMES_VC_UNK: + printf("P_TIMES_VC_TIMES_VC_UNK\n"); + break; + case P_TIMES_Y_VV_INSTINIT: + printf("P_TIMES_Y_VV_INSTINIT\n"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_NVAR: + printf("P_TIMES_Y_VV_TIMES_Y_VV_NVAR\n"); + break; + case P_TIMES_Y_VV_INTTERM: + printf("P_TIMES_Y_VV_INTTERM\n"); + break; + case P_TIMES_Y_VV_NOINTTERM: + printf("P_TIMES_Y_VV_NOINTTERM\n"); + break; + case P_TIMES_Y_VV_D0EQUALS0L: + printf("P_TIMES_Y_VV_D0EQUALS0L\n"); + break; + case P_TIMES_Y_VV_NVAR_END: + printf("P_TIMES_Y_VV_NVAR_END\n"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_UNK: + printf("P_TIMES_Y_VV_TIMES_Y_VV_UNK\n"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK: + printf("P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK\n"); + break; + case P_TIMES_Y_VC_INSTINIT: + printf("P_TIMES_Y_VC_INSTINIT\n"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_NVAR: + printf("P_TIMES_Y_VC_TIMES_Y_VC_NVAR\n"); + break; + case P_TIMES_Y_VC_INTTERM: + printf("P_TIMES_Y_VC_INTTERM\n"); + break; + case P_TIMES_Y_VC_NOINTTERM: + printf("P_TIMES_Y_VC_NOINTTERM\n"); + break; + case P_TIMES_Y_VC_D0EQUALS0L: + printf("P_TIMES_Y_VC_D0EQUALS0L\n"); + break; + case P_TIMES_Y_VC_NVAR_END: + printf("P_TIMES_Y_VC_NVAR_END\n"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_UNK: + printf("P_TIMES_Y_VC_TIMES_Y_VC_UNK\n"); + break; + case P_DIV_VV_INSTINIT: + printf("P_DIV_VV_INSTINIT\n"); + break; + case P_DIV_VV_DIV_VV_NVAR: + printf("P_DIV_VV_DIV_VV_NVAR\n"); + break; + case P_DIV_VV_INTTERM: + printf("P_DIV_VV_INTTERM\n"); + break; + case P_DIV_VV_DIVEQUALS0: + printf("P_DIV_VV_DIVEQUALS0\n"); + break; + case P_DIV_VV_MKINT: + printf("P_DIV_VV_MKINT\n"); + break; + case P_DIV_VV_NOINTTERM: + printf("P_DIV_VV_NOINTTERM\n"); + break; + case P_DIV_VV_D0EQUALS0L: + printf("P_DIV_VV_D0EQUALS0L\n"); + break; + case P_DIV_VV_D0NOEQUALS0L: + printf("P_DIV_VV_D0NOEQUALS0L\n"); + break; + case P_DIV_VV_DIV_VV_UNK: + printf("P_DIV_VV_DIV_VV_UNK\n"); + break; + case P_DIV_VV_DIV_VV_NVAR_UNK: + printf("P_DIV_VV_DIV_VV_NVAR_UNK\n"); + break; + case P_DIV_VC_INSTINIT: + printf("P_DIV_VC_INSTINIT\n"); + break; + case P_DIV_VC_DIV_VC_NVAR: + printf("P_DIV_VC_DIV_VC_NVAR\n"); + break; + case P_DIV_VC_INTTERM: + printf("P_DIV_VC_INTTERM\n"); + break; + case P_DIV_VC_NOINTTERM: + printf("P_DIV_VC_NOINTTERM\n"); + break; + case P_DIV_VC_D0EQUALS0L: + printf("P_DIV_VC_D0EQUALS0L\n"); + break; + case P_DIV_VC_NVAR_END: + printf("P_DIV_VC_NVAR_END\n"); + break; + case P_DIV_VC_DIV_VC_UNK: + printf("P_DIV_VC_DIV_VC_UNK\n"); + break; + case P_DIV_CV_INSTINIT: + printf("P_DIV_CV_INSTINIT\n"); + break; + case P_DIV_CV_DIV_CV_NVAR: + printf("P_DIV_CV_DIV_CV_NVAR\n"); + break; + case P_DIV_CV_INTTERM_INIT: + printf("P_DIV_CV_INTTERM_INIT\n"); + break; + case P_DIV_CV_INTTERM_DIVEQUALS0: + printf("P_DIV_CV_INTTERM_DIVEQUALS0\n"); + break; + case P_DIV_CV_INTTERM_END: + printf("P_DIV_CV_INTTERM_END\n"); + break; + case P_DIV_CV_NOINTTERM: + printf("P_DIV_CV_NOINTTERM\n"); + break; + case P_DIV_CV_D0EQUALS0L: + printf("P_DIV_CV_D0EQUALS0L\n"); + break; + case P_DIV_CV_NVAR_END: + printf("P_DIV_CV_NVAR_END\n"); + break; + case P_DIV_CV_DIV_CV_UNK: + printf("P_DIV_CV_DIV_CV_UNK\n"); + break; + case P_DIV_Y_VV_INSTINIT: + printf("P_DIV_Y_VV_INSTINIT\n"); + break; + case P_DIV_Y_VV_DIV_Y_VV_NVAR: + printf("P_DIV_Y_VV_DIV_Y_VV_NVAR\n"); + break; + case P_DIV_Y_VV_INTTERM_INIT: + printf("P_DIV_Y_VV_INTTERM_INIT\n"); + break; + case P_DIV_Y_VV_INTTERM_DIVEQUALS0: + printf("P_DIV_Y_VV_INTTERM_DIVEQUALS0\n"); + break; + case P_DIV_Y_VV_INTTERM_END: + printf("P_DIV_Y_VV_INTTERM_END\n"); + break; + case P_DIV_Y_VV_NOINTTERM: + printf("P_DIV_Y_VV_NOINTTERM\n"); + break; + case P_DIV_Y_VV_D0EQUALS0L: + printf("P_DIV_Y_VV_D0EQUALS0L\n"); + break; + case P_DIV_Y_VV_NVAR_END: + printf("P_DIV_Y_VV_NVAR_END\n"); + break; + case P_DIV_Y_VV_DIV_Y_VV_UNK: + printf("P_DIV_Y_VV_DIV_Y_VV_UNK\n"); + break; + case P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK: + printf("P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK\n"); + break; + case P_DIV_Y_VC_INSTINIT: + printf("P_DIV_Y_VC_INSTINIT\n"); + break; + case P_DIV_Y_VC_DIV_Y_VC_NVAR: + printf("P_DIV_Y_VC_DIV_Y_VC_NVAR\n"); + break; + case P_DIV_Y_VC_INTTERM: + printf("P_DIV_Y_VC_INTTERM\n"); + break; + case P_DIV_Y_VC_NOINTTERM: + printf("P_DIV_Y_VC_NOINTTERM\n"); + break; + case P_DIV_Y_VC_D0EQUALS0L: + printf("P_DIV_Y_VC_D0EQUALS0L\n"); + break; + case P_DIV_Y_VC_NVAR_END: + printf("P_DIV_Y_VC_NVAR_END\n"); + break; + case P_DIV_Y_VC_DIV_Y_VC_UNK: + printf("P_DIV_Y_VC_DIV_Y_VC_UNK\n"); + break; + case P_DIV_Y_CV_INSTINIT: + printf("P_DIV_Y_CV_INSTINIT\n"); + break; + case P_DIV_Y_CV_DIV_Y_CV_NVAR: + printf("P_DIV_Y_CV_DIV_Y_CV_NVAR\n"); + break; + case P_DIV_Y_CV_INTTERM_INIT: + printf("P_DIV_Y_CV_INTTERM_INIT\n"); + break; + case P_DIV_Y_CV_INTTERM_DIVEQUALS0: + printf("P_DIV_Y_CV_INTTERM_DIVEQUALS0\n"); + break; + case P_DIV_Y_CV_INTTERM_END: + printf("P_DIV_Y_CV_INTTERM_END\n"); + break; + case P_DIV_Y_CV_NOINTTERM: + printf("P_DIV_Y_CV_NOINTTERM\n"); + break; + case P_DIV_Y_CV_D0EQUALS0L: + printf("P_DIV_Y_CV_D0EQUALS0L\n"); + break; + case P_DIV_Y_CV_NVAR_END: + printf("P_DIV_Y_CV_NVAR_END\n"); + break; + case P_DIV_Y_CV_DIV_Y_CV_UNK: + printf("P_DIV_Y_CV_DIV_Y_CV_UNK\n"); + break; + case P_AND_VV_INSTINIT: + printf("P_AND_VV_INSTINIT\n"); + break; + case P_AND_VV_AND_VV_NVAR: + printf("P_AND_VV_AND_VV_NVAR\n"); + break; + case P_AND_VV_INTTERM: + printf("P_AND_VV_INTTERM\n"); + break; + case P_AND_VV_NOINTTERM: + printf("P_AND_VV_NOINTTERM\n"); + break; + case P_AND_VV_D0EQUALS0L: + printf("P_AND_VV_D0EQUALS0L\n"); + break; + case P_AND_VV_NVAR_END: + printf("P_AND_VV_NVAR_END\n"); + break; + case P_AND_VV_AND_VV_UNK: + printf("P_AND_VV_AND_VV_UNK\n"); + break; + case P_AND_VV_AND_VV_NVAR_UNK: + printf("P_AND_VV_AND_VV_NVAR_UNK\n"); + break; + case P_AND_VC_INSTINIT: + printf("P_AND_VC_INSTINIT\n"); + break; + case P_AND_VC_AND_VC_NVAR: + printf("P_AND_VC_AND_VC_NVAR\n"); + break; + case P_AND_VC_INTTERM: + printf("P_AND_VC_INTTERM\n"); + break; + case P_AND_VC_NOINTTERM: + printf("P_AND_VC_NOINTTERM\n"); + break; + case P_AND_VC_D0EQUALS0L: + printf("P_AND_VC_D0EQUALS0L\n"); + break; + case P_AND_VC_NVAR_END: + printf("P_AND_VC_NVAR_END\n"); + break; + case P_AND_VC_AND_VC_UNK: + printf("P_AND_VC_AND_VC_UNK\n"); + break; + case P_AND_Y_VV_INSTINIT: + printf("P_AND_Y_VV_INSTINIT\n"); + break; + case P_AND_Y_VV_AND_Y_VV_NVAR: + printf("P_AND_Y_VV_AND_Y_VV_NVAR\n"); + break; + case P_AND_Y_VV_INTTERM: + printf("P_AND_Y_VV_INTTERM\n"); + break; + case P_AND_Y_VV_NOINTTERM: + printf("P_AND_Y_VV_NOINTTERM\n"); + break; + case P_AND_Y_VV_D0EQUALS0L: + printf("P_AND_Y_VV_D0EQUALS0L\n"); + break; + case P_AND_Y_VV_NVAR_END: + printf("P_AND_Y_VV_NVAR_END\n"); + break; + case P_AND_Y_VV_AND_Y_VV_UNK: + printf("P_AND_Y_VV_AND_Y_VV_UNK\n"); + break; + case P_AND_Y_VV_AND_Y_VV_NVAR_UNK: + printf("P_AND_Y_VV_AND_Y_VV_NVAR_UNK\n"); + break; + case P_AND_Y_VC_INSTINIT: + printf("P_AND_Y_VC_INSTINIT\n"); + break; + case P_AND_Y_VC_AND_Y_VC_NVAR: + printf("P_AND_Y_VC_AND_Y_VC_NVAR\n"); + break; + case P_AND_Y_VC_INTTERM: + printf("P_AND_Y_VC_INTTERM\n"); + break; + case P_AND_Y_VC_NOINTTERM: + printf("P_AND_Y_VC_NOINTTERM\n"); + break; + case P_AND_Y_VC_D0EQUALS0L: + printf("P_AND_Y_VC_D0EQUALS0L\n"); + break; + case P_AND_Y_VC_NVAR_END: + printf("P_AND_Y_VC_NVAR_END\n"); + break; + case P_AND_Y_VC_AND_Y_VC_UNK: + printf("P_AND_Y_VC_AND_Y_VC_UNK\n"); + break; + case P_OR_VV_INSTINIT: + printf("P_OR_VV_INSTINIT\n"); + break; + case P_OR_VV_OR_VV_NVAR: + printf("P_OR_VV_OR_VV_NVAR\n"); + break; + case P_OR_VV_INTTERM: + printf("P_OR_VV_INTTERM\n"); + break; + case P_OR_VV_NOINTTERM: + printf("P_OR_VV_NOINTTERM\n"); + break; + case P_OR_VV_D0EQUALS0L: + printf("P_OR_VV_D0EQUALS0L\n"); + break; + case P_OR_VV_NVAR_END: + printf("P_OR_VV_NVAR_END\n"); + break; + case P_OR_VV_OR_VV_UNK: + printf("P_OR_VV_OR_VV_UNK\n"); + break; + case P_OR_VV_OR_VV_NVAR_UNK: + printf("P_OR_VV_OR_VV_NVAR_UNK\n"); + break; + case P_OR_VC_INSTINIT: + printf("P_OR_VC_INSTINIT\n"); + break; + case P_OR_VC_OR_VC_NVAR: + printf("P_OR_VC_OR_VC_NVAR\n"); + break; + case P_OR_VC_INTTERM: + printf("P_OR_VC_INTTERM\n"); + break; + case P_OR_VC_NOINTTERM: + printf("P_OR_VC_NOINTTERM\n"); + break; + case P_OR_VC_D0EQUALS0L: + printf("P_OR_VC_D0EQUALS0L\n"); + break; + case P_OR_VC_NVAR_END: + printf("P_OR_VC_NVAR_END\n"); + break; + case P_OR_VC_OR_VC_UNK: + printf("P_OR_VC_OR_VC_UNK\n"); + break; + case P_OR_Y_VV_INSTINIT: + printf("P_OR_Y_VV_INSTINIT\n"); + break; + case P_OR_Y_VV_OR_Y_VV_NVAR: + printf("P_OR_Y_VV_OR_Y_VV_NVAR\n"); + break; + case P_OR_Y_VV_INTTERM: + printf("P_OR_Y_VV_INTTERM\n"); + break; + case P_OR_Y_VV_NOINTTERM: + printf("P_OR_Y_VV_NOINTTERM\n"); + break; + case P_OR_Y_VV_D0EQUALS0L: + printf("P_OR_Y_VV_D0EQUALS0L\n"); + break; + case P_OR_Y_VV_NVAR_END: + printf("P_OR_Y_VV_NVAR_END\n"); + break; + case P_OR_Y_VV_OR_Y_VV_UNK: + printf("P_OR_Y_VV_OR_Y_VV_UNK\n"); + break; + case P_OR_Y_VV_OR_Y_VV_NVAR_UNK: + printf("P_OR_Y_VV_OR_Y_VV_NVAR_UNK\n"); + break; + case P_OR_Y_VC_INSTINIT: + printf("P_OR_Y_VC_INSTINIT\n"); + break; + case P_OR_Y_VC_OR_Y_VC_NVAR: + printf("P_OR_Y_VC_OR_Y_VC_NVAR\n"); + break; + case P_OR_Y_VC_INTTERM: + printf("P_OR_Y_VC_INTTERM\n"); + break; + case P_OR_Y_VC_NOINTTERM: + printf("P_OR_Y_VC_NOINTTERM\n"); + break; + case P_OR_Y_VC_D0EQUALS0L: + printf("P_OR_Y_VC_D0EQUALS0L\n"); + break; + case P_OR_Y_VC_NVAR_END: + printf("P_OR_Y_VC_NVAR_END\n"); + break; + case P_OR_Y_VC_OR_Y_VC_UNK: + printf("P_OR_Y_VC_OR_Y_VC_UNK\n"); + break; + case P_SLL_VV_INSTINIT: + printf("P_SLL_VV_INSTINIT\n"); + break; + case P_SLL_VV_SLL_VV_NVAR: + printf("P_SLL_VV_SLL_VV_NVAR\n"); + break; + case P_SLL_VV_INTTERM_INIT: + printf("P_SLL_VV_INTTERM_INIT\n"); + break; + case P_SLL_VV_INTTERM_LESS: + printf("P_SLL_VV_INTTERM_LESS\n"); + break; + case P_SLL_VV_INTTERM_GREATER: + printf("P_SLL_VV_INTTERM_GREATER\n"); + break; + case P_SLL_VV_NOINTTERM: + printf("P_SLL_VV_NOINTTERM\n"); + break; + case P_SLL_VV_D0EQUALS0L: + printf("P_SLL_VV_D0EQUALS0L\n"); + break; + case P_SLL_VV_NVAR_END: + printf("P_SLL_VV_NVAR_END\n"); + break; + case P_SLL_VV_SLL_VV_UNK: + printf("P_SLL_VV_SLL_VV_UNK\n"); + break; + case P_SLL_VV_SLL_VV_NVAR_UNK: + printf("P_SLL_VV_SLL_VV_NVAR_UNK\n"); + break; + case P_SLL_VC_INSTINIT: + printf("P_SLL_VC_INSTINIT\n"); + break; + case P_SLL_VC_SLL_VC_NVAR: + printf("P_SLL_VC_SLL_VC_NVAR\n"); + break; + case P_SLL_VC_INTTERM: + printf("P_SLL_VC_INTTERM\n"); + break; + case P_SLL_VC_NOINTTERM: + printf("P_SLL_VC_NOINTTERM\n"); + break; + case P_SLL_VC_D0EQUALS0L: + printf("P_SLL_VC_D0EQUALS0L\n"); + break; + case P_SLL_VC_NVAR_END: + printf("P_SLL_VC_NVAR_END\n"); + break; + case P_SLL_VC_SLL_VC_UNK: + printf("P_SLL_VC_SLL_VC_UNK\n"); + break; + case P_SLL_CV_INSTINIT: + printf("P_SLL_CV_INSTINIT\n"); + break; + case P_SLL_CV_SLL_CV_NVAR: + printf("P_SLL_CV_SLL_CV_NVAR\n"); + break; + case P_SLL_CV_INTTERM_INIT: + printf("P_SLL_CV_INTTERM_INIT\n"); + break; + case P_SLL_CV_INTTERM_LESS: + printf("P_SLL_CV_INTTERM_LESS\n"); + break; + case P_SLL_CV_INTTERM_GREATER: + printf("P_SLL_CV_INTTERM_GREATER\n"); + break; + case P_SLL_CV_NOINTTERM: + printf("P_SLL_CV_NOINTTERM\n"); + break; + case P_SLL_CV_D0EQUALS0L: + printf("P_SLL_CV_D0EQUALS0L\n"); + break; + case P_SLL_CV_NVAR_END: + printf("P_SLL_CV_NVAR_END\n"); + break; + case P_SLL_CV_SLL_CV_UNK: + printf("P_SLL_CV_SLL_CV_UNK\n"); + break; + case P_SLL_Y_VV_INSTINIT: + printf("P_SLL_Y_VV_INSTINIT\n"); + break; + case P_SLL_Y_VV_SLL_Y_VV_NVAR: + printf("P_SLL_Y_VV_SLL_Y_VV_NVAR\n"); + break; + case P_SLL_Y_VV_INTTERM_INIT: + printf("P_SLL_Y_VV_INTTERM_INIT\n"); + break; + case P_SLL_Y_VV_INTERM_LESS: + printf("P_SLL_Y_VV_INTERM_LESS\n"); + break; + case P_SLL_Y_VV_INTTERM_GREATER: + printf("P_SLL_Y_VV_INTTERM_GREATER\n"); + break; + case P_SLL_Y_VV_NOINTTERM: + printf("P_SLL_Y_VV_NOINTTERM\n"); + break; + case P_SLL_Y_VV_D0EQUALS0L: + printf("P_SLL_Y_VV_D0EQUALS0L\n"); + break; + case P_SLL_Y_VV_NVAR_END: + printf("P_SLL_Y_VV_NVAR_END\n"); + break; + case P_SLL_Y_VV_SLL_Y_VV_UNK: + printf("P_SLL_Y_VV_SLL_Y_VV_UNK\n"); + break; + case P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK: + printf("P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK\n"); + break; + case P_SLL_Y_VC_INSTINIT: + printf("P_SLL_Y_VC_INSTINIT\n"); + break; + case P_SLL_Y_VC_SLL_Y_VC_NVAR: + printf("P_SLL_Y_VC_SLL_Y_VC_NVAR\n"); + break; + case P_SLL_Y_VC_INTTERM: + printf("P_SLL_Y_VC_INTTERM\n"); + break; + case P_SLL_Y_VC_NOINTTERM: + printf("P_SLL_Y_VC_NOINTTERM\n"); + break; + case P_SLL_Y_VC_D0EQUALS0L: + printf("P_SLL_Y_VC_D0EQUALS0L\n"); + break; + case P_SLL_Y_VC_NVAR_END: + printf("P_SLL_Y_VC_NVAR_END\n"); + break; + case P_SLL_Y_VC_SLL_Y_VC_UNK: + printf("P_SLL_Y_VC_SLL_Y_VC_UNK\n"); + break; + case P_SLL_Y_CV_INSTINIT: + printf("P_SLL_Y_CV_INSTINIT\n"); + break; + case P_SLL_Y_CV_SLL_Y_CV_NVAR: + printf("P_SLL_Y_CV_SLL_Y_CV_NVAR\n"); + break; + case P_SLL_Y_CV_INTTERM_INIT: + printf("P_SLL_Y_CV_INTTERM_INIT\n"); + break; + case P_SLL_Y_CV_INTTERM_LESS: + printf("P_SLL_Y_CV_INTTERM_LESS\n"); + break; + case P_SLL_Y_CV_INTTERM_GREATER: + printf("P_SLL_Y_CV_INTTERM_GREATER\n"); + break; + case P_SLL_Y_CV_NOINTTERM: + printf("P_SLL_Y_CV_NOINTTERM\n"); + break; + case P_SLL_Y_CV_D0EQUALS0L: + printf("P_SLL_Y_CV_D0EQUALS0L\n"); + break; + case P_SLL_Y_CV_NVAR_END: + printf("P_SLL_Y_CV_NVAR_END\n"); + break; + case P_SLL_Y_CV_SLL_Y_CV_UNK: + printf("P_SLL_Y_CV_SLL_Y_CV_UNK\n"); + break; + case P_SLR_VV_INSTINIT: + printf("P_SLR_VV_INSTINIT\n"); + break; + case P_SLR_VV_SLR_VV_NVAR: + printf("P_SLR_VV_SLR_VV_NVAR\n"); + break; + case P_SLR_VV_INTTERM_INIT: + printf("P_SLR_VV_INTTERM_INIT\n"); + break; + case P_SLR_VV_INTTERM_LESS: + printf("P_SLR_VV_INTTERM_LESS\n"); + break; + case P_SLR_VV_INTTERM_GREATER: + printf("P_SLR_VV_INTTERM_GREATER\n"); + break; + case P_SLR_VV_NOINTTERM: + printf("P_SLR_VV_NOINTTERM\n"); + break; + case P_SLR_VV_D0EQUALS0L: + printf("P_SLR_VV_D0EQUALS0L\n"); + break; + case P_SLR_VV_NVAR_END: + printf("P_SLR_VV_NVAR_END\n"); + break; + case P_SLR_VV_SRL_VV_UNK: + printf("P_SLR_VV_SRL_VV_UNK\n"); + break; + case P_SLR_VV_SRL_VV_NVAR_UNK: + printf("P_SLR_VV_SRL_VV_NVAR_UNK\n"); + break; + case P_SLR_VC_INSTINIT: + printf("P_SLR_VC_INSTINIT\n"); + break; + case P_SLR_VC_SLR_VC_NVAR: + printf("P_SLR_VC_SLR_VC_NVAR\n"); + break; + case P_SLR_VC_INTTERM: + printf("P_SLR_VC_INTTERM\n"); + break; + case P_SLR_VC_NOINTTERM: + printf("P_SLR_VC_NOINTTERM\n"); + break; + case P_SLR_VC_D0EQUALS0L: + printf("P_SLR_VC_D0EQUALS0L\n"); + break; + case P_SLR_VC_NVAR_END: + printf("P_SLR_VC_NVAR_END\n"); + break; + case P_SLR_VC_SRL_VC_UNK: + printf("P_SLR_VC_SRL_VC_UNK\n"); + break; + case P_SLR_CV_INSTINIT: + printf("P_SLR_CV_INSTINIT\n"); + break; + case P_SLR_CV_SLR_CV_NVAR: + printf("P_SLR_CV_SLR_CV_NVAR\n"); + break; + case P_SLR_CV_INTTERM_INIT: + printf("P_SLR_CV_INTTERM_INIT\n"); + break; + case P_SLR_CV_INTTERM_LESS: + printf("P_SLR_CV_INTTERM_LESS\n"); + break; + case P_SLR_CV_INTTERM_GREATER: + printf("P_SLR_CV_INTTERM_GREATER\n"); + break; + case P_SLR_CV_NOINTTERM: + printf("P_SLR_CV_NOINTTERM\n"); + break; + case P_SLR_CV_D0EQUALS0L: + printf("P_SLR_CV_D0EQUALS0L\n"); + break; + case P_SLR_CV_NVAR_END: + printf("P_SLR_CV_NVAR_END\n"); + break; + case P_SLR_CV_SLR_CV_UNK: + printf("P_SLR_CV_SLR_CV_UNK\n"); + break; + case P_SLR_Y_VV_INSTINIT: + printf("P_SLR_Y_VV_INSTINIT\n"); + break; + case P_SLR_Y_VV_SLR_Y_VV_NVAR: + printf("P_SLR_Y_VV_SLR_Y_VV_NVAR\n"); + break; + case P_SLR_Y_VV_INTTERM_INIT: + printf("P_SLR_Y_VV_INTTERM_INIT\n"); + break; + case P_SLR_Y_VV_INTTERM_LESS: + printf("P_SLR_Y_VV_INTTERM_LESS\n"); + break; + case P_SLR_Y_VV_INTTERM_GREATER: + printf("P_SLR_Y_VV_INTTERM_GREATER\n"); + break; + case P_SLR_Y_VV_NOINTTERM: + printf("P_SLR_Y_VV_NOINTTERM\n"); + break; + case P_SLR_Y_VV_D0EQUALS0L: + printf("P_SLR_Y_VV_D0EQUALS0L\n"); + break; + case P_SLR_Y_VV_NVAR_END: + printf("P_SLR_Y_VV_NVAR_END\n"); + break; + case P_SLR_Y_VV_SLR_Y_VV_UNK: + printf("P_SLR_Y_VV_SLR_Y_VV_UNK\n"); + break; + case P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK: + printf("P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK\n"); + break; + case P_SLR_Y_VC_INSTINIT: + printf("P_SLR_Y_VC_INSTINIT\n"); + break; + case P_SLR_Y_VC_SLR_Y_VC_NVAR: + printf("P_SLR_Y_VC_SLR_Y_VC_NVAR\n"); + break; + case P_SLR_Y_VC_INTTERM: + printf("P_SLR_Y_VC_INTTERM\n"); + break; + case P_SLR_Y_VC_NOINTTERM: + printf("P_SLR_Y_VC_NOINTTERM\n"); + break; + case P_SLR_Y_VC_D0EQUALS0L: + printf("P_SLR_Y_VC_D0EQUALS0L\n"); + break; + case P_SLR_Y_VC_NVAR_END: + printf("P_SLR_Y_VC_NVAR_END\n"); + break; + case P_SLR_Y_VC_SLR_Y_VC_UNK: + printf("P_SLR_Y_VC_SLR_Y_VC_UNK\n"); + break; + case P_SLR_Y_CV_INSTINIT: + printf("P_SLR_Y_CV_INSTINIT\n"); + break; + case P_SLR_Y_CV_SLR_Y_CV_NVAR: + printf("P_SLR_Y_CV_SLR_Y_CV_NVAR\n"); + break; + case P_SLR_Y_CV_INTTERM_INIT: + printf("P_SLR_Y_CV_INTTERM_INIT\n"); + break; + case P_SLR_Y_CV_INTTERM_LESS: + printf("P_SLR_Y_CV_INTTERM_LESS\n"); + break; + case P_SLR_Y_CV_INTTERM_GREATER: + printf("P_SLR_Y_CV_INTTERM_GREATER\n"); + break; + case P_SLR_Y_CV_NOINTTERM: + printf("P_SLR_Y_CV_NOINTTERM\n"); + break; + case P_SLR_Y_CV_D0EQUALS0L: + printf("P_SLR_Y_CV_D0EQUALS0L\n"); + break; + case P_SLR_Y_CV_NVAR_END: + printf("P_SLR_Y_CV_NVAR_END\n"); + break; + case P_SLR_Y_CV_SLR_Y_CV_UNK: + printf("P_SLR_Y_CV_SLR_Y_CV_UNK\n"); + break; + case CALL_BFUNC_XX_INSTINIT: + printf("CALL_BFUNC_XX_INSTINIT\n"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR: + printf("CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR\n"); + break; + case CALL_BFUNC_XX_INTTERM_INIT: + printf("CALL_BFUNC_XX_INTTERM_INIT\n"); + break; + case CALL_BFUNC_XX_INTTERM_VGREATER1: + printf("CALL_BFUNC_XX_INTTERM_VGREATER1\n"); + break; + case CALL_BFUNC_XX_INTTERM_VGREATER2: + printf("CALL_BFUNC_XX_INTTERM_VGREATER2\n"); + break; + case CALL_BFUNC_XX_INTTERM_VLESS1: + printf("CALL_BFUNC_XX_INTTERM_VLESS1\n"); + break; + case CALL_BFUNC_XX_INTTERM_VLESS2: + printf("CALL_BFUNC_XX_INTTERM_VLESS2\n"); + break; + case CALL_BFUNC_XX_INTTERM_VEQUAL1: + printf("CALL_BFUNC_XX_INTTERM_VEQUAL1\n"); + break; + case CALL_BFUNC_XX_INTTERM_VEQUAL2: + printf("CALL_BFUNC_XX_INTTERM_VEQUAL2\n"); + break; + case CALL_BFUNC_XX_NOINTTERM_INIT: + printf("CALL_BFUNC_XX_NOINTTERM_INIT\n"); + break; + case CALL_BFUNC_XX_NOINTTERM_FAILCODE: + printf("CALL_BFUNC_XX_NOINTTERM_FAILCODE\n"); + break; + case CALL_BFUNC_XX_NOINTTERM_NOD0: + printf("CALL_BFUNC_XX_NOINTTERM_NOD0\n"); + break; + case CALL_BFUNC_XX_NOINTTERM_END: + printf("CALL_BFUNC_XX_NOINTTERM_END\n"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX_UNK: + printf("CALL_BFUNC_XX_CALL_BFUNC_XX_UNK\n"); + break; + case CALL_BFUNC_YX_INSTINIT: + printf("CALL_BFUNC_YX_INSTINIT\n"); + break; + case CALL_BFUNC_YX_INTTERM_INIT: + printf("CALL_BFUNC_YX_INTTERM_INIT\n"); + break; + case CALL_BFUNC_YX_INTTERM_VGREATER1: + printf("CALL_BFUNC_YX_INTTERM_VGREATER1\n"); + break; + case CALL_BFUNC_YX_INTTERM_VGREATER2: + printf("CALL_BFUNC_YX_INTTERM_VGREATER2\n"); + break; + case CALL_BFUNC_YX_INTTERM_VLESS1: + printf("CALL_BFUNC_YX_INTTERM_VLESS1\n"); + break; + case CALL_BFUNC_YX_INTTERM_VLESS2: + printf("CALL_BFUNC_YX_INTTERM_VLESS2\n"); + break; + case CALL_BFUNC_YX_INTTERM_VEQUAL1: + printf("CALL_BFUNC_YX_INTTERM_VEQUAL1\n"); + break; + case CALL_BFUNC_YX_INTTERM_VEQUAL2: + printf("CALL_BFUNC_YX_INTTERM_VEQUAL2\n"); + break; + case CALL_BFUNC_YX_NOINTTERM_INIT: + printf("CALL_BFUNC_YX_NOINTTERM_INIT\n"); + break; + case CALL_BFUNC_YX_NOINTTERM_NOFAILCODE: + printf("CALL_BFUNC_YX_NOINTTERM_NOFAILCODE\n"); + break; + case CALL_BFUNC_YX_NOINTTERM_NOD0: + printf("CALL_BFUNC_YX_NOINTTERM_NOD0\n"); + break; + case CALL_BFUNC_YX_NOINTTERM_END: + printf("CALL_BFUNC_YX_NOINTTERM_END\n"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX_UNK: + printf("CALL_BFUNC_YX_CALL_BFUNC_YX_UNK\n"); + break; + case CALL_BFUNC_XY_INSTINIT: + printf("CALL_BFUNC_XY_INSTINIT\n"); + break; + case CALL_BFUNC_XY_INTTERM_INIT: + printf("CALL_BFUNC_XY_INTTERM_INIT\n"); + break; + case CALL_BFUNC_XY_INTTERM_VGREATER1: + printf("CALL_BFUNC_XY_INTTERM_VGREATER1\n"); + break; + case CALL_BFUNC_XY_INTTERM_VGREATER2: + printf("CALL_BFUNC_XY_INTTERM_VGREATER2\n"); + break; + case CALL_BFUNC_XY_INTTERM_VLESS1: + printf("CALL_BFUNC_XY_INTTERM_VLESS1\n"); + break; + case CALL_BFUNC_XY_INTTERM_VLESS2: + printf("CALL_BFUNC_XY_INTTERM_VLESS2\n"); + break; + case CALL_BFUNC_XY_INTTERM_VEQUAL1: + printf("CALL_BFUNC_XY_INTTERM_VEQUAL1\n"); + break; + case CALL_BFUNC_XY_INTTERM_VEQUAL2: + printf("CALL_BFUNC_XY_INTTERM_VEQUAL2\n"); + break; + case CALL_BFUNC_XY_NOINTTERM_INIT: + printf("CALL_BFUNC_XY_NOINTTERM_INIT\n"); + break; + case CALL_BFUNC_XY_NOINTTERM_NOFAILCODE: + printf("CALL_BFUNC_XY_NOINTTERM_NOFAILCODE\n"); + break; + case CALL_BFUNC_XY_NOINTTERM_NOD0: + printf("CALL_BFUNC_XY_NOINTTERM_NOD0\n"); + break; + case CALL_BFUNC_XY_NOINTTERM_END: + printf("CALL_BFUNC_XY_NOINTTERM_END\n"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY_UNK: + printf("CALL_BFUNC_XY_CALL_BFUNC_XY_UNK\n"); + break; + case CALL_BFUNC_YY_INSTINIT: + printf("CALL_BFUNC_YY_INSTINIT\n"); + break; + case CALL_BFUNC_YY_INTTERM_INIT: + printf("CALL_BFUNC_YY_INTTERM_INIT\n"); + break; + case CALL_BFUNC_YY_INTTERM_VGREATER1: + printf("CALL_BFUNC_YY_INTTERM_VGREATER1\n"); + break; + case CALL_BFUNC_YY_INTTERM_VGREATER2: + printf("CALL_BFUNC_YY_INTTERM_VGREATER2\n"); + break; + case CALL_BFUNC_YY_INTTERM_VLESS1: + printf("CALL_BFUNC_YY_INTTERM_VLESS1\n"); + break; + case CALL_BFUNC_YY_INTTERM_VLESS2: + printf("CALL_BFUNC_YY_INTTERM_VLESS2\n"); + break; + case CALL_BFUNC_YY_INTTERM_VEQUAL1: + printf("CALL_BFUNC_YY_INTTERM_VEQUAL1\n"); + break; + case CALL_BFUNC_YY_INTTERM_VEQUAL2: + printf("CALL_BFUNC_YY_INTTERM_VEQUAL2\n"); + break; + case CALL_BFUNC_YY_NOINTTERM_INIT: + printf("CALL_BFUNC_YY_NOINTTERM_INIT\n"); + break; + case CALL_BFUNC_YY_NOINTTERM_NOFAILCODE: + printf("CALL_BFUNC_YY_NOINTTERM_NOFAILCODE\n"); + break; + case CALL_BFUNC_YY_NOINTTERM_NOD0: + printf("CALL_BFUNC_YY_NOINTTERM_NOD0\n"); + break; + case CALL_BFUNC_YY_NOINTTERM_END: + printf("CALL_BFUNC_YY_NOINTTERM_END\n"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY_UNK: + printf("CALL_BFUNC_YY_CALL_BFUNC_YY_UNK\n"); + break; + case P_EQUAL_INSTINIT: + printf("P_EQUAL_INSTINIT\n"); + break; + case P_EQUAL_END: + printf("P_EQUAL_END\n"); + break; + case P_DIF_INSTINIT: + printf("P_DIF_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_DIF_LOW_LEVEL_TRACER: + printf("P_DIF_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_DIF_POST_LOW_LEVEL_TRACER: + printf("P_DIF_POST_LOW_LEVEL_TRACER\n"); + break; + case P_DIF_DIF_NVAR1: + printf("P_DIF_DIF_NVAR1\n"); + break; + case P_DIF_EQUALS: + printf("P_DIF_EQUALS\n"); + break; + case P_DIF_ATOM_OR_INT: + printf("P_DIF_ATOM_OR_INT\n"); + break; +#ifdef COROUTINING + case P_DIF_COROUTINING1: + printf("P_DIF_COROUTINING1\n"); + break; +#endif + case P_DIF_POST_COROUTINING1: + printf("P_DIF_POST_COROUTINING1\n"); + break; +#ifdef COROUTINING + case P_DIF_COROUTINING2_INIT: + printf("P_DIF_COROUTINING2_INIT\n"); + break; + case P_DIF_COROUTINING2_TERMNIL: + printf("P_DIF_COROUTINING2_TERMNIL\n"); + break; +#endif + case P_DIF_POST_COROUTINING2: + printf("P_DIF_POST_COROUTINING2\n"); + break; +#ifdef COROUTINING + case P_DIF_SETH: + printf("P_DIF_SETH\n"); + break; +#endif + case P_DIF_SETHBREG: + printf("P_DIF_SETHBREG\n"); + break; + case P_DIF_INSIDEWHILE_INIT: + printf("P_DIF_INSIDEWHILE_INIT\n"); + break; +#if defined(YAPOR_SBA) && defined(YAPOR) + case P_DIF_INSIDEWHILE_VARTERM_IFOK: + printf("P_DIF_INSIDEWHILE_VARTERM_IFOK\n"); + break; +#endif + case P_DIF_INSIDEWHILE_VARTERM_NOIF: + printf("P_DIF_INSIDEWHILE_VARTERM_NOIF\n"); + break; +#ifdef MULTI_ASSIGNMENT_VARIABLES + case P_DIF_INSIDEWHILE_NOVARTERM_INIT: + printf("P_DIF_INSIDEWHILE_NOVARTERM_INIT\n"); + break; +#ifdef FROZEN_STACKS + case P_DIF_INSIDEWHILE_NOVARTERM_FROZEN: + printf("P_DIF_INSIDEWHILE_NOVARTERM_FROZEN\n"); + break; +#else + case P_DIF_INSIDEWHILE_NOVARTERM_NOFROZEN: + printf("P_DIF_INSIDEWHILE_NOVARTERM_NOFROZEN\n"); + break; +#endif +#endif + case P_DIF_OPRESULT_OK: + printf("P_DIF_OPRESULT_OK\n"); + break; + case P_DIF_RESTORE_B_HB: + printf("P_DIF_RESTORE_B_HB\n"); + break; + case P_DIF_DIF_UNK1: + printf("P_DIF_DIF_UNK1\n"); + break; + case P_DIF_DIF_NVAR1_UNK2: + printf("P_DIF_DIF_NVAR1_UNK2\n"); + break; + case P_EQ_INSTINIT: + printf("P_EQ_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_EQ_LOW_LEVEL_TRACER: + printf("P_EQ_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_EQ_POST_LOW_LEVEL_TRACER: + printf("P_EQ_POST_LOW_LEVEL_TRACER\n"); + break; + case P_EQ_P_EQ_NVAR1: + printf("P_EQ_P_EQ_NVAR1\n"); + break; + case P_EQ_EQUALS: + printf("P_EQ_EQUALS\n"); + break; + case P_EQ_D0PAIR_D1PAIR: + printf("P_EQ_D0PAIR_D1PAIR\n"); + break; + case P_EQ_D0PAIR_POST_IF1: + printf("P_EQ_D0PAIR_POST_IF1\n"); + break; + case P_EQ_D0PAIR_D2FALSE: + printf("P_EQ_D0PAIR_D2FALSE\n"); + break; + case P_EQ_D0PAIR_POST_IF2: + printf("P_EQ_D0PAIR_POST_IF2\n"); + break; + case P_EQ_D0APPL_INIT: + printf("P_EQ_D0APPL_INIT\n"); + break; + case P_EQ_D0APPL_D1NOAPPL: + printf("P_EQ_D0APPL_D1NOAPPL\n"); + break; + case P_EQ_D0APPL_POST_IF1: + printf("P_EQ_D0APPL_POST_IF1\n"); + break; + case P_EQ_D0APPL_FDBREF_D0EQUALSD1: + printf("P_EQ_D0APPL_FDBREF_D0EQUALSD1\n"); + break; + case P_EQ_D0APPL_FDBREF_END: + printf("P_EQ_D0APPL_FDBREF_END\n"); + break; + case P_EQ_D0APPL_FLONGINT_F1NOTLONGINT: + printf("P_EQ_D0APPL_FLONGINT_F1NOTLONGINT\n"); + break; + case P_EQ_D0APPL_FLONGINT_D0INT_EQUALS_D1INT: + printf("P_EQ_D0APPL_FLONGINT_D0INT_EQUALS_D1INT\n"); + break; + case P_EQ_D0APPL_FLONGINT_END: + printf("P_EQ_D0APPL_FLONGINT_END\n"); + break; +#ifdef USE_GMP + case P_EQ_D0APPL_FBIGINT_NOTEQUAL: + printf("P_EQ_D0APPL_FBIGINT_NOTEQUAL\n"); + break; + case P_EQ_D0APPL_FBIGINT_EQUALS: + printf("P_EQ_D0APPL_FBIGINT_EQUALS\n"); + break; + case P_EQ_D0APPL_FBIGINT_END: + printf("P_EQ_D0APPL_FBIGINT_END\n"); + break; +#endif + case P_EQ_D0APPL_FDOUBLE_NOTEQUAL: + printf("P_EQ_D0APPL_FDOUBLE_NOTEQUAL\n"); + break; + case P_EQ_D0APPL_FDOUBLE_EQUALS: + printf("P_EQ_D0APPL_FDOUBLE_EQUALS\n"); + break; + case P_EQ_D0APPL_DEFAULT: + printf("P_EQ_D0APPL_DEFAULT\n"); + break; + case P_EQ_D0APPL_F0NOTEQUALF1: + printf("P_EQ_D0APPL_F0NOTEQUALF1\n"); + break; + case P_EQ_D0APPL_POST_IF2: + printf("P_EQ_D0APPL_POST_IF2\n"); + break; + case P_EQ_D0APPL_D2FALSE: + printf("P_EQ_D0APPL_D2FALSE\n"); + break; + case P_EQ_D0APPL_POST_IF3: + printf("P_EQ_D0APPL_POST_IF3\n"); + break; + case P_EQ_POST_D0APPL: + printf("P_EQ_POST_D0APPL\n"); + break; + case P_EQ_P_EQ_NVAR1_UNK2: + printf("P_EQ_P_EQ_NVAR1_UNK2\n"); + break; + case P_EQ_P_EQ_UNK1: + printf("P_EQ_P_EQ_UNK1\n"); + break; + case P_EQ_P_EQ_VAR1_NVAR2: + printf("P_EQ_P_EQ_VAR1_NVAR2\n"); + break; + case P_EQ_P_EQ_VAR1_UNK2_PT1NOTEQUALPT0: + printf("P_EQ_P_EQ_VAR1_UNK2_PT1NOTEQUALPT0\n"); + break; + case P_EQ_P_EQ_VAR1_UNK2_END: + printf("P_EQ_P_EQ_VAR1_UNK2_END\n"); + break; + case P_ARG_VV_INSTINIT: + printf("P_ARG_VV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_VV_LOW_LEVEL_TRACER: + printf("P_ARG_VV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_ARG_VV_TEST_D0: + printf("P_ARG_VV_TEST_D0\n"); + break; + case P_ARG_VV_D0INT: + printf("P_ARG_VV_D0INT\n"); + break; + case P_ARG_VV_D0LONGINT: + printf("P_ARG_VV_D0LONGINT\n"); + break; + case P_ARG_VV_D0OTHER: + printf("P_ARG_VV_D0OTHER\n"); + break; + case P_ARG_VV_TEST_D1: + printf("P_ARG_VV_TEST_D1\n"); + break; + case P_ARG_VV_D1APPL_INIT: + printf("P_ARG_VV_D1APPL_INIT\n"); + break; + case P_ARG_VV_D1APPL_END: + printf("P_ARG_VV_D1APPL_END\n"); + break; + case P_ARG_VV_D1PAIR_INIT: + printf("P_ARG_VV_D1PAIR_INIT\n"); + break; + case P_ARG_VV_D1PAIR_LESS0: + printf("P_ARG_VV_D1PAIR_LESS0\n"); + break; + case P_ARG_VV_D1PAIR_END: + printf("P_ARG_VV_D1PAIR_END\n"); + break; + case P_ARG_VV_ARG_ARG2_UNK: + printf("P_ARG_VV_ARG_ARG2_UNK\n"); + break; + case P_ARG_VV_ARG_ARG1_UNK: + printf("P_ARG_VV_ARG_ARG1_UNK\n"); + break; + case P_ARG_CV_INSTINIT: + printf("P_ARG_CV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_CV_LOW_LEVEL_TRACER: + printf("P_ARG_CV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_ARG_CV_TEST_D1: + printf("P_ARG_CV_TEST_D1\n"); + break; + case P_ARG_CV_D1APPL_INIT: + printf("P_ARG_CV_D1APPL_INIT\n"); + break; + case P_ARG_CV_D1APPL_END: + printf("P_ARG_CV_D1APPL_END\n"); + break; + case P_ARG_CV_D1PAIR_INIT: + printf("P_ARG_CV_D1PAIR_INIT\n"); + break; + case P_ARG_CV_D1PAIR_LESS0: + printf("P_ARG_CV_D1PAIR_LESS0\n"); + break; + case P_ARG_CV_D1PAIR_END: + printf("P_ARG_CV_D1PAIR_END\n"); + break; + case P_ARG_CV_ARG_ARG2_VC_UNK: + printf("P_ARG_CV_ARG_ARG2_VC_UNK\n"); + break; + case P_ARG_Y_VV_INSTINIT: + printf("P_ARG_Y_VV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_Y_VV_LOW_LEVEL_TRACER: + printf("P_ARG_Y_VV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_ARG_Y_VV_TEST_D0: + printf("P_ARG_Y_VV_TEST_D0\n"); + break; + case P_ARG_Y_VV_D0INT: + printf("P_ARG_Y_VV_D0INT\n"); + break; + case P_ARG_Y_VV_D0LONGINT: + printf("P_ARG_Y_VV_D0LONGINT\n"); + break; + case P_ARG_Y_VV_D0OTHER: + printf("P_ARG_Y_VV_D0OTHER\n"); + break; + case P_ARG_Y_VV_TEST_D1: + printf("P_ARG_Y_VV_TEST_D1\n"); + break; + case P_ARG_Y_VV_D1APPL_INIT: + printf("P_ARG_Y_VV_D1APPL_INIT\n"); + break; + case P_ARG_Y_VV_D1APPL_END: + printf("P_ARG_Y_VV_D1APPL_END\n"); + break; + case P_ARG_Y_VV_D1PAIR_INIT: + printf("P_ARG_Y_VV_D1PAIR_INIT\n"); + break; + case P_ARG_Y_VV_D1PAIR_LESS0: + printf("P_ARG_Y_VV_D1PAIR_LESS0\n"); + break; + case P_ARG_Y_VV_D1PAIR_END: + printf("P_ARG_Y_VV_D1PAIR_END\n"); + break; + case P_ARG_Y_VV_ARG_Y_ARG2_UNK: + printf("P_ARG_Y_VV_ARG_Y_ARG2_UNK\n"); + break; + case P_ARG_Y_VV_ARG_Y_ARG1_UNK: + printf("P_ARG_Y_VV_ARG_Y_ARG1_UNK\n"); + break; + case P_ARG_Y_CV_INSTINIT: + printf("P_ARG_Y_CV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_Y_CV_LOW_LEVEL_TRACER: + printf("P_ARG_Y_CV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_ARG_Y_CV_TEST_D1: + printf("P_ARG_Y_CV_TEST_D1\n"); + break; + case P_ARG_Y_CV_D1APPL_INIT: + printf("P_ARG_Y_CV_D1APPL_INIT\n"); + break; + case P_ARG_Y_CV_D1APPL_END: + printf("P_ARG_Y_CV_D1APPL_END\n"); + break; + case P_ARG_Y_CV_D1PAIR_INIT: + printf("P_ARG_Y_CV_D1PAIR_INIT\n"); + break; + case P_ARG_Y_CV_D1PAIR_LESS0: + printf("P_ARG_Y_CV_D1PAIR_LESS0\n"); + break; + case P_ARG_Y_CV_D1PAIR_END: + printf("P_ARG_Y_CV_D1PAIR_END\n"); + break; + case P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK: + printf("P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK\n"); + break; + case P_FUNC2S_VV_INSTINIT: + printf("P_FUNC2S_VV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_VV_LOW_LEVEL_TRACER: + printf("P_FUNC2S_VV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_TEST_D0: + printf("P_FUNC2S_TEST_D0\n"); + break; + case P_FUNC2S_VV_TEST_D1: + printf("P_FUNC2S_VV_TEST_D1\n"); + break; + case P_FUNC2S_VV_D1INT: + printf("P_FUNC2S_VV_D1INT\n"); + break; + case P_FUNC2S_VV_D1NOTINT: + printf("P_FUNC2S_VV_D1NOTINT\n"); + break; + case P_FUNC2S_VV_D1BIGINT: + printf("P_FUNC2S_VV_D1BIGINT\n"); + break; + case P_FUNC2S_VV_D1NOTBIGINT: + printf("P_FUNC2S_VV_D1NOTBIGINT\n"); + break; + case P_FUNC2S_VV_D1NOTINT_END: + printf("P_FUNC2S_VV_D1NOTINT_END\n"); + break; + case P_FUNC2S_VV_D0NOTATOMIC: + printf("P_FUNC2S_VV_D0NOTATOMIC\n"); + break; + case P_FUNC2S_VV_FIRSTIFOK: + printf("P_FUNC2S_VV_FIRSTIFOK\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_D0NOTATOM: + printf("P_FUNC2S_VV_SECONDIFOK_D0NOTATOM\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_D0ATOM: + printf("P_FUNC2S_VV_SECONDIFOK_D0ATOM\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM: + printf("P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT: + printf("P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK: + printf("P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF: + printf("P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE: + printf("P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_END: + printf("P_FUNC2S_VV_SECONDIFOK_END\n"); + break; + case P_FUNC2S_VV_THIRDIFOK: + printf("P_FUNC2S_VV_THIRDIFOK\n"); + break; + case P_FUNC2S_VV_ELSE: + printf("P_FUNC2S_VV_ELSE\n"); + break; + case P_FUNC2S_VV_FUNC2S_UNK2: + printf("P_FUNC2S_VV_FUNC2S_UNK2\n"); + break; + case P_FUNC2S_VV_FUNC2S_UNK: + printf("P_FUNC2S_VV_FUNC2S_UNK\n"); + break; + case P_FUNC2S_CV_INSTINIT: + printf("P_FUNC2S_CV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_CV_LOW_LEVEL_TRACER: + printf("P_FUNC2S_CV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_CV_TEST_D1: + printf("P_FUNC2S_CV_TEST_D1\n"); + break; + case P_FUNC2S_CV_D1INT: + printf("P_FUNC2S_CV_D1INT\n"); + break; + case P_FUNC2S_CV_D1NOTINT: + printf("P_FUNC2S_CV_D1NOTINT\n"); + break; + case P_FUNC2S_CV_D1NOINT_D1BIGINT: + printf("P_FUNC2S_CV_D1NOINT_D1BIGINT\n"); + break; + case P_FUNC2S_CV_D1NOTBIGINT: + printf("P_FUNC2S_CV_D1NOTBIGINT\n"); + break; + case P_FUNC2S_CV_POST_IF: + printf("P_FUNC2S_CV_POST_IF\n"); + break; + case P_FUNC2S_CV_FIRSTIFOK: + printf("P_FUNC2S_CV_FIRSTIFOK\n"); + break; + case P_FUNC2S_CV_D1GREATER_D0NOTATOM: + printf("P_FUNC2S_CV_D1GREATER_D0NOTATOM\n"); + break; + case P_FUNC2S_CV_D1GREATER_D0ATOM: + printf("P_FUNC2S_CV_D1GREATER_D0ATOM\n"); + break; + case P_FUNC2S_CV_D1GREATER_POST_IF: + printf("P_FUNC2S_CV_D1GREATER_POST_IF\n"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_INIT: + printf("P_FUNC2S_CV_D1GREATER_IFOK_INIT\n"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_IFOK: + printf("P_FUNC2S_CV_D1GREATER_IFOK_IFOK\n"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_NOIF: + printf("P_FUNC2S_CV_D1GREATER_IFOK_NOIF\n"); + break; + case P_FUNC2S_CV_D1GREATER_INSIDEWHILE: + printf("P_FUNC2S_CV_D1GREATER_INSIDEWHILE\n"); + break; + case P_FUNC2S_CV_D1GREATER_END: + printf("P_FUNC2S_CV_D1GREATER_END\n"); + break; + case P_FUNC2S_CV_D1ISZERO: + printf("P_FUNC2S_CV_D1ISZERO\n"); + break; + case P_FUNC2S_CV_ELSE: + printf("P_FUNC2S_CV_ELSE\n"); + break; + case P_FUNC2S_CV_END: + printf("P_FUNC2S_CV_END\n"); + break; + case P_FUNC2S_VC_INSTINIT: + printf("P_FUNC2S_VC_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_VC_LOW_LEVEL_TRACER: + printf("P_FUNC2S_VC_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_VC_TEST_D0: + printf("P_FUNC2S_VC_TEST_D0\n"); + break; + case P_FUNC2S_VC_FUNC2S_NVAR_VC: + printf("P_FUNC2S_VC_FUNC2S_NVAR_VC\n"); + break; + case P_FUNC2S_VC_D0NOATOMIC: + printf("P_FUNC2S_VC_D0NOATOMIC\n"); + break; + case P_FUNC2S_VC_EQUALS: + printf("P_FUNC2S_VC_EQUALS\n"); + break; + case P_FUNC2S_VC_D1ISZERO: + printf("P_FUNC2S_VC_D1ISZERO\n"); + break; + case P_FUNC2S_VC_D0NOATOM: + printf("P_FUNC2S_VC_D0NOATOM\n"); + break; + case P_FUNC2S_VC_D0ATOM: + printf("P_FUNC2S_VC_D0ATOM\n"); + break; + case P_FUNC2S_VC_POST_ELSE: + printf("P_FUNC2S_VC_POST_ELSE\n"); + break; + case P_FUNC2S_VC_IFOK_INIT: + printf("P_FUNC2S_VC_IFOK_INIT\n"); + break; + case P_FUNC2S_VC_IFOK_IFOK: + printf("P_FUNC2S_VC_IFOK_IFOK\n"); + break; + case P_FUNC2S_VC_IFOK_NOIF: + printf("P_FUNC2S_VC_IFOK_NOIF\n"); + break; + case P_FUNC2S_VC_INSIDEWHILE: + printf("P_FUNC2S_VC_INSIDEWHILE\n"); + break; + case P_FUNC2S_VC_END1: + printf("P_FUNC2S_VC_END1\n"); + break; + case P_FUNC2S_VC_END2: + printf("P_FUNC2S_VC_END2\n"); + break; + case P_FUNC2S_Y_VV_INSTINIT: + printf("P_FUNC2S_Y_VV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_VV_LOW_LEVEL_TRACER: + printf("P_FUNC2S_Y_VV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_Y_VV_TEST_D0: + printf("P_FUNC2S_Y_VV_TEST_D0\n"); + break; + case P_FUNC2S_Y_VV_TEST_D1: + printf("P_FUNC2S_Y_VV_TEST_D1\n"); + break; + case P_FUNC2S_Y_VV_D1INT: + printf("P_FUNC2S_Y_VV_D1INT\n"); + break; + case P_FUNC2S_Y_VV_D1NOTINT: + printf("P_FUNC2S_Y_VV_D1NOTINT\n"); + break; + case P_FUNC2S_Y_VV_D1BIGINT: + printf("P_FUNC2S_Y_VV_D1BIGINT\n"); + break; + case P_FUNC2S_Y_VV_D1NOTBIGINT: + printf("P_FUNC2S_Y_VV_D1NOTBIGINT\n"); + break; + case P_FUNC2S_Y_VV_POST_IF: + printf("P_FUNC2S_Y_VV_POST_IF\n"); + break; + case P_FUNC2S_Y_VV_D0NOATOMIC: + printf("P_FUNC2S_Y_VV_D0NOATOMIC\n"); + break; + case P_FUNC2S_Y_VV_EQUALS: + printf("P_FUNC2S_Y_VV_EQUALS\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_D0NOATOM: + printf("P_FUNC2S_Y_VV_D1GREATER_D0NOATOM\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_D0ATOM: + printf("P_FUNC2S_Y_VV_D1GREATER_D0ATOM\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_POST_ELSE: + printf("P_FUNC2S_Y_VV_D1GREATER_POST_ELSE\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT: + printf("P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK: + printf("P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF: + printf("P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE: + printf("P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_END: + printf("P_FUNC2S_Y_VV_D1GREATER_END\n"); + break; + case P_FUNC2S_Y_VV_D1ISZERO: + printf("P_FUNC2S_Y_VV_D1ISZERO\n"); + break; + case P_FUNC2S_Y_VV_ELSE: + printf("P_FUNC2S_Y_VV_ELSE\n"); + break; + case P_FUNC2S_Y_VV_END1: + printf("P_FUNC2S_Y_VV_END1\n"); + break; + case P_FUNC2S_Y_VV_END2: + printf("P_FUNC2S_Y_VV_END2\n"); + break; + case P_FUNC2S_Y_CV_INSTINIT: + printf("P_FUNC2S_Y_CV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_CV_LOW_LEVEL_TRACER: + printf("P_FUNC2S_Y_CV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_Y_CV_TEST_D1: + printf("P_FUNC2S_Y_CV_TEST_D1\n"); + break; + case P_FUNC2S_Y_CV_D1INT: + printf("P_FUNC2S_Y_CV_D1INT\n"); + break; + case P_FUNC2S_Y_CV_D1NOTINT: + printf("P_FUNC2S_Y_CV_D1NOTINT\n"); + break; + case P_FUNC2S_Y_CV_D1BIGINT: + printf("P_FUNC2S_Y_CV_D1BIGINT\n"); + break; + case P_FUNC2S_Y_CV_D1NOTBIGINT: + printf("P_FUNC2S_Y_CV_D1NOTBIGINT\n"); + break; + case P_FUNC2S_Y_CV_POST_IF: + printf("P_FUNC2S_Y_CV_POST_IF\n"); + break; + case P_FUNC2S_Y_CV_EQUALS: + printf("P_FUNC2S_Y_CV_EQUALS\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_D0NOATOM: + printf("P_FUNC2S_Y_CV_D1GREATER_D0NOATOM\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_D0ATOM: + printf("P_FUNC2S_Y_CV_D1GREATER_D0ATOM\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_POST_ELSE: + printf("P_FUNC2S_Y_CV_D1GREATER_POST_ELSE\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT: + printf("P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK: + printf("P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF: + printf("P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE: + printf("P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_END: + printf("P_FUNC2S_Y_CV_D1GREATER_END\n"); + break; + case P_FUNC2S_Y_CV_D1ISZERO: + printf("P_FUNC2S_Y_CV_D1ISZERO\n"); + break; + case P_FUNC2S_Y_CV_ELSE: + printf("P_FUNC2S_Y_CV_ELSE\n"); + break; + case P_FUNC2S_Y_CV_END: + printf("P_FUNC2S_Y_CV_END\n"); + break; + case P_FUNC2S_Y_VC_INSTINIT: + printf("P_FUNC2S_Y_VC_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_VC_LOW_LEVEL_TRACER: + printf("P_FUNC2S_Y_VC_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_Y_VC_TEST_D0: + printf("P_FUNC2S_Y_VC_TEST_D0\n"); + break; + case P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC: + printf("P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC\n"); + break; + case P_FUNC2S_Y_VC_D0NOATOMIC: + printf("P_FUNC2S_Y_VC_D0NOATOMIC\n"); + break; + case P_FUNC2S_Y_VC_EQUALS: + printf("P_FUNC2S_Y_VC_EQUALS\n"); + break; + case P_FUNC2S_Y_VC_D1ISZERO: + printf("P_FUNC2S_Y_VC_D1ISZERO\n"); + break; + case P_FUNC2S_Y_VC_D0NOATOM1: + printf("P_FUNC2S_Y_VC_D0NOATOM1\n"); + break; + case P_FUNC2S_Y_VC_D0NOATOM2: + printf("P_FUNC2S_Y_VC_D0NOATOM2\n"); + break; + case P_FUNC2S_Y_VC_D0ATOM: + printf("P_FUNC2S_Y_VC_D0ATOM\n"); + break; + case P_FUNC2S_Y_VC_POST_ELSE: + printf("P_FUNC2S_Y_VC_POST_ELSE\n"); + break; + case P_FUNC2S_Y_VC_IFOK_INIT: + printf("P_FUNC2S_Y_VC_IFOK_INIT\n"); + break; + case P_FUNC2S_Y_VC_IFOK_IFOK: + printf("P_FUNC2S_Y_VC_IFOK_IFOK\n"); + break; + case P_FUNC2S_Y_VC_IFOK_NOIF: + printf("P_FUNC2S_Y_VC_IFOK_NOIF\n"); + break; + case P_FUNC2S_Y_VC_INSIDEWHILE: + printf("P_FUNC2S_Y_VC_INSIDEWHILE\n"); + break; + case P_FUNC2S_Y_VC_END1: + printf("P_FUNC2S_Y_VC_END1\n"); + break; + case P_FUNC2S_Y_VC_END2: + printf("P_FUNC2S_Y_VC_END2\n"); + break; + case P_FUNC2F_XX_INSTINIT: + printf("P_FUNC2F_XX_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_XX_LOW_LEVEL_TRACER: + printf("P_FUNC2F_XX_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2F_XX_TEST_D0: + printf("P_FUNC2F_XX_TEST_D0\n"); + break; + case P_FUNC2F_XX_D0APPL: + printf("P_FUNC2F_XX_D0APPL\n"); + break; + case P_FUNC2F_XX_D0APPL_D1EXTFUNC: + printf("P_FUNC2F_XX_D0APPL_D1EXTFUNC\n"); + break; + case P_FUNC2F_XX_D0APPL_END: + printf("P_FUNC2F_XX_D0APPL_END\n"); + break; + case P_FUNC2F_XX_D0PAIR: + printf("P_FUNC2F_XX_D0PAIR\n"); + break; + case P_FUNC2F_XX_D0NOCOMPOUND: + printf("P_FUNC2F_XX_D0NOCOMPOUND\n"); + break; + case P_FUNC2F_XX_END: + printf("P_FUNC2F_XX_END\n"); + break; + case P_FUNC2F_XY_INSTINIT: + printf("P_FUNC2F_XY_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_XY_LOW_LEVEL_TRACER: + printf("P_FUNC2F_XY_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2F_XY_TEST_D0: + printf("P_FUNC2F_XY_TEST_D0\n"); + break; + case P_FUNC2F_XY_D0APPL: + printf("P_FUNC2F_XY_D0APPL\n"); + break; + case P_FUNC2F_XY_D0APPL_D1EXTFUNC: + printf("P_FUNC2F_XY_D0APPL_D1EXTFUNC\n"); + break; + case P_FUNC2F_XY_D0APPL_END: + printf("P_FUNC2F_XY_D0APPL_END\n"); + break; + case P_FUNC2F_XY_D0PAIR: + printf("P_FUNC2F_XY_D0PAIR\n"); + break; + case P_FUNC2F_XY_D0NOCOMPOUND: + printf("P_FUNC2F_XY_D0NOCOMPOUND\n"); + break; + case P_FUNC2F_XY_END: + printf("P_FUNC2F_XY_END\n"); + break; + case P_FUNC2F_YX_INSTINIT: + printf("P_FUNC2F_YX_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_YX_LOW_LEVEL_TRACER: + printf("P_FUNC2F_YX_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2F_YX_TEST_D0: + printf("P_FUNC2F_YX_TEST_D0\n"); + break; + case P_FUNC2F_YX_D0APPL: + printf("P_FUNC2F_YX_D0APPL\n"); + break; + case P_FUNC2F_YX_D0APPL_D1EXTFUNC: + printf("P_FUNC2F_YX_D0APPL_D1EXTFUNC\n"); + break; + case P_FUNC2F_YX_D0APPL_END: + printf("P_FUNC2F_YX_D0APPL_END\n"); + break; + case P_FUNC2F_YX_D0PAIR: + printf("P_FUNC2F_YX_D0PAIR\n"); + break; + case P_FUNC2F_YX_D0NOCOMPOUND: + printf("P_FUNC2F_YX_D0NOCOMPOUND\n"); + break; + case P_FUNC2F_YX_END: + printf("P_FUNC2F_YX_END\n"); + break; + case P_FUNC2F_YY_INSTINIT: + printf("P_FUNC2F_YY_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_YY_LOW_LEVEL_TRACER: + printf("P_FUNC2F_YY_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2F_YY_TEST_D0: + printf("P_FUNC2F_YY_TEST_D0\n"); + break; + case P_FUNC2F_YY_D0APPL: + printf("P_FUNC2F_YY_D0APPL\n"); + break; + case P_FUNC2F_YY_D0APPL_D1EXTFUNC: + printf("P_FUNC2F_YY_D0APPL_D1EXTFUNC\n"); + break; + case P_FUNC2F_YY_D0APPL_END: + printf("P_FUNC2F_YY_D0APPL_END\n"); + break; + case P_FUNC2F_YY_D0PAIR: + printf("P_FUNC2F_YY_D0PAIR\n"); + break; + case P_FUNC2F_YY_D0NOCOMPOUND: + printf("P_FUNC2F_YY_D0NOCOMPOUND\n"); + break; + case P_FUNC2F_YY_END: + printf("P_FUNC2F_YY_END\n"); + break; + } +} diff --git a/JIT/HPP/processa.cpp b/JIT/HPP/processa.cpp new file mode 100644 index 000000000..d4bb6e235 --- /dev/null +++ b/JIT/HPP/processa.cpp @@ -0,0 +1,97 @@ +#include +#include +#include +#include +#include + +using namespace std; + +#define NFILES 13 + +string files[NFILES] = {"yaam_primitive_predicates", + "yaam_call", + "yaam_call_count", + "yaam_cut", + "yaam_failure", + "yaam_get", + "yaam_indexing_ext", + "yaam_indexing_std", + "yaam_misc", + "yaam_pop", + "yaam_put", + "yaam_unify", + "yaam_write"}; + +int main(int argc, char **argv) +{ + std::string fileinname, fileoutname, linein, lineout; + char lineout_char[256]; + ifstream filein; + ofstream fileout; + int k; + for (int i = 0; i < NFILES; i++) + { + linein = ""; + lineout = ""; + fileinname = files[i] + ".h"; + fileoutname = files[i] + "_mod.h"; + filein.open(fileinname.c_str()); + if (!filein.is_open()) { + cout << "Erro ao abrir arquivo " << fileinname << " para leitura! Saindo..." << endl; + exit(1); + } + fileout.open(fileoutname.c_str()); + if (!fileout.is_open()) { + cout << "Erro ao abrir arquivo " << fileoutname << " para escrita! Saindo..." << endl; + exit(1); + } + cout << "Processando arquivo " << fileinname << "!\n"; + getline(filein, linein); + while (!filein.eof()) + { + lineout = ""; + strcpy(lineout_char, ""); + //cout << "linein = " << linein << endl; /* */ + if (linein.size() > 6) + { + if (linein.substr(0, 7) == "#define") + { + lineout = "#define"; + k = 0; + for (int j = 7; j < linein.size(); j++) + { + if (linein[j] >= 'a' && linein[j] <= 'z') + { + //cout << "linein[j] = " << linein[j] << endl; + lineout_char[k++] = linein[j] - 32; + } + else + { + lineout_char[k++] = linein[j]; + } + } + lineout_char[k] = '\0'; + lineout += lineout_char; + //cout << "lineout 1 = " << lineout << endl; + } + else + { + lineout = linein; + //cout << "lineout 2 = " << lineout << endl; + } + } + else + { + lineout = linein; + //cout << "lineout 3 = " << lineout << endl; + } + fileout << lineout << endl; + getline(filein, linein); + } + lineout = linein; + fileout << lineout << endl; + filein.close(); + fileout.close(); + } + return 0; +} diff --git a/JIT/HPP/singlecode_basics.h b/JIT/HPP/singlecode_basics.h new file mode 100644 index 000000000..5bf23dbc0 --- /dev/null +++ b/JIT/HPP/singlecode_basics.h @@ -0,0 +1,76 @@ +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define check_stack_on_fail \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) return external_labels[10]; +#else +#define check_stack_on_fail \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) return external_labels[10]; +#endif /* YAPOR_SBA && YAPOR */ + +#define GONEXT() \ + if (idx != -1) goto *NOp_Address_R[idx]; \ + else BACK(); + +#define GONEXTW() \ + if (idx != -1) goto *NOp_Address_W[idx]; \ + else BACK(); + +#define YAAM_UnifyBound_TEST_ATTACHED(f,d0,pt0,d1) \ + if (IsExtensionFunctor(f)) { \ + if (unify_extension(f, d0, RepAppl(d0), d1)) \ + { GONEXT(); } \ + else \ + { FAIL(); } \ + } + +#define YAAM_UnifyBound(d0,d1) \ + if (d0 == d1) { GONEXT(); } \ + if (IsPairTerm(d0)) { \ + register CELL *ipt0, *ipt1; \ + if (!IsPairTerm(d1)) { FAIL(); } \ + ipt0 = RepPair(d0); \ + ipt1 = RepPair(d1); \ + save_hb(); \ + always_save_pc(); \ + if (IUnify_complex(ipt0-1,ipt0+1,ipt1-1)) {always_set_pc(); GONEXT();}\ + else { FAIL(); } \ + } else if (IsApplTerm(d0)) { \ + register CELL *ipt0, *ipt1; \ + register Functor f; \ + if (!IsApplTerm(d1)) { FAIL(); } \ + ipt0 = RepAppl(d0); \ + ipt1 = RepAppl(d1); \ + f = (Functor)*ipt0; \ + if (f != (Functor)*ipt1) { FAIL(); } \ + YAAM_UnifyBound_TEST_ATTACHED(f,d0,ipt0,d1); \ + d0 = ArityOfFunctor(f); \ + always_save_pc(); \ + save_hb(); \ + if (IUnify_complex(ipt0, ipt0+d0, ipt1)) {always_set_pc(); GONEXT();} \ + else { FAIL(); } \ + } \ + else { FAIL(); } + +#define _native_me_instinit \ + (*_PREG) = NEXTOP((*_PREG), aFlp); \ + GONEXT(); + +#ifdef COROUTINING +#define _op_fail_instinit \ + if (PP) { \ + UNLOCK(PP->PELock); \ + PP = NULL; \ + } \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_fail; \ + ENDCACHE_Y_AS_ENV(); \ + FAIL(); +#else /* COROUTINING */ +#define _op_fail_instinit \ + if (PP) { \ + UNLOCK(PP->PELock); \ + PP = NULL; \ + } \ + FAIL(); +#endif /* COROUTINING */ + +#define I_R (XREGS[0]) diff --git a/JIT/HPP/singlecode_call.h b/JIT/HPP/singlecode_call.h new file mode 100644 index 000000000..3e4dae5e5 --- /dev/null +++ b/JIT/HPP/singlecode_call.h @@ -0,0 +1,2874 @@ +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define check_stack_on_call \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) return external_labels[6]; +#else +#define check_stack_on_call \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) return external_labels[6]; +#endif /* YAPOR_SBA && YAPOR */ + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define check_stack_on_execute \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) return external_labels[5]; +#else +#define check_stack_on_execute \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) return external_labels[5]; +#endif /* YAPOR_SBA && YAPOR */ + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define check_stack_on_dexecute \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) return external_labels[7]; +#else +#define check_stack_on_dexecute \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) return external_labels[7]; +#endif /* YAPOR_SBA && YAPOR */ + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define check_stack_on_deallocate \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) return external_labels[8]; +#else +#define check_stack_on_deallocate \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) return external_labels[8]; +#endif /* YAPOR_SBA && YAPOR */ + +#ifdef DEPTH_LIMIT +#define _procceed_instinit \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = (*_CPREG); \ + save_pc(); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); +#else /* DEPTH_LIMIT */ +#define _procceed_instinit \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = (*_CPREG); \ + save_pc(); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); +#endif /* DEPTH_LIMIT */ + +#ifdef DEPTH_LIMIT +#define _fcall_instinit \ + CACHE_Y_AS_ENV(YREG); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; \ + ENV_YREG[E_DEPTH] = DEPTH; \ + ENDCACHE_Y_AS_ENV(); \ + _call_instinit; +#else /* DEPTH_LIMIT */ +#define _fcall_instinit \ + CACHE_Y_AS_ENV(YREG); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; \ + ENDCACHE_Y_AS_ENV(); \ + _call_instinit; +#endif /* DEPTH_LIMIT */ + +#ifdef LOW_LEVEL_TRACER +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#else /* YAPOR_SBA */ +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#else /* YAPOR_SBA */ +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#else /* YAPOR_SBA */ +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#else /* YAPOR_SBA */ +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#else /* LOW_LEVEL_TRACER */ +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#else /* YAPOR_SBA */ +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#else /* YAPOR_SBA */ +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#else /* YAPOR_SBA */ +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + FAIL(); \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#else /* YAPOR_SBA */ +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR */ +#define _call_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); \ + check_stack_on_call; \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#endif /* LOW_LEVEL_TRACER */ + +#ifdef LOW_LEVEL_TRACER +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#define _execute_instinit \ + { \ + PredEntry *pt0; \ + CACHE_Y_AS_ENV(YREG); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + } +#else /* DEPTH_LIMIT */ +#define _execute_instinit \ + { \ + PredEntry *pt0; \ + CACHE_Y_AS_ENV(YREG); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + } +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#define _execute_instinit \ + { \ + PredEntry *pt0; \ + CACHE_Y_AS_ENV(YREG); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + } +#else /* DEPTH_LIMIT */ +#define _execute_instinit \ + { \ + PredEntry *pt0; \ + CACHE_Y_AS_ENV(YREG); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + } +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#else /* LOW_LEVEL_TRACER */ +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#define _execute_instinit \ + { \ + PredEntry *pt0; \ + CACHE_Y_AS_ENV(YREG); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + } +#else /* DEPTH_LIMIT */ +#define _execute_instinit \ + { \ + PredEntry *pt0; \ + CACHE_Y_AS_ENV(YREG); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + } +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#define _execute_instinit \ + { \ + PredEntry *pt0; \ + CACHE_Y_AS_ENV(YREG); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + } +#else /* DEPTH_LIMIT */ +#define _execute_instinit \ + { \ + PredEntry *pt0; \ + CACHE_Y_AS_ENV(YREG); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + } +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#endif /* LOW_LEVEL_TRACER */ + +#ifdef LOW_LEVEL_TRACER +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _dexecute_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#else /* LOW_LEVEL_TRACER */ +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _dexecute_instinit \ + CACHE_Y_AS_ENV(YREG); \ + { \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; \ + check_stack_on_dexecute; \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + GONEXT(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#endif /* LOW_LEVEL_TRACER */ + +#ifdef DEPTH_LIMIT +#define _allocate_instinit \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; \ + ENV_YREG[E_DEPTH] = DEPTH; \ + ENV = ENV_YREG; \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#else /* DEPTH_LIMIT */ +#define _allocate_instinit \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; \ + ENV = ENV_YREG; \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#endif /* DEPTH_LIMIT */ + +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef NO_CHECKING +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#else /* NO_CHECKING */ +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + check_stack_on_deallocate; \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#endif /* NO_CHECKING */ +#else /* YAPOR_SBA */ +#ifdef NO_CHECKING +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#else /* NO_CHECKING */ +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + check_stack_on_deallocate; \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#endif /* NO_CHECKING */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef NO_CHECKING +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + if (ENV_YREG > (CELL *) B) \ + ENV_YREG = (CELL *) B; \ + else \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + WRITEBACK_Y_AS_ENV(); \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#else /* NO_CHECKING */ +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + if (ENV_YREG > (CELL *) B) \ + ENV_YREG = (CELL *) B; \ + else \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + WRITEBACK_Y_AS_ENV(); \ + check_stack_on_deallocate; \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#endif /* NO_CHECKING */ +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#ifdef NO_CHECKING +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#else /* NO_CHECKING */ +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + check_stack_on_deallocate; \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#endif /* NO_CHECKING */ +#else /* YAPOR_SBA */ +#ifdef NO_CHECKING +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#else /* NO_CHECKING */ +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + check_stack_on_deallocate; \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#endif /* NO_CHECKING */ +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#ifdef NO_CHECKING +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *) B) \ + ENV_YREG = (CELL *) B; \ + else \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + WRITEBACK_Y_AS_ENV(); \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#else /* NO_CHECKING */ +#define _deallocate_instinit \ + check_trail(TR); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *) B) \ + ENV_YREG = (CELL *) B; \ + else \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + WRITEBACK_Y_AS_ENV(); \ + check_stack_on_deallocate; \ + ENDCACHE_Y_AS_ENV(); \ + GONEXT(); +#endif /* NO_CHECKING */ +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ diff --git a/JIT/HPP/singlecode_cpred.h b/JIT/HPP/singlecode_cpred.h new file mode 100644 index 000000000..cd45f8071 --- /dev/null +++ b/JIT/HPP/singlecode_cpred.h @@ -0,0 +1,3116 @@ +#ifdef SHADOW_S +#ifdef LOW_LEVEL_TRACER +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#endif /* FROZEN_STACKS */ +#else /* LOW_LEVEL_TRACER */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#endif /* FROZEN_STACKS */ +#endif /* LOW_LEVEL_TRACER */ +#else /* SHADOW_S */ +#ifdef LOW_LEVEL_TRACER +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#endif /* FROZEN_STACKS */ +#else /* LOW_LEVEL_TRACER */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _call_cpred_instinit \ + check_trail(TR); \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); \ + BEGD(d0); \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + CACHE_A1(); \ + ENDD(d0); \ + GONEXT(); +#endif /* FROZEN_STACKS */ +#endif /* LOW_LEVEL_TRACER */ +#endif /* SHADOW_S */ + +#ifdef LOW_LEVEL_TRACER +#ifdef SHADOW_S +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#else /* SHADOW_S */ +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,pt0,XREGS+1); \ + } \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#endif /* SHADOW_S */ +#else /* LOW_LEVEL_TRACER */ +#ifdef SHADOW_S +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#else /* SHADOW_S */ +#ifdef NO_CHECKING +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#else /* NO_CHECKING */ +#ifdef DEPTH_LIMIT +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + if (DEPTH <= MkIntTerm(1)) { \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + FAIL(); \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } \ + } else if (pt0->ModuleOfPred) { \ + DEPTH -= MkIntConstant(2); \ + } \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#else /* DEPTH_LIMIT */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#else /* YAPOR_SBA */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } \ + } \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _execute_cpred_instinit \ + check_trail(TR); \ + { \ + PredEntry *pt0; \ + BEGD(d0); \ + CACHE_Y_AS_ENV(YREG); \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + pt0 = (*_PREG)->u.pp.p; \ + CACHE_A1(); \ + BEGD(d0); \ + d0 = (CELL)B; \ + check_stack_on_execute; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; \ + ENDD(d0); \ + { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + FAIL(); \ + } \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + } \ + GONEXT(); \ + ENDCACHE_Y_AS_ENV(); \ + ENDD(d0); \ + } +#endif /* FROZEN_STACKS */ +#endif /* DEPTH_LIMIT */ +#endif /* NO_CHECKING */ +#endif /* SHADOW_S */ +#endif /* LOW_LEVEL_TRACER */ + +#ifdef LOW_LEVEL_TRACER +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _call_usercpred_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *) top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + { \ + yamop *savedP; \ + Yap_StartSlots( PASS_REGS1 ); \ + LOCAL_PrologMode = UserCCallMode; \ + { \ + PredEntry *p = (*_PREG)->u.Osbpp.p; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + savedP = (*_PREG); \ + saveregs(); \ + save_machine_regs(); \ + (*_SREG) = (CELL *) YAP_Execute(p, p->cs.f_code); \ + } \ + Yap_CloseSlots( PASS_REGS1 ); \ + setregs(); \ + LOCAL_PrologMode = UserMode; \ + restore_machine_regs(); \ + (*_PREG) = savedP; \ + } \ + if (EX) { \ + struct DB_TERM *exp = EX; \ + EX = NULL; \ + Yap_JumpToEnv(Yap_PopTermFromDB(exp)); \ + } \ + if (!(*_SREG)) { \ + FAIL(); \ + } \ + YENV = ENV; \ + YREG = ENV; \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _call_usercpred_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *) top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + { \ + yamop *savedP; \ + Yap_StartSlots( PASS_REGS1 ); \ + LOCAL_PrologMode = UserCCallMode; \ + { \ + PredEntry *p = (*_PREG)->u.Osbpp.p; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + savedP = (*_PREG); \ + saveregs(); \ + save_machine_regs(); \ + (*_SREG) = (CELL *) YAP_Execute(p, p->cs.f_code); \ + } \ + Yap_CloseSlots( PASS_REGS1 ); \ + setregs(); \ + LOCAL_PrologMode = UserMode; \ + restore_machine_regs(); \ + (*_PREG) = savedP; \ + } \ + if (EX) { \ + struct DB_TERM *exp = EX; \ + EX = NULL; \ + Yap_JumpToEnv(Yap_PopTermFromDB(exp)); \ + } \ + if (!(*_SREG)) { \ + FAIL(); \ + } \ + YENV = ENV; \ + YREG = ENV; \ + GONEXT(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _call_usercpred_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); \ + } \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); \ + { \ + yamop *savedP; \ + Yap_StartSlots( PASS_REGS1 ); \ + LOCAL_PrologMode = UserCCallMode; \ + { \ + PredEntry *p = (*_PREG)->u.Osbpp.p; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + savedP = (*_PREG); \ + saveregs(); \ + save_machine_regs(); \ + (*_SREG) = (CELL *) YAP_Execute(p, p->cs.f_code); \ + } \ + Yap_CloseSlots( PASS_REGS1 ); \ + setregs(); \ + LOCAL_PrologMode = UserMode; \ + restore_machine_regs(); \ + (*_PREG) = savedP; \ + } \ + if (EX) { \ + struct DB_TERM *exp = EX; \ + EX = NULL; \ + Yap_JumpToEnv(Yap_PopTermFromDB(exp)); \ + } \ + if (!(*_SREG)) { \ + FAIL(); \ + } \ + YENV = ENV; \ + YREG = ENV; \ + GONEXT(); +#endif /* FROZEN_STACKS */ +#else /* LOW_LEVEL_TRACER */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _call_usercpred_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *) top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + { \ + yamop *savedP; \ + Yap_StartSlots( PASS_REGS1 ); \ + LOCAL_PrologMode = UserCCallMode; \ + { \ + PredEntry *p = (*_PREG)->u.Osbpp.p; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + savedP = (*_PREG); \ + saveregs(); \ + save_machine_regs(); \ + (*_SREG) = (CELL *) YAP_Execute(p, p->cs.f_code); \ + } \ + Yap_CloseSlots( PASS_REGS1 ); \ + setregs(); \ + LOCAL_PrologMode = UserMode; \ + restore_machine_regs(); \ + (*_PREG) = savedP; \ + } \ + if (EX) { \ + struct DB_TERM *exp = EX; \ + EX = NULL; \ + Yap_JumpToEnv(Yap_PopTermFromDB(exp)); \ + } \ + if (!(*_SREG)) { \ + FAIL(); \ + } \ + YENV = ENV; \ + YREG = ENV; \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _call_usercpred_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *) top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); \ + } \ + { \ + yamop *savedP; \ + Yap_StartSlots( PASS_REGS1 ); \ + LOCAL_PrologMode = UserCCallMode; \ + { \ + PredEntry *p = (*_PREG)->u.Osbpp.p; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + savedP = (*_PREG); \ + saveregs(); \ + save_machine_regs(); \ + (*_SREG) = (CELL *) YAP_Execute(p, p->cs.f_code); \ + } \ + Yap_CloseSlots( PASS_REGS1 ); \ + setregs(); \ + LOCAL_PrologMode = UserMode; \ + restore_machine_regs(); \ + (*_PREG) = savedP; \ + } \ + if (EX) { \ + struct DB_TERM *exp = EX; \ + EX = NULL; \ + Yap_JumpToEnv(Yap_PopTermFromDB(exp)); \ + } \ + if (!(*_SREG)) { \ + FAIL(); \ + } \ + YENV = ENV; \ + YREG = ENV; \ + GONEXT(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _call_usercpred_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_call; \ + ENDCACHE_Y_AS_ENV(); \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); \ + { \ + yamop *savedP; \ + Yap_StartSlots( PASS_REGS1 ); \ + LOCAL_PrologMode = UserCCallMode; \ + { \ + PredEntry *p = (*_PREG)->u.Osbpp.p; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + savedP = (*_PREG); \ + saveregs(); \ + save_machine_regs(); \ + (*_SREG) = (CELL *) YAP_Execute(p, p->cs.f_code); \ + } \ + Yap_CloseSlots( PASS_REGS1 ); \ + setregs(); \ + LOCAL_PrologMode = UserMode; \ + restore_machine_regs(); \ + (*_PREG) = savedP; \ + } \ + if (EX) { \ + struct DB_TERM *exp = EX; \ + EX = NULL; \ + Yap_JumpToEnv(Yap_PopTermFromDB(exp)); \ + } \ + if (!(*_SREG)) { \ + FAIL(); \ + } \ + YENV = ENV; \ + YREG = ENV; \ + GONEXT(); +#endif /* FROZEN_STACKS */ +#endif /* LOW_LEVEL_TRACER */ diff --git a/JIT/HPP/singlecode_cut.h b/JIT/HPP/singlecode_cut.h new file mode 100644 index 000000000..659e2683d --- /dev/null +++ b/JIT/HPP/singlecode_cut.h @@ -0,0 +1,247 @@ +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define check_stack_on_cut \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) return external_labels[1]; +#else +#define check_stack_on_cut \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) return external_labels[1]; +#endif /* YAPOR_SBA && YAPOR */ + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define check_stack_on_cutt \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) return external_labels[3]; +#else +#define check_stack_on_cutt \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) return external_labels[3]; +#endif /* YAPOR_SBA && YAPOR */ + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define check_stack_on_commitx \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) return external_labels[11]; +#else +#define check_stack_on_commitx \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) return external_labels[11]; +#endif /* YAPOR_SBA && YAPOR */ + +#ifdef COROUTINING +#define _cut_instinit \ + if (FALSE) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_cut; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + do_cut: \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + saveregs(); \ + prune((choiceptr)YREG[E_CB]); \ + setregs(); \ + GONEXT(); +#else /* COROUTINING */ +#define _cut_instinit \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + saveregs(); \ + prune((choiceptr)YREG[E_CB]); \ + setregs(); \ + GONEXT(); +#endif /* COROUTINING */ + +#ifdef COROUTINING +#define _cut_t_instinit \ + if (FALSE) { \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_cutt; \ + ENDCACHE_Y_AS_ENV(); \ + } \ + do_cut_t: \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + saveregs(); \ + prune((choiceptr)YREG[E_CB]); \ + setregs(); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + GONEXT(); +#else /* COROUTINING */ +#define _cut_t_instinit \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + saveregs(); \ + prune((choiceptr)YREG[E_CB]); \ + setregs(); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + GONEXT(); +#endif /* COROUTINING */ + +#define CUT_E_INSTINIT + +#ifdef COROUTINING +#define CUT_E_COROUTINING \ + CACHE_Y_AS_ENV(YREG); \ + check_stack(NoStackCutE, HR); \ + ENDCACHE_Y_AS_ENV(); +#endif + +#define CUT_E_NOCOROUTINING \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + saveregs(); \ + prune((choiceptr)(*_SREG)[E_CB]); \ + setregs(); \ + GONext(); + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define _save_b_x_instinit \ + BEGD(d0); \ + d0 = (*_PREG)->u.x.x; \ + XREG(d0) = MkIntegerTerm((Int)B); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + ENDD(d0); \ + GONEXT(); +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#define _save_b_x_instinit \ + BEGD(d0); \ + d0 = (*_PREG)->u.x.x; \ + XREG(d0) = MkIntegerTerm(LCL0-(CELL *) (B)); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + ENDD(d0); \ + GONEXT(); +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#if defined(YAPOR_SBA) +#define _save_b_y_instinit \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.y.y,MkIntegerTerm((Int)B)); \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONEXT(); +#else /* defined(YAPOR_SBA) */ +#define _save_b_y_instinit \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.y.y,MkIntegerTerm(LCL0-(CELL *)(B))); \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONEXT(); +#endif /* defined(YAPOR_SBA) */ + +#ifdef COROUTINING +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define _commit_b_x_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_commitx; \ + ENDCACHE_Y_AS_ENV(); \ + do_commit_b_x: \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xps.x); \ + deref_head(d0, commit_b_x_unk); \ + commit_b_x_nvar: \ + SET_ASP(YREG, (*_PREG)->u.xps.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xps),Osbpp),l); \ + { \ + choiceptr pt0; \ + pt0 = (choiceptr)IntegerOfTerm(d0); \ + saveregs(); \ + prune(pt0); \ + setregs(); \ + } \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d0, pt1, commit_b_x_unk, commit_b_x_nvar); \ + ENDP(pt1); \ + FAIL(); \ + ENDD(d0); +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#define _commit_b_x_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_commitx; \ + ENDCACHE_Y_AS_ENV(); \ + do_commit_b_x: \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xps.x); \ + deref_head(d0, commit_b_x_unk); \ + commit_b_x_nvar: \ + SET_ASP(YREG, (*_PREG)->u.xps.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xps),Osbpp),l); \ + { \ + choiceptr pt0; \ + pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0)); \ + saveregs(); \ + prune(pt0); \ + setregs(); \ + } \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d0, pt1, commit_b_x_unk, commit_b_x_nvar); \ + ENDP(pt1); \ + FAIL(); \ + ENDD(d0); +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#else /* COROUTINING */ +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define _commit_b_x_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xps.x); \ + deref_head(d0, commit_b_x_unk); \ + commit_b_x_nvar: \ + SET_ASP(YREG, (*_PREG)->u.xps.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xps),Osbpp),l); \ + { \ + choiceptr pt0; \ + pt0 = (choiceptr)IntegerOfTerm(d0); \ + saveregs(); \ + prune(pt0); \ + setregs(); \ + } \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d0, pt1, commit_b_x_unk, commit_b_x_nvar); \ + ENDP(pt1); \ + FAIL(); \ + ENDD(d0); +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#define _commit_b_x_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xps.x); \ + deref_head(d0, commit_b_x_unk); \ + commit_b_x_nvar: \ + SET_ASP(YREG, (*_PREG)->u.xps.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xps),Osbpp),l); \ + { \ + choiceptr pt0; \ + pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0)); \ + saveregs(); \ + prune(pt0); \ + setregs(); \ + } \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d0, pt1, commit_b_x_unk, commit_b_x_nvar); \ + ENDP(pt1); \ + FAIL(); \ + ENDD(d0); +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#endif /* COROUTINING */ + +#define COMMIT_B_Y_INSTINIT \ + register CELL d0; \ + register CELL *pt1; + +#define COMMIT_B_Y_DO_COMMIT_B_Y \ + d0 = YREG[(*_PREG)->u.yps.y]; + +#define COMMIT_B_Y_COMMIT_B_Y_NVAR \ + SET_ASP(YREG, (*_PREG)->u.yps.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yps),Osbpp),l); \ + choiceptr pt0; + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define COMMIT_B_Y_YSBA_FROZEN \ + pt0 = (choiceptr)IntegerOfTerm(d0); +#else +#define COMMIT_B_Y_NOYSBA_NOFROZEN \ + pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0)); +#endif + +#define COMMIT_B_Y_POST_YSBA_FROZEN \ + saveregs(); \ + prune(pt0); \ + setregs(); \ + GONext(); + diff --git a/JIT/HPP/singlecode_get.h b/JIT/HPP/singlecode_get.h new file mode 100644 index 000000000..6022601a5 --- /dev/null +++ b/JIT/HPP/singlecode_get.h @@ -0,0 +1,864 @@ +#define _get_x_var_instinit \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.xx.xr); \ + XREG((*_PREG)->u.xx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONEXT(); + +#define _get_y_var_instinit \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + d0 = XREG((*_PREG)->u.yx.x); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONEXT(); + +#define _get_yy_var_instinit \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + CACHE_Y(YREG); \ + pt0 = S_YREG + (*_PREG)->u.yyxx.y1; \ + d0 = XREG((*_PREG)->u.yyxx.x1); \ + pt1 = S_YREG + (*_PREG)->u.yyx.y2; \ + d1 = XREG((*_PREG)->u.yyxx.x2); \ + (*_PREG) = NEXTOP((*_PREG), yyxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + INITIALIZE_PERMVAR(pt1,d1); \ + ENDCACHE_Y(); \ + GONEXT(); + +#define _get_x_val_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xx.xl); \ + deref_head(d0, gvalx_unk); \ + \ + gvalx_nonvar: \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.xx.xr); \ + deref_head(d1, gvalx_nonvar_unk); \ + \ + gvalx_nonvar_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + YAAM_UnifyBound(d0, d1); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, gvalx_nonvar_unk, gvalx_nonvar_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt0, d0); \ + GONEXT(); \ + ENDP(pt0); \ + ENDD(d1); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, gvalx_unk, gvalx_nonvar); \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.xx.xr); \ + deref_head(d1, gvalx_var_unk); \ + \ + gvalx_var_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt0, d1); \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, gvalx_var_unk, gvalx_var_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + UnifyCells(pt0, pt1); \ + GONEXT(); \ + ENDP(pt1); \ + ENDD(d1); \ + ENDP(pt0); \ + ENDD(d0); + +#define _get_y_val_instinit \ + BEGD(d0); \ + BEGD(d1); \ + BEGP(pt0); \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + d0 = *pt0; \ + \ + deref_head(d0, gvaly_unk); \ + gvaly_nonvar: \ + d1 = XREG((*_PREG)->u.yx.x); \ + deref_head(d1, gvaly_nonvar_unk); \ + \ + gvaly_nonvar_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + YAAM_UnifyBound(d0, d1); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, gvaly_nonvar_unk, gvaly_nonvar_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind(pt1, d0); \ + GONEXT(); \ + ENDP(pt1); \ + \ + derefa_body(d0, pt0, gvaly_unk, gvaly_nonvar); \ + d1 = XREG((*_PREG)->u.yx.x); \ + deref_head(d1, gvaly_var_unk); \ + gvaly_var_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind(pt0, d1); \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, gvaly_var_unk, gvaly_var_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + UnifyCells(pt0, pt1); \ + GONEXT(); \ + ENDP(pt1); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _get_atom_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = XREG((*_PREG)->u.xc.x); \ + d1 = (*_PREG)->u.xc.c; \ + \ + BEGP(pt0); \ + deref_head(d0, gatom_unk); \ + gatom_nonvar: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), xc); \ + GONEXT(); \ + } \ + else { \ + FAIL(); \ + } \ + \ + deref_body(d0, pt0, gatom_unk, gatom_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), xc); \ + Bind(pt0, d1); \ + GONEXT(); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _get_2atoms_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + \ + BEGP(pt0); \ + deref_head(d0, gatom_2unk); \ + gatom_2nonvar: \ + if (d0 == (*_PREG)->u.cc.c1) { \ + goto gatom_2b; \ + } \ + else { \ + FAIL(); \ + } \ + \ + deref_body(d0, pt0, gatom_2unk, gatom_2nonvar); \ + Bind(pt0, (*_PREG)->u.cc.c1); \ + ENDP(pt0); \ + gatom_2b: \ + d0 = ARG2; \ + d1 = (*_PREG)->u.cc.c2; \ + \ + BEGP(pt0); \ + deref_head(d0, gatom_2bunk); \ + gatom_2bnonvar: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), cc); \ + GONEXT(); \ + } \ + else { \ + FAIL(); \ + } \ + \ + deref_body(d0, pt0, gatom_2bunk, gatom_2bnonvar); \ + (*_PREG) = NEXTOP((*_PREG), cc); \ + Bind(pt0, d1); \ + GONEXT(); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _get_3atoms_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + \ + BEGP(pt0); \ + deref_head(d0, gatom_3unk); \ + gatom_3nonvar: \ + if (d0 == (*_PREG)->u.ccc.c1) { \ + goto gatom_3b; \ + } \ + else { \ + FAIL(); \ + } \ + \ + deref_body(d0, pt0, gatom_3unk, gatom_3nonvar); \ + Bind(pt0, (*_PREG)->u.ccc.c1); \ + ENDP(pt0); \ + gatom_3b: \ + d0 = ARG2; \ + \ + BEGP(pt0); \ + deref_head(d0, gatom_3bunk); \ + gatom_3bnonvar: \ + if (d0 == (*_PREG)->u.ccc.c2) { \ + goto gatom_3c; \ + } \ + else { \ + FAIL(); \ + } \ + \ + deref_body(d0, pt0, gatom_3bunk, gatom_3bnonvar); \ + Bind(pt0, (*_PREG)->u.ccc.c2); \ + ENDP(pt0); \ + gatom_3c: \ + d0 = ARG3; \ + d1 = (*_PREG)->u.ccc.c3; \ + \ + BEGP(pt0); \ + deref_head(d0, gatom_3cunk); \ + gatom_3cnonvar: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), ccc); \ + GONEXT(); \ + } \ + else { \ + FAIL(); \ + } \ + \ + deref_body(d0, pt0, gatom_3cunk, gatom_3cnonvar); \ + (*_PREG) = NEXTOP((*_PREG), ccc); \ + Bind(pt0, d1); \ + GONEXT(); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define GET_4ATOMS_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_4ATOMS_GATOM_4UNK \ + Bind(pt0, (*_PREG)->u.cccc.c1); + +#define GET_4ATOMS_GATOM_4B \ + d0 = ARG2; + +#define GET_4ATOMS_GATOM_4BUNK \ + Bind(pt0, (*_PREG)->u.cccc.c2); + +#define GET_4ATOMS_GATOM_4C \ + d0 = ARG3; + +#define GET_4ATOMS_GATOM_4CUNK \ + Bind(pt0, (*_PREG)->u.cccc.c3); + +#define GET_4ATOMS_GATOM_4D \ + d0 = ARG4; \ + d1 = (*_PREG)->u.cccc.c4; + +#define GET_4ATOMS_EQUALS \ + (*_PREG) = NEXTOP((*_PREG), cccc); \ + GONext(); + +#define GET_4ATOMS_GATOM_4DUNK \ + (*_PREG) = NEXTOP((*_PREG), cccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_5ATOMS_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_5ATOMS_GATOM_5UNK \ + Bind(pt0, (*_PREG)->u.ccccc.c1); + +#define GET_5ATOMS_GATOM_5B \ + d0 = ARG2; + +#define GET_5ATOMS_GATOM_5BUNK \ + Bind(pt0, (*_PREG)->u.ccccc.c2); + +#define GET_5ATOMS_GATOM_5C \ + d0 = ARG3; + +#define GET_5ATOMS_GATOM_5CUNK \ + Bind(pt0, (*_PREG)->u.ccccc.c3); + +#define GET_5ATOMS_GATOM_5D \ + d0 = ARG4; + +#define GET_5ATOMS_GATOM_5DUNK \ + Bind(pt0, (*_PREG)->u.ccccc.c4); + +#define GET_5ATOMS_GATOM_5E \ + d0 = ARG5; \ + d1 = (*_PREG)->u.ccccc.c5; + +#define GET_5ATOMS_EQUALS \ + (*_PREG) = NEXTOP((*_PREG), ccccc); \ + GONext(); + +#define GET_5ATOMS_GATOM_5EUNK \ + (*_PREG) = NEXTOP((*_PREG), ccccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_6ATOMS_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_6ATOMS_GATOM_6UNK \ + Bind(pt0, (*_PREG)->u.cccccc.c1); + +#define GET_6ATOMS_GATOM_6B \ + d0 = ARG2; + +#define GET_6ATOMS_GATOM_6BUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c2); + +#define GET_6ATOMS_GATOM_6C \ + d0 = ARG3; + +#define GET_6ATOMS_GATOM_6CUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c3); + +#define GET_6ATOMS_GATOM_6D \ + d0 = ARG4; + +#define GET_6ATOMS_GATOM_6DUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c4); + +#define GET_6ATOMS_GATOM_6E \ + d0 = ARG5; + +#define GET_6ATOMS_GATOM_6EUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c5); + +#define GET_6ATOMS_GATOM_6F \ + d0 = ARG6; \ + d1 = (*_PREG)->u.cccccc.c6; + +#define GET_6ATOMS_EQUALS \ + (*_PREG) = NEXTOP((*_PREG), cccccc); \ + GONext(); + +#define GET_6ATOMS_GATOM_6FUNK \ + (*_PREG) = NEXTOP((*_PREG), cccccc); \ + Bind(pt0, d1); \ + GONext(); + +#define _get_list_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.x.x); \ + deref_head(d0, glist_unk); \ + \ + glist_nonvar: \ + if (!IsPairTerm(d0)) { \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), x); \ + (*_SREG) = RepPair(d0); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, glist_unk, glist_nonvar); \ + CACHE_S(); \ + S_SREG = HR; \ + (*_PREG) = NEXTOP((*_PREG), x); \ + BEGD(d0); \ + d0 = AbsPair(S_SREG); \ + Bind(pt0, d0); \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + ENDD(d0); \ + WRITEBACK_S(S_SREG); \ + GONEXTW(); \ + ENDCACHE_S(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _get_struct_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xfa.x); \ + deref_head(d0, gstruct_unk); \ + \ + gstruct_nonvar: \ + if (!IsApplTerm(d0)) { \ + FAIL(); \ + } \ + CACHE_S(); \ + S_SREG = RepAppl(d0); \ + d0 = (CELL) ((*_PREG)->u.xfa.f); \ + if (*S_SREG != d0) { \ + FAIL(); \ + } \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + (*_PREG) = NEXTOP((*_PREG), xfa); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, gstruct_unk, gstruct_nonvar); \ + BEGD(d1); \ + d1 = AbsAppl(HR); \ + Bind(pt0, d1); \ + pt0 = HR; \ + ENDD(d1); \ + d0 = (CELL) ((*_PREG)->u.xfa.f); \ + *pt0++ = d0; \ + HR = pt0 + (*_PREG)->u.xfa.a; \ + (*_PREG) = NEXTOP((*_PREG), xfa); \ + (*_SREG) = pt0; \ + GONEXTW(); \ + ENDP(pt0); \ + ENDD(d0); + +#if SIZEOF_DOUBLE == 2*SIZEOF_INT_P +#define _get_float_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xd.x); \ + deref_head(d0, gfloat_unk); \ + \ + gfloat_nonvar: \ + if (!IsApplTerm(d0)) { \ + FAIL(); \ + } \ + BEGP(pt0); \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorDouble) { \ + FAIL(); \ + } \ + BEGP(pt1); \ + pt1 = (*_PREG)->u.xd.d; \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + if ( \ + pt1[1] != pt0[1] \ + || pt1[2] != pt0[2] \ + ) { \ + FAIL(); \ + } \ + ENDP(pt1); \ + ENDP(pt0); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, gfloat_unk, gfloat_nonvar); \ + BEGD(d1); \ + d1 = AbsAppl((*_PREG)->u.xd.d); \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + Bind(pt0, d1); \ + GONEXT(); \ + ENDD(d1); \ + ENDP(pt0); \ + ENDD(d0); +#else /* SIZEOF_DOUBLE == 2*SIZEOF_INT_P */ +#define _get_float_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xd.x); \ + deref_head(d0, gfloat_unk); \ + \ + gfloat_nonvar: \ + if (!IsApplTerm(d0)) { \ + FAIL(); \ + } \ + BEGP(pt0); \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorDouble) { \ + FAIL(); \ + } \ + BEGP(pt1); \ + pt1 = (*_PREG)->u.xd.d; \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + if ( \ + pt1[1] != pt0[1] \ + ) { \ + FAIL(); \ + } \ + ENDP(pt1); \ + ENDP(pt0); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, gfloat_unk, gfloat_nonvar); \ + BEGD(d1); \ + d1 = AbsAppl((*_PREG)->u.xd.d); \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + Bind(pt0, d1); \ + GONEXT(); \ + ENDD(d1); \ + ENDP(pt0); \ + ENDD(d0); +#endif /* SIZEOF_DOUBLE == 2*SIZEOF_INT_P */ + +#define GET_LONGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xi.x); + +#define GET_LONGINT_GLONGINT_NONVAR_INIT \ + START_PREFETCH(xi); \ + pt0 = RepAppl(d0); + +#define GET_LONGINT_GLONGINT_NONVAR_END \ + (*_PREG) = NEXTOP((*_PREG), xi); \ + GONext(); \ + END_PREFETCH(); + +#define GET_LONGINT_GLONGINT_UNK \ + START_PREFETCH(xi); \ + d1 = AbsAppl((*_PREG)->u.xi.i); \ + (*_PREG) = NEXTOP((*_PREG), xi); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); + +#ifdef USE_GMP +#define GET_BIGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xN.x); + +#define GET_BIGINT_GBIGINT_NONVAR_INIT \ + START_PREFETCH(xN); \ + pt0 = RepAppl(d0); + +#define GET_BIGINT_GBIGINT_NONVAR_END \ + (*_PREG) = NEXTOP((*_PREG), xN); \ + GONext(); \ + END_PREFETCH(); + +#define GET_BIGINT_GBIGINT_UNK \ + START_PREFETCH(xN); \ + d1 = (*_PREG)->u.xN.b; \ + (*_PREG) = NEXTOP((*_PREG), xN); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); +#endif + +#define GET_DBTERM_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xD.x); + +#define GET_DBTERM_GDBTERM_NONVAR \ + BLOCK = (CELL)GET_DBTERM_GDBTERM_NONVAR; \ + d1 = (*_PREG)->u.xD.D; \ + (*_PREG) = NEXTOP((*_PREG), xD); \ + YAAM_UNIFYBOUND; + +#define GET_DBTERM_GDBTERM_UNK \ + START_PREFETCH(xD); \ + d1 = (*_PREG)->u.xD.D; \ + (*_PREG) = NEXTOP((*_PREG), xD); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); + +#define _glist_valx_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xx.xl); \ + deref_head(d0, glist_valx_write); \ + glist_valx_read: \ + BEGP(pt0); \ + if (!IsPairTerm(d0)) { \ + FAIL(); \ + } \ + pt0 = RepPair(d0); \ + (*_SREG) = pt0 + 1; \ + d0 = *pt0; \ + deref_head(d0, glist_valx_unk); \ + \ + glist_valx_nonvar: \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.xx.xr); \ + deref_head(d1, glist_valx_nonvar_unk); \ + \ + glist_valx_nonvar_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + YAAM_UnifyBound(d0, d1); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, glist_valx_nonvar_unk, glist_valx_nonvar_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt1, d0); \ + GONEXT(); \ + ENDP(pt1); \ + ENDD(d1); \ + \ + derefa_body(d0, pt0, glist_valx_unk, glist_valx_nonvar); \ + d0 = XREG((*_PREG)->u.xx.xr); \ + deref_head(d0, glist_valx_var_unk); \ + \ + glist_valx_var_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind_Global(pt0, d0); \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d0, pt1, glist_valx_var_unk, glist_valx_var_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONEXT(); \ + ENDP(pt1); \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, glist_valx_write, glist_valx_read); \ + CACHE_S(); \ + S_SREG = HR; \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.xx.xr); \ + d0 = AbsPair(S_SREG); \ + S_SREG[0] = d1; \ + ENDD(d1); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG+1); \ + Bind(pt0, d0); \ + GONEXTW(); \ + ENDCACHE_S(); \ + ENDP(pt0); \ + ENDD(d0); + +#define GLIST_VALY_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yx.x); + +#define GLIST_VALY_GLIST_VALY_READ \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + START_PREFETCH(yx); \ + pt0 = RepPair(d0); \ + (*_SREG) = pt0 + 1; \ + d0 = *pt0; + +#define GLIST_VALY_GLIST_VALY_NONVAR \ + pt1 = YREG + (*_PREG)->u.yx.y; \ + d1 = *pt1; \ + (*_PREG) = NEXTOP((*_PREG), yx); + +#define GLIST_VALY_GLIST_VALY_NONVAR_NONVAR \ + BLOCK = (CELL)GLIST_VALY_GLIST_VALY_NONVAR_NONVAR; \ + (*_SREG) = pt0 + 1; \ + YAAM_UNIFYBOUND; + +#define GLIST_VALY_GLIST_VALY_NONVAR_UNK \ + Bind(pt1, d0); \ + GONext(); + +#define GLIST_VALY_GLIST_VALY_UNK \ + pt1 = YREG+(*_PREG)->u.yx.y; \ + d1 = *pt1; + +#define GLIST_VALY_GLIST_VALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define GLIST_VALY_GLIST_VALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); \ + END_PREFETCH(); + +#define GLIST_VALY_GLIST_VALY_WRITE \ + START_PREFETCH_W(yx); \ + pt1 = HR; \ + d0 = AbsPair(pt1); \ + Bind(pt0, d0); \ + d0 = YREG[(*_PREG)->u.yx.y]; \ + pt1[0] = d0; \ + HR = pt1 + 2; \ + (*_SREG) = pt1 + 1; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONextW(); \ + END_PREFETCH_W(); + +#define _gl_void_varx_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xx.xl); \ + deref_head(d0, glist_void_varx_write); \ + glist_void_varx_read: \ + if (!IsPairTerm(d0)) { \ + FAIL(); \ + } \ + BEGP(pt0); \ + pt0 = RepPair(d0); \ + d0 = pt0[1]; \ + XREG((*_PREG)->u.xx.xr) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONEXT(); \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, glist_void_varx_write, glist_void_varx_read); \ + BEGP(pt1); \ + pt1 = HR; \ + XREG((*_PREG)->u.xx.xr) = \ + Unsigned(pt1 + 1); \ + RESET_VARIABLE(pt1); \ + RESET_VARIABLE(pt1+1); \ + HR = pt1 + 2; \ + BEGD(d0); \ + d0 = AbsPair(pt1); \ + Bind(pt0, d0); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + ENDD(d0); \ + ENDP(pt1); \ + GONEXT(); \ + ENDP(pt0); \ + ENDD(d0); + +#define GL_VOID_VARY_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yx.x); + +#define GL_VOID_VARY_GLIST_VOID_VARY_READ \ + BLOCK = (CELL)GL_VOID_VARY_GLIST_VOID_VARY_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0); \ + d0 = pt0[1]; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.yx.y,d0); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); \ + } + +#define GL_VOID_VARY_GLIST_VOID_VARY_WRITE \ + pt1 = HR; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.yx.y,Unsigned(pt1 + 1)); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + RESET_VARIABLE(pt1); \ + RESET_VARIABLE(pt1+1); \ + d0 = AbsPair(pt1); \ + HR = pt1 + 2; \ + Bind(pt0, d0); \ + GONext(); + +#define GL_VOID_VALX_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xx.xl); + +#define GL_VOID_VALX_GLIST_VOID_VALX_READ \ + BLOCK = (CELL)GL_VOID_VALX_GLIST_VOID_VALX_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0)+1; \ + d0 = *pt0; \ + } + +#define GL_VOID_VALX_GLIST_VOID_VALX_NONVAR \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR \ + BLOCK = (CELL)GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + YAAM_UNIFYBOUND; + +#define GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt1, d0); \ + GONext(); + +#define GL_VOID_VALX_GLIST_VOID_VALX_UNK \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define GL_VOID_VALX_GLIST_VOID_VALX_WRITE \ + pt1 = HR; \ + d0 = AbsPair(pt1); \ + Bind(pt0, d0); \ + pt1 = HR; \ + d0 = XREG((*_PREG)->u.xx.xr); \ + RESET_VARIABLE(pt1); \ + pt1[1] = d0; \ + HR = pt1 + 2; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONext(); + +#define GL_VOID_VALY_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yx.x); + +#define GL_VOID_VALY_GLIST_VOID_VALY_READ \ + BLOCK = (CELL)GL_VOID_VALY_GLIST_VOID_VALY_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0)+1; \ + d0 = *pt0; \ + } + +#define GL_VOID_VALY_GLIST_VOID_VALY_NONVAR \ + pt1 = YREG+(*_PREG)->u.yx.y; \ + d1 = *pt1; + +#define GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR \ + BLOCK = (CELL)GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + YAAM_UNIFYBOUND; + +#define GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind(pt1, d0); \ + GONext(); + +#define GL_VOID_VALY_GLIST_VOID_VALY_UNK \ + pt1 = YREG+(*_PREG)->u.yx.y; \ + d1 = *pt1; + +#define GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define GL_VOID_VALY_GLIST_VOID_VALY_WRITE \ + CACHE_S(); \ + S_SREG = HR; \ + d0 = AbsPair(S_SREG); \ + Bind(pt0, d0); \ + S_SREG = HR; \ + d1 = YREG[(*_PREG)->u.yx.y]; \ + RESET_VARIABLE(S_SREG); \ + S_SREG[1] = d1; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + HR = S_SREG + 2; \ + ENDCACHE_S(); \ + GONext(); + diff --git a/JIT/HPP/singlecode_misc.h b/JIT/HPP/singlecode_misc.h new file mode 100644 index 000000000..f4ff7b0e7 --- /dev/null +++ b/JIT/HPP/singlecode_misc.h @@ -0,0 +1,1753 @@ +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define check_stack_on_either \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) return external_labels[4]; +#else +#define check_stack_on_either \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) return external_labels[4]; +#endif /* YAPOR_SBA && YAPOR */ + +#define LUCK_LU_INSTINIT + +#if PARALLEL_YAP +#define LOCK_LU_PARALLEL_PP \ + GONext(); + +#define LOCK_LU_PARALLEL \ + PP = (*_PREG)->u.p.p; \ + PELOCK(3, PP); +#endif + +#define LOCK_LU_END \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); + +#define UNLOCK_LU_INSTINIT + +#if defined(YAPOR) || defined(THREADS) +#define UNLOCK_LU_YAPOR_THREADS \ + UNLOCKPE(1,PP); \ + PP = NULL; +#endif + +#define UNLOCK_LU_END \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); + +#define ALLOC_FOR_LOGICAL_PRED_INSTINIT + +#if MULTIPLE_STACKS +#define ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS \ + LogUpdClause *cl = (*_PREG)->u.L.ClBase; +#if PARALLEL_YAP +#define ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL \ + PredEntry *ap = cl->ClPred; +#endif +#define ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(2,ap); \ + PP = NULL; +#else +#define ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT \ + LogUpdClause *cl = (LogUpdClause *)(*_PREG)->u.L.ClBase; + +#define ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IFOK \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); +#endif + +#define ALLOC_FOR_LOGICAL_PRED_END \ + (*_PREG) = NEXTOP((*_PREG), L); \ + JMPNext(); + +#if defined(YAPOR) || defined(THREADS) +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_growglobal(NULL)) { \ + UNLOCKPE(3,PP); \ + PP = NULL; \ + Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_gc(3, ENV, CP)) { \ + UNLOCKPE(4,PP); \ + PP = NULL; \ + Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } \ + } \ + if (!FAILED) { \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_growglobal(NULL)) { \ + UNLOCKPE(3,PP); \ + PP = NULL; \ + Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_gc(3, ENV, CP)) { \ + UNLOCKPE(4,PP); \ + PP = NULL; \ + Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; tofail = 1; \ + break; \ + } \ + } \ + } \ + if (!FAILED) { \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } \ + } +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_growglobal(NULL)) { \ + UNLOCKPE(3,PP); \ + PP = NULL; \ + Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_gc(3, ENV, CP)) { \ + UNLOCKPE(4,PP); \ + PP = NULL; \ + Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } \ + } \ + if (!FAILED) { \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_growglobal(NULL)) { \ + UNLOCKPE(3,PP); \ + PP = NULL; \ + Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_gc(3, ENV, CP)) { \ + UNLOCKPE(4,PP); \ + PP = NULL; \ + Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } \ + } \ + if (!FAILED) { \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } \ + } +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#else /* defined(YAPOR) || defined(THREADS) */ +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_growglobal(NULL)) { \ + UNLOCKPE(3,PP); \ + Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_gc(3, ENV, CP)) { \ + UNLOCKPE(4,PP); \ + Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } \ + } \ + if (!FAILED) { \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_growglobal(NULL)) { \ + UNLOCKPE(3,PP); \ + Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_gc(3, ENV, CP)) { \ + UNLOCKPE(4,PP); \ + Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } \ + } \ + if (!FAILED) { \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } \ + } +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_growglobal(NULL)) { \ + UNLOCKPE(3,PP); \ + Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_gc(3, ENV, CP)) { \ + UNLOCKPE(4,PP); \ + Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } \ + } \ + if (!FAILED) { \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_growglobal(NULL)) { \ + UNLOCKPE(3,PP); \ + Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } else { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + if (!Yap_gc(3, ENV, CP)) { \ + UNLOCKPE(4,PP); \ + Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); \ + YAAM_FAIL; \ + break; \ + } \ + } \ + } \ + if (!FAILED) { \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } \ + } +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define COPY_IDB_TERM_END \ + BLOCK = (CELL)COPY_IDB_TERM_END; + +#define UNIFY_IDB_TERM_INSTINIT \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); + +#define UNIFY_IDB_TERM_NOUNIFYARG2_INIT \ + setregs(); \ + UNLOCKPE(8,PP); + +#if defined(YAPOR) || defined(THREADS) +#define UNIFY_IDB_TERM_NOUNIFYARG2_YAPOR_THREADS \ + PP = NULL; +#endif + +#define UNIFY_IDB_TERM_NOUNIFYARG3_INIT \ + setregs(); \ + UNLOCKPE(9,PP); + +#if defined(YAPOR) || defined(THREADS) +#define UNIFY_IDB_TERM_NOUNIFYARG3_YAPOR_THREADS \ + PP = NULL; +#endif + +#define UNIFY_IDB_TERM_SETREGS \ + setregs(); + +#if MULTIPLE_STACKS +#define UNIFY_IDB_TERM_MULTIPLE_STACKS \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(10,PP); \ + PP = NULL; +#else +#define UNIFY_IDB_TERM_NOMULTIPLE_STACKS_IFOK \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); +#endif + +#define UNIFY_IDB_TERM_POST_MULTIPLE \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; + +#ifdef DEPTH_LIMIT +#define UNIFY_IDB_TERM_DEPTH \ + DEPTH = YREG[E_DEPTH]; +#endif + +#define UNIFY_IDB_TERM_END \ + JMPNext(); + +#define ENSURE_SPACE_INSTINIT \ + Int sz = (*_PREG)->u.Osbpa.i; \ + UInt arity = (*_PREG)->u.Osbpa.p->ArityOfPE; + +#define ENSURE_SPACE_FIRSTIFOK_INIT \ + YENV[E_CP] = (CELL) (*_CPREG); \ + YENV[E_E] = (CELL) ENV; + +#ifdef DEPTH_LIMIT +#define ENSURE_SPACE_FIRSTIFOK_DEPTH \ + YENV[E_DEPTH] = DEPTH; +#endif + +#define ENSURE_SPACE_FIRSTIFOK_END \ + SET_ASP(YREG, (*_PREG)->u.Osbpa.s); \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); \ + saveregs(); + +#define ENSURE_SPACE_SECONDIFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define ENSURE_SPACE_NOSECONDIF \ + setregs(); + +#define ENSURE_SPACE_NOFIRSTIF \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); + +#define ENSURE_SPACE_END \ + JMPNext(); + +#define _jump_instinit \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); + +#define MOVE_BACK_INSTINIT \ + (*_PREG) = (yamop *)(((char *)(*_PREG))-(Int)(NEXTOP((yamop *)NULL,Osbpp))); \ + JMPNext(); + +#define SKIP_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG),l); \ + JMPNext(); + +#ifdef YAPOR +#ifdef COROUTINING +#ifdef LOW_LEVEL_TRACER +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#else /* YAPOR_SBA */ +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + if (pt1 > B) \ + pt1 = B; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* LOW_LEVEL_TRACER */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _either_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#else /* YAPOR_SBA */ +#define _either_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _either_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + if (pt1 > B) \ + pt1 = B; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#endif /* LOW_LEVEL_TRACER */ +#else /* COROUTINING */ +#ifdef LOW_LEVEL_TRACER +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#else /* YAPOR_SBA */ +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + if (pt1 > B) \ + pt1 = B; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* LOW_LEVEL_TRACER */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _either_instinit \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#else /* YAPOR_SBA */ +#define _either_instinit \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _either_instinit \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + if (pt1 > B) \ + pt1 = B; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SCH_set_load(pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#endif /* LOW_LEVEL_TRACER */ +#endif /* COROUTINING */ +#else /* YAPOR */ +#ifdef COROUTINING +#ifdef LOW_LEVEL_TRACER +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#else /* YAPOR_SBA */ +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + if (pt1 > B) \ + pt1 = B; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* LOW_LEVEL_TRACER */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _either_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#else /* YAPOR_SBA */ +#define _either_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _either_instinit \ + CACHE_Y_AS_ENV(YREG); \ + check_stack_on_either; \ + ENDCACHE_Y_AS_ENV(); \ + either_notest: \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + if (pt1 > B) \ + pt1 = B; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#endif /* LOW_LEVEL_TRACER */ +#else /* COROUTINING */ +#ifdef LOW_LEVEL_TRACER +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#else /* YAPOR_SBA */ +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _either_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); \ + } \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + if (pt1 > B) \ + pt1 = B; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* LOW_LEVEL_TRACER */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define _either_instinit \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#else /* YAPOR_SBA */ +#define _either_instinit \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define _either_instinit \ + BEGD(d0); \ + d0 = (*_PREG)->u.Osblp.s; \ + BEGCHO(pt1); \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); \ + if (pt1 > B) \ + pt1 = B; \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); \ + SET_BB(pt1); \ + ENDCHO(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONEXT(); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#endif /* LOW_LEVEL_TRACER */ +#endif /* COROUTINING */ +#endif /* YAPOR */ + +#define OR_ELSE_INSTINIT \ + HR = HRBREG = PROTECT_FROZEN_H(B); \ + ENV = B->cp_env; \ + B->cp_cp = (*_PREG); + +#ifdef DEPTH_LIMIT +#define OR_ELSE_DEPTH \ + DEPTH = B->cp_depth; +#endif + +#define OR_ELSE_POST_DEPTH \ + SET_BB(PROTECT_FROZEN_B(B)); + +#ifdef YAPOR +#define OR_ELSE_YAPOR \ + SCH_new_alternative((*_PREG), (*_PREG)->u.Osblp.l); +#endif + +#define OR_ELSE_END \ + B->cp_ap = (*_PREG)->u.Osblp.l; \ + (*_PREG) = NEXTOP((*_PREG), Osblp); \ + YREG = (CELL *) B->cp_a1; \ + GONext(); + +#define OR_LAST_INSTINIT \ + register choiceptr pt0; \ + pt0 = B; + +#ifdef YAPOR +#define OR_LAST_IFOK_INIT \ + H = HRBREG = PROTECT_FROZEN_H(pt0); \ + YREG = (CELL *) pt0->cp_a1; \ + ENV = pt0->cp_env; + +#ifdef DEPTH_LIMIT +#define OR_LAST_IFOK_DEPTH \ + DEPTH = pt0->cp_depth; +#endif + +#define OR_LAST_IFOK_END \ + SCH_new_alternative((*_PREG), NULL); +#endif + +#define OR_LAST_NOIF_INIT \ + B = pt0->cp_b; \ + H = PROTECT_FROZEN_H(pt0); \ + YREG = (CELL *) pt0->cp_a1; \ + ENV = pt0->cp_env; + +#ifdef DEPTH_LIMIT +#define OR_LAST_NOIF_DEPTH \ + DEPTH = pt0->cp_depth; +#endif + +#define OR_LAST_NOIF_END \ + HBREG = PROTECT_FROZEN_H(B); +#ifdef YAPOR + +#define OR_LAST_YAPOR \ + (*_PREG) = NEXTOP((*_PREG), Osblp); +#else + +#define OR_LAST_NOYAPOR \ + (*_PREG) = NEXTOP((*_PREG), p); +#endif + +#define OR_LAST_END \ + SET_BB(PROTECT_FROZEN_B(B)); \ + GONext(); + +#define LOCK_PRED_INSTINIT \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + PELOCK(10,ap); \ + PP = ap; + +#define LOCK_PRED_FIRSTIFOK \ + UNLOCKPE(11,ap); \ + FAIL(); + +#define LOCK_PRED_SECONDTIFOK \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(ap, 0, CP); \ + setregs(); \ + CACHE_A1(); \ + save_pc(); + +#define LOCK_PRED_END \ + (*_PREG) = ap->cs.p_code.TrueCodeOfPred; \ + JMPNext(); + +#if defined(YAPOR) || defined(THREADS) +#define INDEX_PRED_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + if (!PP) { \ + PELOCK(11,ap); \ + } \ + if (ap->OpcodeOfPred != INDEX_OPCODE) { \ + if (!PP) { \ + UNLOCKPE(11,ap); \ + } \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + JMPNext(); \ + } \ + else \ + { \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(ap, 0, CP); \ + setregs(); \ + CACHE_A1(); \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + if (!PP) \ + { \ + UNLOCKPE(14,ap); \ + } \ + JMPNext(); \ + } +#else /* defined(YAPOR) || defined(THREADS) */ +#define INDEX_PRED_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + { \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(ap, 0, CP); \ + setregs(); \ + CACHE_A1(); \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + { \ + UNLOCKPE(14,ap); \ + } \ + JMPNext(); \ + } +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define INDEX_PRED_END \ + BLOCK = (CELL)INDEX_PRED_END; + +#if THREADS +#define THREAD_LOCAL_INSTINIT \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + ap = Yap_GetThreadPred(ap PASS_REGS); \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + JMPNext(); +#endif + +#define EXPAND_INDEX_INSTINIT \ + PredEntry *pe = PredFromExpandCode((*_PREG)); \ + yamop *pt0; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_INDEX_YAPOR_THREADS_NOPP \ + PELOCK(12,pe); + +#define EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT \ + (*_PREG) = *PREG_ADDR; + +#define EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK \ + UNLOCKPE(15,pe); + +#define EXPAND_INDEX_YAPOR_THREADS_IFOK_END \ + JMPNext(); +#endif + +#ifdef SHADOW_S +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS \ + S = (*_SREG); +#endif + +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS \ + saveregs(); \ + pt0 = Yap_ExpandIndex(pe, 0); \ + setregs(); + +#ifdef SHADOW_S +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG \ + (*_SREG) = S; +#endif + +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG \ + (*_PREG) = pt0; + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_INDEX_UNLOCK \ + UNLOCKPE(12,pe); +#endif + +#define EXPAND_INDEX_END \ + JMPNext(); + +#define EXPAND_CLAUSES_INSTINIT \ + PredEntry *pe = (*_PREG)->u.sssllp.p; \ + yamop *pt0; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_CLAUSES_YAPOR_THREADS_NOPP \ + PELOCK(13,pe); + +#define EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT \ + (*_PREG) = *PREG_ADDR; + +#define EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK \ + UNLOCKPE(16,pe); + +#define EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END \ + JMPNext(); +#endif + +#define EXPAND_CLAUSES_NOYAPOR_NOTHREADS \ + saveregs(); \ + pt0 = Yap_ExpandIndex(pe, 0); \ + setregs(); \ + UNLOCKPE(17,pe); \ + (*_PREG) = pt0; + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_CLAUSES_UNLOCK \ + UNLOCKPE(18,pe); +#endif + +#define EXPAND_CLAUSES_END \ + JMPNext(); + +#if defined(YAPOR) || defined(THREADS) +#ifdef LOW_LEVEL_TRACER +#define UNDEF_P_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + PP = NULL; \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,UndefCode,XREGS+1); \ + } \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#else /* LOW_LEVEL_TRACER */ +#define UNDEF_P_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + PP = NULL; \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#endif /* LOW_LEVEL_TRACER */ +#else /* defined(YAPOR) || defined(THREADS) */ +#ifdef LOW_LEVEL_TRACER +#define UNDEF_P_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,UndefCode,XREGS+1); \ + } \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#else /* LOW_LEVEL_TRACER */ +#define UNDEF_P_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#endif /* LOW_LEVEL_TRACER */ +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define UNDEF_P_END \ + BLOCK = (CELL)UNDEF_P_END; + +#define SPY_PRED_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + PELOCK(14,pe); + +#define SPY_PRED_FIRSTIFOK \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(pe, 0, CP); \ + setregs(); + +#define SPY_PRED_SECONDIFOK_INIT \ + LOCK(pe->StatisticsForPred.lock); \ + pe->StatisticsForPred.NOfEntries++; \ + UNLOCK(pe->StatisticsForPred.lock); \ + LOCAL_ReductionsCounter--; + +#define SPY_PRED_SECONDIFOK_FIRSTIFOK \ + UNLOCKPE(20,pe); \ + saveregs(); \ + Yap_NilError(CALL_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); + +#define SPY_PRED_SECONDIFOK_POST_FIRSTIF \ + LOCAL_PredEntriesCounter--; + +#define SPY_PRED_SECONDIFOK_SECONDIFOK \ + UNLOCKPE(21,pe); \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); + +#define SPY_PRED_SECONDIFOK_THIRDIFOK \ + (*_PREG) = pe->cs.p_code.TrueCodeOfPred; \ + UNLOCKPE(22,pe); \ + JMPNext(); + +#define SPY_PRED_THIRDIFOK_INIT \ + LOCK(pe->StatisticsForPred.lock); \ + pe->StatisticsForPred.NOfEntries++; \ + UNLOCK(pe->StatisticsForPred.lock); + +#define SPY_PRED_THIRDIFOK_FIRSTIFOK \ + (*_PREG) = pe->cs.p_code.TrueCodeOfPred; \ + UNLOCKPE(23,pe); \ + JMPNext(); + +#define SPY_PRED_FOURTHIFOK \ + (*_PREG) = pe->cs.p_code.TrueCodeOfPred; \ + UNLOCKPE(24,pe); \ + JMPNext(); + +#define SPY_PRED_POST_FOURTHIF \ + UNLOCKPE(25,pe); \ + d0 = pe->ArityOfPE; + +#define SPY_PRED_D0ISZERO \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); + +#define SPY_PRED_D0ISNOZERO_INIT \ + *H = (CELL) pe->FunctorOfPred; \ + HR[d0 + 2] = AbsAppl(HR); \ + HR++; \ + pt1 = XREGS + 1; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT \ + pt0 = pt1++; \ + d1 = *pt0; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR \ + *H++ = d1; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR \ + *H++ = (CELL)pt0; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); + +#define SPY_PRED_POST_IFS \ + H[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + PredEntry *pt0; + +#ifdef THREADS +#define SPY_PRED_THREADS_LOCK \ + LOCK(GLOBAL_ThreadHandlesLock); +#endif + +#define SPY_PRED_POST_LOCK \ + pt0 = SpyCode; \ + P_before_spy = (*_PREG); \ + (*_PREG) = pt0->CodeOfPred; + +#ifdef THREADS +#define SPY_PRED_THREADS_UNLOCK \ + UNLOCK(GLOBAL_ThreadHandlesLock); +#endif + +#define SPY_PRED_POST_UNLOCK \ + save_pc(); \ + CACHE_A1(); + +#ifdef LOW_LEVEL_TRACER +#define SPY_PRED_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,pt0,XREGS+1); +#endif + +#define SPY_PRED_END \ + JMPNext(); + diff --git a/JIT/HPP/singlecode_pop.h b/JIT/HPP/singlecode_pop.h new file mode 100644 index 000000000..349a8eb89 --- /dev/null +++ b/JIT/HPP/singlecode_pop.h @@ -0,0 +1,36 @@ +#define POP_N_INIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + d0 = (*_PREG)->u.os.s; \ + SP = (CELL *) (((char *) SP) + d0); \ + d0 = SP[0]; \ + if (d0) { \ + (*_SREG) = (CELL *) (SP[1]); \ + SP += 2; \ + (*_PREG) = NEXTOP((*_PREG), s); \ + GONext(); \ + } \ + else { \ + (*_SREG) = (CELL *) (SP[1]); \ + SP += 2; \ + (*_PREG) = NEXTOP((*_PREG), s); \ + GONextW(); \ + } + +#define POP_N_END \ + BLOCK = (CELL)POP_N_END; + +#define _pop_instinit \ + BEGD(d0); \ + d0 = SP[0]; \ + (*_SREG) = (CELL *) (SP[1]); \ + SP += 2; \ + if (d0) { \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONEXT(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONEXTW(); \ + } \ + ENDD(d0); diff --git a/JIT/HPP/singlecode_primitive_predicates.h b/JIT/HPP/singlecode_primitive_predicates.h new file mode 100644 index 000000000..76e92e25b --- /dev/null +++ b/JIT/HPP/singlecode_primitive_predicates.h @@ -0,0 +1,3869 @@ +#define _p_integer_x_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xl.x); \ + deref_head(d0, integer_x_unk); \ + integer_x_nvar: \ + if (IsIntTerm(d0)) { \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONEXT(); \ + } \ + if (IsApplTerm(d0)) { \ + Functor f0 = FunctorOfTerm(d0); \ + if (IsExtensionFunctor(f0)) { \ + switch ((CELL)f0) { \ + case (CELL)FunctorLongInt: \ + case (CELL)FunctorBigInt: \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONEXT(); \ + default: \ + (*_PREG) = (*_PREG)->u.xl.F; \ + BACK(); \ + } \ + } \ + } \ + (*_PREG) = (*_PREG)->u.xl.F; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, integer_x_unk, integer_x_nvar); \ + (*_PREG) = (*_PREG)->u.xl.F; \ + BACK(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _p_plus_vv_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = XREG((*_PREG)->u.xxx.x1); \ + deref_head(d0, plus_vv_unk); \ + plus_vv_nvar: \ + d1 = XREG((*_PREG)->u.xxx.x2); \ + deref_head(d1, plus_vv_nvar_unk); \ + plus_vv_nvar_nvar: \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1)); \ + } \ + else { \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, plus_vv_unk, plus_vv_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is _+B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, plus_vv_nvar_unk, plus_vv_nvar_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _p_plus_vc_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + deref_head(d0, plus_vc_unk); \ + plus_vc_nvar: \ + { \ + Int d1 = (*_PREG)->u.xxn.c; \ + if (IsIntTerm(d0)) { \ + d0 = MkIntegerTerm(IntOfTerm(d0) + d1); \ + } \ + else { \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + } \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, plus_vc_unk, plus_vc_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _p_plus_y_vv_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = XREG((*_PREG)->u.yxx.x1); \ + deref_head(d0, plus_y_vv_unk); \ + plus_y_vv_nvar: \ + d1 = XREG((*_PREG)->u.xxx.x2); \ + deref_head(d1, plus_y_vv_nvar_unk); \ + plus_y_vv_nvar_nvar: \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1)); \ + } \ + else { \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + BEGP(pt0); \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + ENDP(pt0); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, plus_y_vv_unk, plus_y_vv_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, plus_y_vv_nvar_unk, plus_y_vv_nvar_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _p_plus_y_vc_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.yxn.xi); \ + deref_head(d0, plus_y_vc_unk); \ + plus_y_vc_nvar: \ + { \ + Int d1 = (*_PREG)->u.yxn.c; \ + if (IsIntTerm(d0)) { \ + d0 = MkIntegerTerm(IntOfTerm(d0) + d1); \ + } \ + else { \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + } \ + BEGP(pt0); \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + ENDP(pt0); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, plus_y_vc_unk, plus_y_vc_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _p_minus_vv_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = XREG((*_PREG)->u.xxx.x1); \ + deref_head(d0, minus_vv_unk); \ + minus_vv_nvar: \ + d1 = XREG((*_PREG)->u.xxx.x2); \ + deref_head(d1, minus_vv_nvar_unk); \ + minus_vv_nvar_nvar: \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1)); \ + } \ + else { \ + saveregs(); \ + d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, minus_vv_unk, minus_vv_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, minus_vv_nvar_unk, minus_vv_nvar_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _p_times_vv_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = XREG((*_PREG)->u.xxx.x1); \ + deref_head(d0, times_vv_unk); \ + times_vv_nvar: \ + d1 = XREG((*_PREG)->u.xxx.x2); \ + deref_head(d1, times_vv_nvar_unk); \ + times_vv_nvar_nvar: \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + d0 = times_int(IntOfTerm(d0), IntOfTerm(d1)); \ + } \ + else { \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, times_vv_unk, times_vv_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, times_vv_nvar_unk, times_vv_nvar_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _p_times_vc_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + deref_head(d0, times_vc_unk); \ + times_vc_nvar: \ + { \ + Int d1 = (*_PREG)->u.xxn.c; \ + if (IsIntTerm(d0)) { \ + d0 = times_int(IntOfTerm(d0), d1); \ + } \ + else { \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + } \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, times_vc_unk, times_vc_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A* " Int_FORMAT, (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _p_div_vv_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = XREG((*_PREG)->u.xxx.x1); \ + deref_head(d0, div_vv_unk); \ + div_vv_nvar: \ + d1 = XREG((*_PREG)->u.xxx.x2); \ + deref_head(d1, div_vv_nvar_unk); \ + div_vv_nvar_nvar: \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + Int div = IntOfTerm(d1); \ + if (div == 0) { \ + saveregs(); \ + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); \ + setregs(); \ + FAIL(); \ + } \ + d0 = MkIntTerm(IntOfTerm(d0) / div); \ + } \ + else { \ + saveregs(); \ + d0 = p_div(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, div_vv_unk, div_vv_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, div_vv_nvar_unk, div_vv_nvar_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _p_and_vv_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = XREG((*_PREG)->u.xxx.x1); \ + deref_head(d0, and_vv_unk); \ + and_vv_nvar: \ + d1 = XREG((*_PREG)->u.xxx.x2); \ + deref_head(d1, and_vv_nvar_unk); \ + and_vv_nvar_nvar: \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1)); \ + } \ + else { \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, and_vv_unk, and_vv_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, and_vv_nvar_unk, and_vv_nvar_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _p_and_vc_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + deref_head(d0, and_vc_unk); \ + and_vc_nvar: \ + { \ + Int d1 = (*_PREG)->u.xxn.c; \ + if (IsIntTerm(d0)) { \ + d0 = MkIntegerTerm(IntOfTerm(d0) & d1); \ + } \ + else { \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + } \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, and_vc_unk, and_vc_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A /\\ " Int_FORMAT , (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _p_sll_cv_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + deref_head(d0, sll_cv_unk); \ + sll_cv_nvar: \ + { \ + Int d1 = (*_PREG)->u.xxn.c; \ + if (IsIntTerm(d0)) { \ + Int i2 = IntOfTerm(d0); \ + if (i2 < 0) { \ + d0 = MkIntegerTerm(SLR(d1, -i2)); \ + } else { \ + d0 = do_sll(d1,i2); \ + } \ + } else { \ + saveregs(); \ + d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); \ + } \ + } \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, sll_cv_unk, sll_cv_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxn.xi); \ + deref_head(d0, slr_vc_unk); \ + slr_vc_nvar: \ + { \ + Int d1 = (*_PREG)->u.xxn.c; \ + if (IsIntTerm(d0)) { \ + d0 = MkIntTerm(SLR(IntOfTerm(d0), d1)); \ + } \ + else { \ + saveregs(); \ + d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + if (d0 == 0L) { \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); \ + } \ + } \ + } \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, slr_vc_unk, slr_vc_nvar); \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _call_bfunc_xx_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = XREG((*_PREG)->u.plxxs.x1); \ + call_bfunc_xx_nvar: \ + d1 = XREG((*_PREG)->u.plxxs.x2); \ + call_bfunc_xx2_nvar: \ + deref_head(d0, call_bfunc_xx_unk); \ + deref_head(d1, call_bfunc_xx2_unk); \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + COUNT flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plxxs.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + yamop *nextp = NEXTOP((*_PREG), plxxs); \ + (*_PREG) = nextp; \ + GONEXT(); \ + } \ + else { \ + yamop *nextp = (*_PREG)->u.plxxs.f; \ + (*_PREG) = nextp; \ + BACK(); \ + } \ + } \ + else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + yamop *nextp = NEXTOP((*_PREG), plxxs); \ + (*_PREG) = nextp; \ + GONEXT(); \ + } \ + else { \ + yamop *nextp = (*_PREG)->u.plxxs.f; \ + (*_PREG) = nextp; \ + BACK(); \ + } \ + } \ + else { \ + if (flags & EQ_OK_IN_CMP) { \ + yamop *nextp = NEXTOP((*_PREG), plxxs); \ + (*_PREG) = nextp; \ + GONEXT(); \ + } \ + else { \ + yamop *nextp = (*_PREG)->u.plxxs.f; \ + (*_PREG) = nextp; \ + BACK(); \ + } \ + } \ + } \ + exec_bin_cmp_xx: \ + { \ + CmpPredicate f = (*_PREG)->u.plxxs.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + } \ + if ((*_PREG) == FAILCODE) { \ + BACK(); \ + } \ + if (!d0) { \ + (*_PREG) = (*_PREG)->u.plxxs.f; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), plxxs); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, call_bfunc_xx_unk, call_bfunc_xx_nvar); \ + d1 = Deref(d1); \ + goto exec_bin_cmp_xx; \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, call_bfunc_xx2_unk, call_bfunc_xx2_nvar); \ + goto exec_bin_cmp_xx; \ + ENDP(pt0); \ + \ + ENDD(d1); \ + ENDD(d0); + +#define _call_bfunc_yx_instinit \ + BEGD(d0); \ + BEGD(d1); \ + BEGP(pt0); \ + pt0 = YREG + (*_PREG)->u.plxys.y; \ + d1 = XREG((*_PREG)->u.plxys.x); \ + d0 = *pt0; \ + ENDP(pt0); \ + deref_head(d0, call_bfunc_yx_unk); \ + call_bfunc_yx_nvar: \ + deref_head(d1, call_bfunc_yx2_unk); \ + call_bfunc_yx2_nvar: \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + int flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plxys.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + GONEXT(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + BACK(); \ + } \ + } else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + GONEXT(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + BACK(); \ + } \ + } else { \ + if (flags & EQ_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + GONEXT(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + BACK(); \ + } \ + } \ + } \ + exec_bin_cmp_yx: \ + { \ + CmpPredicate f = (*_PREG)->u.plxys.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + } \ + if (!d0 || (*_PREG) == FAILCODE) { \ + if ((*_PREG) != FAILCODE) { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + } \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, call_bfunc_yx_unk, call_bfunc_yx_nvar); \ + d1 = Deref(d1); \ + goto exec_bin_cmp_yx; \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, call_bfunc_yx2_unk, call_bfunc_yx2_nvar); \ + goto exec_bin_cmp_yx; \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _call_bfunc_xy_instinit \ + BEGD(d0); \ + BEGD(d1); \ + BEGP(pt0); \ + pt0 = YREG + (*_PREG)->u.plxys.y; \ + d0 = XREG((*_PREG)->u.plxys.x); \ + d1 = *pt0; \ + ENDP(pt0); \ + deref_head(d0, call_bfunc_xy_unk); \ + call_bfunc_xy_nvar: \ + deref_head(d1, call_bfunc_xy2_unk); \ + call_bfunc_xy2_nvar: \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + int flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plxys.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + GONEXT(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + BACK(); \ + } \ + } else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + GONEXT(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + BACK(); \ + } \ + } else { \ + if (flags & EQ_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + GONEXT(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + BACK(); \ + } \ + } \ + } \ + exec_bin_cmp_xy: \ + { \ + CmpPredicate f = (*_PREG)->u.plxys.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + } \ + if (!d0 || (*_PREG) == FAILCODE) { \ + if ((*_PREG) != FAILCODE) { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + } \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, call_bfunc_xy_unk, call_bfunc_xy_nvar); \ + d1 = Deref(d1); \ + goto exec_bin_cmp_xy; \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, call_bfunc_xy2_unk, call_bfunc_xy2_nvar); \ + goto exec_bin_cmp_xy; \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _call_bfunc_yy_instinit \ + BEGD(d0); \ + BEGD(d1); \ + BEGP(pt0); \ + pt0 = YREG + (*_PREG)->u.plyys.y1; \ + BEGP(pt1); \ + pt1 = YREG + (*_PREG)->u.plyys.y2; \ + d0 = *pt0; \ + d1 = *pt1; \ + ENDP(pt1); \ + ENDP(pt0); \ + deref_head(d0, call_bfunc_yy_unk); \ + call_bfunc_yy_nvar: \ + deref_head(d1, call_bfunc_yy2_unk); \ + call_bfunc_yy2_nvar: \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + int flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plyys.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + GONEXT(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + BACK(); \ + } \ + } else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + GONEXT(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + BACK(); \ + } \ + } else { \ + if (flags & EQ_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + GONEXT(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + BACK(); \ + } \ + } \ + } \ + exec_bin_cmp_yy: \ + { \ + CmpPredicate f = (*_PREG)->u.plyys.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + } \ + if (!d0 || (*_PREG) == FAILCODE) { \ + if ((*_PREG) != FAILCODE) { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + } \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, call_bfunc_yy_unk, call_bfunc_yy_nvar); \ + d1 = Deref(d1); \ + goto exec_bin_cmp_yy; \ + ENDP(pt0); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, call_bfunc_yy2_unk, call_bfunc_yy2_nvar); \ + goto exec_bin_cmp_yy; \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#ifdef LOW_LEVEL_TRACER +#if defined(YAPOR_SBA) && defined(YAPOR) +#ifdef COROUTINING +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#else /* COROUTINING */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#endif /* COROUTINING */ +#else /* defined(YAPOR_SBA) && defined(YAPOR) */ +#ifdef COROUTINING +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#else /* COROUTINING */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define _p_dif_instinit \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); \ + } \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#endif /* COROUTINING */ +#endif /* defined(YAPOR_SBA) && defined(YAPOR) */ +#else /* LOW_LEVEL_TRACER */ +#if defined(YAPOR_SBA) && defined(YAPOR) +#ifdef COROUTINING +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#else /* COROUTINING */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#endif /* COROUTINING */ +#else /* defined(YAPOR_SBA) && defined(YAPOR) */ +#ifdef COROUTINING +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); \ + if (OldWokenGoals == TermNil) { \ + Yap_undo_signal(YAP_WAKEUP_SIGNAL); \ + } \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + H = HRBREG; \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#else /* COROUTINING */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailVal(--TR); \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(--TR); \ + TR--; \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define _p_dif_instinit \ + BEGD(d0); \ + BEGD(d1); \ + d0 = ARG1; \ + deref_head(d0, dif_unk1); \ + dif_nvar1: \ + d1 = ARG2; \ + deref_head(d1, dif_nvar1_unk2); \ + dif_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + { \ + Int opresult; \ + register tr_fr_ptr pt0; \ + pt0 = TR; \ + BEGCHO(pt1); \ + pt1 = B; \ + HBREG = HR; \ + B = (choiceptr) HR; \ + B->cp_h = HR; \ + SET_BB(B); \ + save_hb(); \ + opresult = Yap_IUnify(d0, d1); \ + B = pt1; \ + SET_BB(PROTECT_FROZEN_B(pt1)); \ + HBREG = B->cp_h; \ + while (TR != pt0) { \ + BEGD(d1); \ + d1 = TrailTerm(--TR); \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + } \ + ENDD(d1); \ + } \ + if (opresult) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + ENDCHO(pt1); \ + } \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, dif_unk1, dif_nvar1); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2); \ + ENDP(pt0); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#endif /* COROUTINING */ +#endif /* defined(YAPOR_SBA) && defined(YAPOR) */ +#endif /* LOW_LEVEL_TRACER */ + +#ifdef LOW_LEVEL_TRACER +#ifdef USE_GMP +#define _p_eq_instinit \ + register CELL d0, d1, d2; \ + register CELL *pt0, *pt1; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorSame,0)),XREGS+1); \ + } \ + d0 = ARG1; \ + deref_head(d0, p_eq_unk1); \ + p_eq_nvar1: \ + d1 = ARG2; \ + deref_head(d1, p_eq_nvar1_unk2); \ + p_eq_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + if (IsPairTerm(d0)) { \ + if (!IsPairTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_save_pc(); \ + d2 = iequ_complex(RepPair(d0)-1, RepPair(d0)+1,RepPair(d1)-1); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + if (IsApplTerm(d0)) { \ + Functor f0 = FunctorOfTerm(d0); \ + Functor f1; \ + \ + if (!IsApplTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + f1 = FunctorOfTerm(d1); \ + \ + if (IsExtensionFunctor(f0)) { \ + switch ((CELL)f0) { \ + case (CELL)FunctorDBRef: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorLongInt: \ + if (f1 != FunctorLongInt) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (LongIntOfTerm(d0) == LongIntOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorBigInt: \ + if (f1 != FunctorBigInt) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (Yap_gmp_tcmp_big_big(d0,d1) == 0) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorDouble: \ + if (f1 != FunctorDouble) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (FloatOfTerm(d0) == FloatOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + default: \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + } \ + if (f0 != f1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_save_pc(); \ + d2 = iequ_complex(RepAppl(d0), RepAppl(d0)+ArityOfFunctor(f0), RepAppl(d1)); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d1, pt0, p_eq_nvar1_unk2, p_eq_nvar1_nvar2); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d0, pt0, p_eq_unk1, p_eq_nvar1); \ + d1 = ARG2; \ + deref_head(d1, p_eq_var1_unk2); \ + p_eq_var1_nvar2: \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d1, pt1, p_eq_var1_unk2, p_eq_var1_nvar2); \ + if (pt1 != pt0) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); +#else /* USE_GMP */ +#define _p_eq_instinit \ + register CELL d0, d1, d2; \ + register CELL *pt0, *pt1; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorSame,0)),XREGS+1); \ + } \ + d0 = ARG1; \ + deref_head(d0, p_eq_unk1); \ + p_eq_nvar1: \ + d1 = ARG2; \ + deref_head(d1, p_eq_nvar1_unk2); \ + p_eq_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + if (IsPairTerm(d0)) { \ + if (!IsPairTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_save_pc(); \ + d2 = iequ_complex(RepPair(d0)-1, RepPair(d0)+1,RepPair(d1)-1); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + if (IsApplTerm(d0)) { \ + Functor f0 = FunctorOfTerm(d0); \ + Functor f1; \ + \ + if (!IsApplTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + f1 = FunctorOfTerm(d1); \ + \ + if (IsExtensionFunctor(f0)) { \ + switch ((CELL)f0) { \ + case (CELL)FunctorDBRef: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorLongInt: \ + if (f1 != FunctorLongInt) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (LongIntOfTerm(d0) == LongIntOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorDouble: \ + if (f1 != FunctorDouble) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (FloatOfTerm(d0) == FloatOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + default: \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + } \ + if (f0 != f1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_save_pc(); \ + d2 = iequ_complex(RepAppl(d0), RepAppl(d0)+ArityOfFunctor(f0), RepAppl(d1)); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d1, pt0, p_eq_nvar1_unk2, p_eq_nvar1_nvar2); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d0, pt0, p_eq_unk1, p_eq_nvar1); \ + d1 = ARG2; \ + deref_head(d1, p_eq_var1_unk2); \ + p_eq_var1_nvar2: \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d1, pt1, p_eq_var1_unk2, p_eq_var1_nvar2); \ + if (pt1 != pt0) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); +#endif /* USE_GMP */ +#else /* LOW_LEVEL_TRACER */ +#ifdef USE_GMP +#define _p_eq_instinit \ + register CELL d0, d1, d2; \ + register CELL *pt0, *pt1; \ + d0 = ARG1; \ + deref_head(d0, p_eq_unk1); \ + p_eq_nvar1: \ + d1 = ARG2; \ + deref_head(d1, p_eq_nvar1_unk2); \ + p_eq_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + if (IsPairTerm(d0)) { \ + if (!IsPairTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_save_pc(); \ + d2 = iequ_complex(RepPair(d0)-1, RepPair(d0)+1,RepPair(d1)-1); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + if (IsApplTerm(d0)) { \ + Functor f0 = FunctorOfTerm(d0); \ + Functor f1; \ + \ + if (!IsApplTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + f1 = FunctorOfTerm(d1); \ + \ + if (IsExtensionFunctor(f0)) { \ + switch ((CELL)f0) { \ + case (CELL)FunctorDBRef: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorLongInt: \ + if (f1 != FunctorLongInt) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (LongIntOfTerm(d0) == LongIntOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorBigInt: \ + if (f1 != FunctorBigInt) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (Yap_gmp_tcmp_big_big(d0,d1) == 0) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorDouble: \ + if (f1 != FunctorDouble) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (FloatOfTerm(d0) == FloatOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + default: \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + } \ + if (f0 != f1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_save_pc(); \ + d2 = iequ_complex(RepAppl(d0), RepAppl(d0)+ArityOfFunctor(f0), RepAppl(d1)); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d1, pt0, p_eq_nvar1_unk2, p_eq_nvar1_nvar2); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d0, pt0, p_eq_unk1, p_eq_nvar1); \ + d1 = ARG2; \ + deref_head(d1, p_eq_var1_unk2); \ + p_eq_var1_nvar2: \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d1, pt1, p_eq_var1_unk2, p_eq_var1_nvar2); \ + if (pt1 != pt0) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); +#else /* USE_GMP */ +#define _p_eq_instinit \ + register CELL d0, d1, d2; \ + register CELL *pt0, *pt1; \ + d0 = ARG1; \ + deref_head(d0, p_eq_unk1); \ + p_eq_nvar1: \ + d1 = ARG2; \ + deref_head(d1, p_eq_nvar1_unk2); \ + p_eq_nvar1_nvar2: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + if (IsPairTerm(d0)) { \ + if (!IsPairTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_save_pc(); \ + d2 = iequ_complex(RepPair(d0)-1, RepPair(d0)+1,RepPair(d1)-1); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + if (IsApplTerm(d0)) { \ + Functor f0 = FunctorOfTerm(d0); \ + Functor f1; \ + \ + if (!IsApplTerm(d1)) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + f1 = FunctorOfTerm(d1); \ + \ + if (IsExtensionFunctor(f0)) { \ + switch ((CELL)f0) { \ + case (CELL)FunctorDBRef: \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorLongInt: \ + if (f1 != FunctorLongInt) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (LongIntOfTerm(d0) == LongIntOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + case (CELL)FunctorDouble: \ + if (f1 != FunctorDouble) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + if (FloatOfTerm(d0) == FloatOfTerm(d1)) { \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + default: \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + } \ + if (f0 != f1) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_save_pc(); \ + d2 = iequ_complex(RepAppl(d0), RepAppl(d0)+ArityOfFunctor(f0), RepAppl(d1)); \ + if (d2 == FALSE) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + always_set_pc(); \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); \ + } \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d1, pt0, p_eq_nvar1_unk2, p_eq_nvar1_nvar2); \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d0, pt0, p_eq_unk1, p_eq_nvar1); \ + d1 = ARG2; \ + deref_head(d1, p_eq_var1_unk2); \ + p_eq_var1_nvar2: \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + \ + deref_body(d1, pt1, p_eq_var1_unk2, p_eq_var1_nvar2); \ + if (pt1 != pt0) { \ + (*_PREG) = (*_PREG)->u.l.l; \ + BACK(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), l); \ + GONEXT(); +#endif /* USE_GMP */ +#endif /* LOW_LEVEL_TRACER */ + +#ifdef LOW_LEVEL_TRACER +#define _p_arg_vv_instinit \ + if (Yap_do_low_level_trace) { \ + H[0] = XREG((*_PREG)->u.xxx.x1); \ + H[1] = XREG((*_PREG)->u.xxx.x2); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); \ + } \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xxx.x1); \ + deref_head(d0, arg_arg1_unk); \ + arg_arg1_nvar: \ + if (IsIntTerm(d0)) { \ + d0 = IntOfTerm(d0); \ + } else if (IsLongIntTerm(d0)) { \ + d0 = LongIntOfTerm(d0); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); \ + setregs(); \ + FAIL(); \ + } \ + \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.xxx.x2); \ + deref_head(d1, arg_arg2_unk); \ + arg_arg2_nvar: \ + if (IsApplTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + XREG((*_PREG)->u.xxx.x) = pt0[d0]; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else if (IsPairTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + FAIL(); \ + } \ + XREG((*_PREG)->u.xxx.x) = pt0[d0-1]; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else { \ + FAIL(); \ + } \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, arg_arg2_unk, arg_arg2_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d1); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, arg_arg1_unk, arg_arg1_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d0); +#else /* LOW_LEVEL_TRACER */ +#define _p_arg_vv_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.xxx.x1); \ + deref_head(d0, arg_arg1_unk); \ + arg_arg1_nvar: \ + if (IsIntTerm(d0)) { \ + d0 = IntOfTerm(d0); \ + } else if (IsLongIntTerm(d0)) { \ + d0 = LongIntOfTerm(d0); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); \ + setregs(); \ + FAIL(); \ + } \ + \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.xxx.x2); \ + deref_head(d1, arg_arg2_unk); \ + arg_arg2_nvar: \ + if (IsApplTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + XREG((*_PREG)->u.xxx.x) = pt0[d0]; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else if (IsPairTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + FAIL(); \ + } \ + XREG((*_PREG)->u.xxx.x) = pt0[d0-1]; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else { \ + FAIL(); \ + } \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, arg_arg2_unk, arg_arg2_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d1); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, arg_arg1_unk, arg_arg1_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d0); +#endif /* LOW_LEVEL_TRACER */ + +#ifdef LOW_LEVEL_TRACER +#define _p_arg_cv_instinit \ + if (Yap_do_low_level_trace) { \ + CELL *Ho = HR; \ + Term t = MkIntegerTerm((*_PREG)->u.xxn.c); \ + H[0] = t; \ + H[1] = XREG((*_PREG)->u.xxn.xi); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); \ + H = HRo; \ + } \ + BEGD(d0); \ + d0 = (*_PREG)->u.xxn.c; \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.xxn.xi); \ + deref_head(d1, arg_arg2_vc_unk); \ + arg_arg2_vc_nvar: \ + if (IsApplTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + XREG((*_PREG)->u.xxn.x) = pt0[d0]; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else if (IsPairTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + FAIL(); \ + } \ + XREG((*_PREG)->u.xxn.x) = pt0[d0-1]; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else { \ + FAIL(); \ + } \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, arg_arg2_vc_unk, arg_arg2_vc_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d1); \ + ENDD(d0); +#else /* LOW_LEVEL_TRACER */ +#define _p_arg_cv_instinit \ + BEGD(d0); \ + d0 = (*_PREG)->u.xxn.c; \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.xxn.xi); \ + deref_head(d1, arg_arg2_vc_unk); \ + arg_arg2_vc_nvar: \ + if (IsApplTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + XREG((*_PREG)->u.xxn.x) = pt0[d0]; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else if (IsPairTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + FAIL(); \ + } \ + XREG((*_PREG)->u.xxn.x) = pt0[d0-1]; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else { \ + FAIL(); \ + } \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, arg_arg2_vc_unk, arg_arg2_vc_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d1); \ + ENDD(d0); +#endif /* LOW_LEVEL_TRACER */ + +#ifdef LOW_LEVEL_TRACER +#define _p_arg_y_vv_instinit \ + if (Yap_do_low_level_trace) { \ + H[0] = XREG((*_PREG)->u.yxx.x1); \ + H[1] = XREG((*_PREG)->u.yxx.x2); \ + H[2] = YREG[(*_PREG)->u.yxx.y]; \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); \ + } \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.yxx.x1); \ + deref_head(d0, arg_y_arg1_unk); \ + arg_y_arg1_nvar: \ + if (IsIntTerm(d0)) { \ + d0 = IntOfTerm(d0); \ + } else if (IsLongIntTerm(d0)) { \ + d0 = LongIntOfTerm(d0); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); \ + setregs(); \ + FAIL(); \ + } \ + \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.yxx.x2); \ + deref_head(d1, arg_y_arg2_unk); \ + arg_y_arg2_nvar: \ + if (IsApplTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + BEGP(pt1); \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt1,pt0[d0]); \ + ENDP(pt1); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else if (IsPairTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + FAIL(); \ + } \ + BEGP(pt1); \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt1,pt0[d0-1]); \ + GONEXT(); \ + ENDP(pt1); \ + ENDP(pt0); \ + } \ + else { \ + FAIL(); \ + } \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, arg_y_arg2_unk, arg_y_arg2_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d1); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, arg_y_arg1_unk, arg_y_arg1_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d0); +#else /* LOW_LEVEL_TRACER */ +#define _p_arg_y_vv_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.yxx.x1); \ + deref_head(d0, arg_y_arg1_unk); \ + arg_y_arg1_nvar: \ + if (IsIntTerm(d0)) { \ + d0 = IntOfTerm(d0); \ + } else if (IsLongIntTerm(d0)) { \ + d0 = LongIntOfTerm(d0); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); \ + setregs(); \ + FAIL(); \ + } \ + \ + BEGD(d1); \ + d1 = XREG((*_PREG)->u.yxx.x2); \ + deref_head(d1, arg_y_arg2_unk); \ + arg_y_arg2_nvar: \ + if (IsApplTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + FAIL(); \ + } \ + BEGP(pt1); \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt1,pt0[d0]); \ + ENDP(pt1); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + else if (IsPairTerm(d1)) { \ + BEGP(pt0); \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + FAIL(); \ + } \ + BEGP(pt1); \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt1,pt0[d0-1]); \ + GONEXT(); \ + ENDP(pt1); \ + ENDP(pt0); \ + } \ + else { \ + FAIL(); \ + } \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, arg_y_arg2_unk, arg_y_arg2_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d1); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, arg_y_arg1_unk, arg_y_arg1_nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); \ + setregs(); \ + ENDP(pt0); \ + FAIL(); \ + ENDD(d0); +#endif /* LOW_LEVEL_TRACER */ + + +#ifdef LOW_LEVEL_TRACER +#define _p_functor_instinit \ + if (Yap_do_low_level_trace) \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),XREGS+1); \ + restart_functor: \ + BEGD(d0); \ + d0 = ARG1; \ + deref_head(d0, func_unk); \ + func_nvar: \ + BEGD(d1); \ + if (IsApplTerm(d0)) { \ + d1 = *RepAppl(d0); \ + if (IsExtensionFunctor((Functor) d1)) { \ + if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt ) { \ + d1 = MkIntTerm(0); \ + } else \ + FAIL(); \ + } else { \ + d0 = MkAtomTerm(NameOfFunctor((Functor) d1)); \ + d1 = MkIntTerm(ArityOfFunctor((Functor) d1)); \ + } \ + } \ + else if (IsPairTerm(d0)) { \ + d0 = TermDot; \ + d1 = MkIntTerm(2); \ + } \ + else { \ + d1 = MkIntTerm(0); \ + } \ + { \ + register CELL arity = d1; \ + \ + d1 = ARG2; \ + deref_head(d1, func_nvar_unk); \ + func_nvar_nvar: \ + if (d0 != d1) { \ + FAIL(); \ + } \ + d0 = arity; \ + goto func_bind_x3; \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, func_nvar_unk, func_nvar_nvar); \ + Bind(pt0, d0); \ + d0 = arity; \ + ENDP(pt0); \ + func_bind_x3: \ + d1 = ARG3; \ + deref_head(d1, func_nvar3_unk); \ + func_nvar3_nvar: \ + if (d0 != d1) { \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, func_nvar3_unk, func_nvar3_nvar); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + ENDD(d1); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, func_unk, func_nvar); \ + d0 = ARG2; \ + deref_head(d0, func_var_2unk); \ + func_var_2nvar: \ + BEGD(d1); \ + d1 = ARG3; \ + deref_head(d1, func_var_3unk); \ + func_var_3nvar: \ + if (IsIntTerm(d1)) \ + d1 = IntOfTerm(d1); \ + else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + FAIL(); \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); \ + } \ + BEGP(pt1); \ + if (!IsAtomTerm(d0)) { \ + FAIL(); \ + } \ + else \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + BACK(); \ + } else { \ + setregs(); \ + } \ + goto restart_functor; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + H = pt1; \ + ENDP(pt1); \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, func_var_3unk, func_var_3nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + ENDP(pt1); \ + FAIL(); \ + ENDD(d1); \ + \ + BEGP(pt1); \ + deref_body(d0, pt1, func_var_2unk, func_var_2nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + ENDP(pt1); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d0); +#else /* LOW_LEVEL_TRACER */ +#define _p_functor_instinit \ + restart_functor: \ + BEGD(d0); \ + d0 = ARG1; \ + deref_head(d0, func_unk); \ + func_nvar: \ + BEGD(d1); \ + if (IsApplTerm(d0)) { \ + d1 = *RepAppl(d0); \ + if (IsExtensionFunctor((Functor) d1)) { \ + if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt ) { \ + d1 = MkIntTerm(0); \ + } else \ + FAIL(); \ + } else { \ + d0 = MkAtomTerm(NameOfFunctor((Functor) d1)); \ + d1 = MkIntTerm(ArityOfFunctor((Functor) d1)); \ + } \ + } \ + else if (IsPairTerm(d0)) { \ + d0 = TermDot; \ + d1 = MkIntTerm(2); \ + } \ + else { \ + d1 = MkIntTerm(0); \ + } \ + { \ + register CELL arity = d1; \ + \ + d1 = ARG2; \ + deref_head(d1, func_nvar_unk); \ + func_nvar_nvar: \ + if (d0 != d1) { \ + FAIL(); \ + } \ + d0 = arity; \ + goto func_bind_x3; \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, func_nvar_unk, func_nvar_nvar); \ + Bind(pt0, d0); \ + d0 = arity; \ + ENDP(pt0); \ + func_bind_x3: \ + d1 = ARG3; \ + deref_head(d1, func_nvar3_unk); \ + func_nvar3_nvar: \ + if (d0 != d1) { \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d1, pt0, func_nvar3_unk, func_nvar3_nvar); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbmp),l); \ + Bind(pt0, d0); \ + GONEXT(); \ + ENDP(pt0); \ + } \ + ENDD(d1); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, func_unk, func_nvar); \ + d0 = ARG2; \ + deref_head(d0, func_var_2unk); \ + func_var_2nvar: \ + BEGD(d1); \ + d1 = ARG3; \ + deref_head(d1, func_var_3unk); \ + func_var_3nvar: \ + if (IsIntTerm(d1)) \ + d1 = IntOfTerm(d1); \ + else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); \ + setregs(); \ + FAIL(); \ + } \ + if (!IsAtomicTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); \ + } \ + if (d0 == TermDot && d1 == 2) { \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + } \ + else if ((Int)d1 > 0) { \ + if (!IsAtomTerm(d0)) { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); \ + } \ + BEGP(pt1); \ + if (!IsAtomTerm(d0)) { \ + FAIL(); \ + } \ + else \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); \ + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { \ + saveregs(); \ + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP((*_PREG),e),Osbmp))) { \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + BACK(); \ + } else { \ + setregs(); \ + } \ + goto restart_functor; \ + } \ + while ((Int)d1--) { \ + RESET_VARIABLE(pt1); \ + pt1++; \ + } \ + H = pt1; \ + ENDP(pt1); \ + } else if ((Int)d1 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), e),Osbpp),l); \ + Bind(pt0, d0); \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, func_var_3unk, func_var_3nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + ENDP(pt1); \ + FAIL(); \ + ENDD(d1); \ + \ + BEGP(pt1); \ + deref_body(d0, pt1, func_var_2unk, func_var_2nvar); \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + ENDP(pt1); \ + FAIL(); \ + ENDP(pt0); \ + ENDD(d0); +#endif /* LOW_LEVEL_TRACER */ diff --git a/JIT/HPP/singlecode_put.h b/JIT/HPP/singlecode_put.h new file mode 100644 index 000000000..7f5962ccb --- /dev/null +++ b/JIT/HPP/singlecode_put.h @@ -0,0 +1,180 @@ +#define _put_x_var_instinit \ + register CELL *pt0; \ + pt0 = HR; \ + XREG((*_PREG)->u.xx.xl) = Unsigned(pt0); \ + HR = pt0 + 1; \ + XREG((*_PREG)->u.xx.xr) = Unsigned(pt0); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + RESET_VARIABLE(pt0); \ + GONEXT(); + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define _put_y_var_instinit \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + XREG((*_PREG)->u.yx.x) = (CELL) pt0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + if (Unsigned((Int)(pt0)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + *pt0 = (CELL)STACK_TO_SBA(pt0); \ + } else \ + INITIALIZE_PERMVAR(pt0, (CELL)pt0); \ + GONEXT(); +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#define _put_y_var_instinit \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + XREG((*_PREG)->u.yx.x) = (CELL) pt0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + INITIALIZE_PERMVAR(pt0, (CELL)pt0); \ + GONEXT(); +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#define _put_x_val_instinit \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.xx.xl); \ + XREG((*_PREG)->u.xx.xr) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONEXT(); + +#define _put_xx_val_instinit \ + register CELL d0, d1; \ + d0 = XREG((*_PREG)->u.xxxx.xl1); \ + d1 = XREG((*_PREG)->u.xxxx.xl2); \ + XREG((*_PREG)->u.xxxx.xr1) = d0; \ + XREG((*_PREG)->u.xxxx.xr2) = d1; \ + (*_PREG) = NEXTOP((*_PREG), xxxx); \ + GONEXT(); + +#ifdef YAPOR_SBA +#define _put_y_val_instinit \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.yx.y]; \ + if (d0 == 0) { \ + XREG((*_PREG)->u.yx.x) = (CELL)(YREG+(*_PREG)->u.yx.y); \ + } else \ + XREG((*_PREG)->u.yx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _put_y_val_instinit \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.yx.y]; \ + XREG((*_PREG)->u.yx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONEXT(); +#endif /* YAPOR_SBA */ + +#ifdef YAPOR_SBA +#define _put_y_vals_instinit \ + register CELL d0, d1; \ + d0 = YREG[(*_PREG)->u.yyxx.y1]; \ + if (d0 == 0) \ + XREG((*_PREG)->u.yyxx.x1) = (CELL)(YREG+(*_PREG)->u.yyxx.y1); \ + else \ + XREG((*_PREG)->u.yyxx.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yyxx); \ + d1 = YREG[PREVOP((*_PREG),yyxx)->u.yyxx.y2]; \ + if (d1 == 0) \ + XREG(PREVOP((*_PREG)->u.yyxx,yyxx).x2) = (CELL)(YREG+(*_PREG)->u.yyxx.y2); \ + else \ + XREG(PREVOP((*_PREG),yyxx)->u.yyxx.x2) = d1; \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _put_y_vals_instinit \ + register CELL d0, d1; \ + d0 = YREG[(*_PREG)->u.yyxx.y1]; \ + XREG((*_PREG)->u.yyxx.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yyxx); \ + d1 = YREG[PREVOP((*_PREG),yyxx)->u.yyxx.y2]; \ + XREG(PREVOP((*_PREG),yyxx)->u.yyxx.x2) = d1; \ + GONEXT(); +#endif /* YAPOR_SBA */ + +#define _put_unsafe_instinit \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = YREG+(*_PREG)->u.yx.y; \ + d0 = *pt0; \ + deref_head(d0, punsafe_unk); \ + punsafe_nonvar: \ + XREG((*_PREG)->u.yx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONEXT(); \ + \ + derefa_body(d0, pt0, punsafe_unk, punsafe_nonvar); \ + if (pt0 <= HR || pt0 >= YREG) { \ + XREG((*_PREG)->u.yx.x) = Unsigned(pt0); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONEXT(); \ + } \ + else { \ + Bind_Local(pt0, Unsigned(HR)); \ + XREG((*_PREG)->u.yx.x) = (CELL) HR; \ + RESET_VARIABLE(HR); \ + H++; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); + +#define _put_atom_instinit \ + register CELL d0; \ + d0 = (*_PREG)->u.xc.c; \ + XREG((*_PREG)->u.xc.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xc); \ + GONEXT(); + +#define PUT_DBTERM_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.xD.D; \ + XREG((*_PREG)->u.xD.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xD); \ + GONext(); + +#define PUT_BIGINT_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.xN.b; \ + XREG((*_PREG)->u.xN.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xN); \ + GONext(); + +#define _put_float_instinit \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.xd.d); \ + XREG((*_PREG)->u.xd.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + GONEXT(); + +#define PUT_LONGINT_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.xi.i); \ + XREG((*_PREG)->u.xi.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xi); \ + GONext(); + +#define _put_list_instinit \ + register CELL d0; \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = HR; \ + HR += 2; \ + d0 = AbsPair(S_SREG); \ + XREG((*_PREG)->u.x.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), x); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONEXT(); + +#define _put_struct_instinit \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + XREG((*_PREG)->u.xfa.x) = d0; \ + d0 = (CELL) ((*_PREG)->u.xfa.f); \ + *H++ = d0; \ + (*_SREG) = HR; \ + HR += (*_PREG)->u.xfa.a; \ + (*_PREG) = NEXTOP((*_PREG), xfa); \ + GONEXT(); + diff --git a/JIT/HPP/singlecode_unify.h b/JIT/HPP/singlecode_unify.h new file mode 100644 index 000000000..99c483e0e --- /dev/null +++ b/JIT/HPP/singlecode_unify.h @@ -0,0 +1,1373 @@ +#ifdef YAPOR_SBA +#define _unify_x_var_instinit \ + CACHE_S(); \ + READ_IN_S(); \ + BEGD(d0); \ + d0 = *S_SREG; \ + if (d0 == 0) { \ + d0 = (CELL)S_SREG; \ + } \ + WRITEBACK_S(S_SREG+1); \ + XREG((*_PREG)->u.ox.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXT(); \ + ENDD(d0); \ + ENDCACHE_S(); +#else /* YAPOR_SBA */ +#define _unify_x_var_instinit \ + CACHE_S(); \ + READ_IN_S(); \ + BEGD(d0); \ + d0 = *S_SREG; \ + WRITEBACK_S(S_SREG+1); \ + XREG((*_PREG)->u.ox.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXT(); \ + ENDD(d0); \ + ENDCACHE_S(); +#endif /* YAPOR_SBA */ + +#define _unify_x_var_write_instinit \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + RESET_VARIABLE(S_SREG); \ + *pt0 = (CELL) S_SREG; \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONEXTW(); + +#ifdef YAPOR_SBA +#define _unify_l_x_var_instinit \ + BEGP(pt0); \ + BEGD(d0); \ + d0 = SREG[0]; \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + if (d0 == 0) { \ + d0 = (CELL)SREG; \ + } \ + *pt0 = d0; \ + GONEXT(); \ + ENDD(d0); \ + ENDP(pt0); +#else /* YAPOR_SBA */ +#define _unify_l_x_var_instinit \ + BEGP(pt0); \ + BEGD(d0); \ + d0 = (*_SREG)[0]; \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + *pt0 = d0; \ + GONEXT(); \ + ENDD(d0); \ + ENDP(pt0); +#endif /* YAPOR_SBA */ + +#define _unify_l_x_var_write_instinit \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + RESET_VARIABLE(S_SREG); \ + *pt0 = (CELL)S_SREG; \ + ENDCACHE_S(); \ + GONEXT(); + +#ifdef YAPOR_SBA +#define _unify_x_var2_instinit \ + CACHE_S(); \ + READ_IN_S(); \ + BEGP(pt0); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + BEGD(d0); \ + d0 = S_SREG[0]; \ + BEGD(d1); \ + d1 = S_SREG[1]; \ + if (d0 == 0) { \ + d0 = (CELL)S_SREG; \ + } \ + if (d1 == 0) { \ + d1 = (CELL)(S_SREG+1); \ + } \ + WRITEBACK_S(S_SREG+2); \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + *pt0 = d1; \ + ENDD(d0); \ + ENDD(d1); \ + ENDP(pt0); \ + GONEXT(); \ + ENDCACHE_S(); +#else /* YAPOR_SBA */ +#define _unify_x_var2_instinit \ + CACHE_S(); \ + READ_IN_S(); \ + BEGP(pt0); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + BEGD(d0); \ + d0 = S_SREG[0]; \ + BEGD(d1); \ + d1 = S_SREG[1]; \ + WRITEBACK_S(S_SREG+2); \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + *pt0 = d1; \ + ENDD(d0); \ + ENDD(d1); \ + ENDP(pt0); \ + GONEXT(); \ + ENDCACHE_S(); +#endif /* YAPOR_SBA */ + +#define _unify_x_var2_write_instinit \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + RESET_VARIABLE(S_SREG); \ + XREG((*_PREG)->u.oxx.xl) = (CELL) S_SREG; \ + S_SREG++; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + RESET_VARIABLE(S_SREG); \ + *pt0 = (CELL) S_SREG; \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONEXTW(); + +#ifdef YAPOR_SBA +#define _unify_l_x_var2_instinit \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + d0 = S_SREG[0]; \ + d1 = S_SREG[1]; \ + if (d0 == 0) \ + XREG((*_PREG)->u.oxx.xl) = (CELL)S_SREG; \ + else \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + if (d1 == 0) \ + *pt0 = (CELL)(S_SREG+1); \ + else \ + *pt0 = d1; \ + ENDCACHE_S(); \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _unify_l_x_var2_instinit \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + d0 = S_SREG[0]; \ + d1 = S_SREG[1]; \ + { \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + } \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + { \ + *pt0 = d1; \ + } \ + ENDCACHE_S(); \ + GONEXT(); +#endif /* YAPOR_SBA */ + +#define _unify_l_x_var2_write_instinit \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + XREG((*_PREG)->u.oxx.xl) = (CELL) S_SREG; \ + RESET_VARIABLE(S_SREG); \ + S_SREG++; \ + *pt0 = (CELL) S_SREG; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + RESET_VARIABLE(S_SREG); \ + ENDCACHE_S(); \ + GONEXT(); + +#ifdef YAPOR_SBA +#define _unify_y_var_instinit \ + register CELL d0; \ + d0 = *(*_SREG)++; \ + if (d0 == 0) { \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL)((*_SREG)-1)); \ + } else \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _unify_y_var_instinit \ + register CELL d0; \ + d0 = *(*_SREG)++; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,d0); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONEXT(); +#endif /* YAPOR_SBA */ + +#define _unify_y_var_write_instinit \ + CACHE_S(); \ + READ_IN_S(); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL) S_SREG); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONEXTW(); + +#ifdef YAPOR_SBA +#define _unify_l_y_var_instinit \ + register CELL d0; \ + d0 = (*_SREG)[0]; \ + if (d0 == 0) { \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL)(*_SREG)); \ + } else \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _unify_l_y_var_instinit \ + register CELL d0; \ + d0 = (*_SREG)[0]; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,d0); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONEXT(); +#endif /* YAPOR_SBA */ + +#define _unify_l_y_var_write_instinit \ + CACHE_S(); \ + READ_IN_S(); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL) S_SREG); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + RESET_VARIABLE(S_SREG); \ + ENDCACHE_S(); \ + GONEXT(); + +#define _unify_x_val_instinit \ + BEGD(d0); \ + BEGD(d1); \ + BEGP(pt0); \ + pt0 = (*_SREG); \ + d0 = *pt0; \ + deref_head(d0, uvalx_unk); \ + \ + uvalx_nonvar: \ + d1 = XREG((*_PREG)->u.ox.x); \ + deref_head(d1, uvalx_nonvar_unk); \ + \ + uvalx_nonvar_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + YAAM_UnifyBound(d0, d1); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, uvalx_nonvar_unk, uvalx_nonvar_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONEXT(); \ + ENDP(pt1); \ + \ + derefa_body(d0, pt0, uvalx_unk, uvalx_nonvar); \ + d1 = XREG((*_PREG)->u.ox.x); \ + deref_head(d1, uvalx_var_unk); \ + \ + uvalx_var_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, uvalx_var_unk, uvalx_var_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONEXT(); \ + ENDP(pt1); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _unify_x_val_write_instinit \ + *(*_SREG)++ = XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXTW(); + +#define _unify_l_x_val_instinit \ + BEGD(d0); \ + BEGD(d1); \ + BEGP(pt0); \ + pt0 = (*_SREG); \ + d0 = *pt0; \ + deref_head(d0, ulvalx_unk); \ + \ + ulvalx_nonvar: \ + d1 = XREG((*_PREG)->u.ox.x); \ + deref_head(d1, ulvalx_nonvar_unk); \ + \ + ulvalx_nonvar_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + YAAM_UnifyBound(d0, d1); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, ulvalx_nonvar_unk, ulvalx_nonvar_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind(pt1, d0); \ + GONEXT(); \ + ENDP(pt1); \ + \ + derefa_body(d0, pt0, ulvalx_unk, ulvalx_nonvar); \ + d1 = XREG((*_PREG)->u.ox.x); \ + deref_head(d1, ulvalx_var_unk); \ + \ + ulvalx_var_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind_Global(pt0, d1); \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, ulvalx_var_unk, ulvalx_var_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONEXT(); \ + ENDP(pt1); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _unify_l_x_val_write_instinit \ + (*_SREG)[0] = XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXT(); + +#define UNIFY_Y_VAL_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_Y_VAL_UVALY_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_VAL_UVALY_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_Y_VAL_UVALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_Y_VAL_UVALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_Y_VAL_UVALY_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_VAL_UVALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_Y_VAL_UVALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#ifdef YAPOR_SBA +#define UNIFY_Y_VAL_WRITE_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + if (d0 == 0) \ + *(*_SREG)++ = (CELL)(YREG+(*_PREG)->u.oy.y); \ + else \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); +#else /* YAPOR_SBA */ +#define UNIFY_Y_VAL_WRITE_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); +#endif /* YAPOR_SBA */ + +#define UNIFY_L_Y_VAL_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_Y_VAL_ULVALY_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_L_Y_VAL_ULVALY_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_Y_VAL_ULVALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#ifdef YAPOR_SBA +#define UNIFY_L_Y_VAL_WRITE_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + if (d0 == 0) \ + (*_SREG)[0] = (CELL)(YREG+(*_PREG)->u.oy.y); \ + else \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#else /* YAPOR_SBA */ +#define UNIFY_L_Y_VAL_WRITE_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#endif /* YAPOR_SBA */ + +#define _unify_x_loc_instinit \ + BEGD(d0); \ + BEGD(d1); \ + BEGP(pt0); \ + pt0 = (*_SREG); \ + d0 = *pt0; \ + deref_head(d0, uvalx_loc_unk); \ + \ + uvalx_loc_nonvar: \ + d1 = XREG((*_PREG)->u.ox.x); \ + deref_head(d1, uvalx_loc_nonvar_unk); \ + \ + uvalx_loc_nonvar_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + YAAM_UnifyBound(d0, d1); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, uvalx_loc_nonvar_unk, uvalx_loc_nonvar_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONEXT(); \ + ENDP(pt1); \ + \ + derefa_body(d0, pt0, uvalx_loc_unk, uvalx_loc_nonvar); \ + d1 = XREG((*_PREG)->u.ox.x); \ + deref_head(d1, uvalx_loc_var_unk); \ + \ + uvalx_loc_var_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, uvalx_loc_var_unk, uvalx_loc_var_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + UnifyCells(pt0, pt1); \ + GONEXT(); \ + ENDP(pt1); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _unify_x_loc_write_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.ox.x); \ + deref_head(d0, unify_x_loc_unk); \ + unify_x_loc_nonvar: \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXTW(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, unify_x_loc_unk, unify_x_loc_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + if (pt0 < HR) { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONEXTW(); \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + Bind_Local(pt0, Unsigned(S_SREG)); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONEXTW(); \ + } \ + ENDP(pt0); \ + ENDD(d0); + +#define _unify_l_x_loc_instinit \ + BEGD(d0); \ + BEGD(d1); \ + BEGP(pt0); \ + pt0 = (*_SREG); \ + d0 = *pt0; \ + deref_head(d0, ulvalx_loc_unk); \ + \ + ulvalx_loc_nonvar: \ + d1 = XREG((*_PREG)->u.ox.x); \ + deref_head(d1, ulvalx_loc_nonvar_unk); \ + \ + ulvalx_loc_nonvar_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + YAAM_UnifyBound(d0, d1); \ + \ + deref_body(d1, pt0, ulvalx_loc_nonvar_unk, ulvalx_loc_nonvar_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind(pt0, d0); \ + GONEXT(); \ + \ + derefa_body(d0, pt0, ulvalx_loc_unk, ulvalx_loc_nonvar); \ + d1 = XREG((*_PREG)->u.ox.x); \ + deref_head(d1, ulvalx_loc_var_unk); \ + \ + ulvalx_loc_var_nonvar: \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind_Global(pt0, d1); \ + GONEXT(); \ + \ + BEGP(pt1); \ + deref_body(d1, pt1, ulvalx_loc_var_unk, ulvalx_loc_var_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONEXT(); \ + ENDP(pt1); \ + ENDP(pt0); \ + ENDD(d1); \ + ENDD(d0); + +#define _unify_l_x_loc_write_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.ox.x); \ + deref_head(d0, ulnify_x_loc_unk); \ + ulnify_x_loc_nonvar: \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, ulnify_x_loc_unk, ulnify_x_loc_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + if (pt0 < HR) { \ + (*_SREG)[0] = Unsigned(pt0); \ + GONEXT(); \ + } \ + else { \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); + +#define UNIFY_Y_LOC_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_Y_LOC_UVALY_LOC_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_Y_LOC_UVALY_LOC_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_Y_LOC_UVALY_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + UnifyCells(pt0, pt1); \ + GONext(); + +#define UNIFY_Y_LOC_WRITE_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.oy.y; \ + d0 = *pt0; + +#define UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); + +#define UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + if (pt0 < HR) { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONextW(); \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + Bind_Local(pt0, Unsigned(S_SREG)); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); \ + } + +#define UNIFY_L_Y_LOC_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_L_Y_LOC_ULVALY_LOC_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define UNIFY_L_Y_LOC_WRITE_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.oy.y; \ + d0 = *pt0; + +#define UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); + +#define UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + if (pt0 < HR) { \ + (*_SREG)[0] = Unsigned(pt0); \ + GONext(); \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + Bind_Local(pt0, Unsigned(S_SREG)); \ + RESET_VARIABLE(S_SREG); \ + ENDCACHE_S(); \ + GONext(); \ + } + +#define _unify_void_instinit \ + (*_PREG) = NEXTOP((*_PREG), o); \ + (*_SREG)++; \ + GONEXT(); + +#define _unify_void_write_instinit \ + CACHE_S(); \ + READ_IN_S(); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONEXTW(); + +#define UNIFY_L_VOID_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG), o); \ + GONext(); + +#define UNIFY_L_VOID_WRITE_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG), o); \ + RESET_VARIABLE((*_SREG)); \ + GONext(); + +#define _unify_n_voids_instinit \ + (*_SREG) += (*_PREG)->u.os.s; \ + (*_PREG) = NEXTOP((*_PREG), os); \ + GONEXT(); + +#define _unify_n_voids_write_instinit \ + register CELL d0; \ + CACHE_S(); \ + d0 = (*_PREG)->u.os.s; \ + READ_IN_S(); \ + (*_PREG) = NEXTOP((*_PREG), os); \ + for (; d0 > 0; d0--) { \ + RESET_VARIABLE(S_SREG); \ + S_SREG++; \ + } \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONEXTW(); + +#define _unify_l_n_voids_instinit \ + (*_PREG) = NEXTOP((*_PREG), os); \ + GONEXT(); + +#define _unify_l_n_voids_write_instinit \ + register CELL d0; \ + d0 = (*_PREG)->u.os.s; \ + (*_PREG) = NEXTOP((*_PREG), os); \ + CACHE_S(); \ + READ_IN_S(); \ + for (; d0 > 0; d0--) { \ + RESET_VARIABLE(S_SREG); \ + S_SREG++; \ + } \ + ENDCACHE_S(); \ + GONEXT(); + +#define _unify_atom_instinit \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = (*_SREG)++; \ + d0 = *pt0; \ + deref_head(d0, uatom_unk); \ + uatom_nonvar: \ + if (d0 != (*_PREG)->u.oc.c) { \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONEXT(); \ + \ + derefa_body(d0, pt0, uatom_unk, uatom_nonvar); \ + d0 = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + Bind_Global(pt0, d0); \ + GONEXT(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _unify_atom_write_instinit \ + * (*_SREG)++ = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONEXTW(); + +#define _unify_l_atom_instinit \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = (*_SREG); \ + d0 = *(*_SREG); \ + deref_head(d0, ulatom_unk); \ + ulatom_nonvar: \ + if (d0 != (*_PREG)->u.oc.c) { \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONEXT(); \ + \ + derefa_body(d0, pt0, ulatom_unk, ulatom_nonvar); \ + d0 = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + Bind_Global(pt0, d0); \ + GONEXT(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _unify_l_atom_write_instinit \ + (*_SREG)[0] = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONEXT(); + +#define UNIFY_N_ATOMS_INSTINIT \ + register Int i = (*_PREG)->u.osc.s; \ + register CELL d0, d1; \ + register CELL *pt0; \ + d1 = (*_PREG)->u.osc.c; \ + for (; i > 0; i--) { \ + pt0 = (*_SREG)++; \ + d0 = *pt0; \ + Int nonvar = 1; \ + if(IsVarTerm(d0)) { \ + nonvar = 0; \ + while (Unsigned(pt0) != (d0)) { \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + } \ + if (!nonvar) { \ + Bind_Global(pt0, d1); \ + continue; \ + } \ + } \ + if (nonvar) { \ + if (d0 != d1) { \ + break; \ + } \ + continue; \ + } \ + } \ + (*_PREG) = NEXTOP((*_PREG), osc); \ + GONext(); + +#define UNIFY_N_ATOMS_WRITE_INSTINIT \ + register CELL d0, d1; \ + d0 = (*_PREG)->u.osc.s; \ + d1 = (*_PREG)->u.osc.c; \ + CACHE_S(); \ + READ_IN_S(); \ + (*_PREG) = NEXTOP((*_PREG), osc); \ + for (; d0 > 0; d0--) { \ + *S_SREG++ = d1; \ + } \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_FLOAT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_FLOAT_UFLOAT_NONVAR_INIT \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR \ + pt1 = (*_PREG)->u.od.d; \ + (*_PREG) = NEXTOP((*_PREG), od); + +#define UNIFY_FLOAT_UFLOAT_NONVAR_END \ + GONext(); + +#define UNIFY_FLOAT_UFLOAT_UNK \ + d1 = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_FLOAT_WRITE_INSTINIT \ + * (*_SREG)++ = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + GONextW(); + +#if SIZEOF_DOUBLE == 2*SIZEOF_INT_P +#define _unify_l_float_instinit \ + BEGD(d0); \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; \ + deref_head(d0, ulfloat_unk); \ + ulfloat_nonvar: \ + if (!IsApplTerm(d0)) { \ + FAIL(); \ + } \ + BEGP(pt0); \ + pt0 = RepAppl(d0); \ + BEGD(d0); \ + d0 = *pt0; \ + if (d0 != (CELL)FunctorDouble) { \ + FAIL(); \ + } \ + ENDD(d0); \ + BEGP(pt1); \ + pt1 = (*_PREG)->u.od.d; \ + (*_PREG) = NEXTOP((*_PREG), od); \ + if ( \ + pt1[1] != pt0[1] \ + || pt1[2] != pt0[2] \ + ) { \ + FAIL(); \ + } \ + ENDP(pt1); \ + ENDP(pt0); \ + GONEXT(); \ + \ + derefa_body(d0, S_SREG, ulfloat_unk, ulfloat_nonvar); \ + BEGD(d1); \ + d1 = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + Bind_Global(S_SREG, d1); \ + GONEXT(); \ + ENDD(d1); \ + ENDCACHE_S(); \ + ENDD(d0); +#else /* SIZEOF_DOUBLE == 2*SIZEOF_INT_P */ +#define _unify_l_float_instinit \ + BEGD(d0); \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; \ + deref_head(d0, ulfloat_unk); \ + ulfloat_nonvar: \ + if (!IsApplTerm(d0)) { \ + FAIL(); \ + } \ + BEGP(pt0); \ + pt0 = RepAppl(d0); \ + BEGD(d0); \ + d0 = *pt0; \ + if (d0 != (CELL)FunctorDouble) { \ + FAIL(); \ + } \ + ENDD(d0); \ + BEGP(pt1); \ + pt1 = (*_PREG)->u.od.d; \ + (*_PREG) = NEXTOP((*_PREG), od); \ + if ( \ + pt1[1] != pt0[1] \ + ) { \ + FAIL(); \ + } \ + ENDP(pt1); \ + ENDP(pt0); \ + GONEXT(); \ + \ + derefa_body(d0, S_SREG, ulfloat_unk, ulfloat_nonvar); \ + BEGD(d1); \ + d1 = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + Bind_Global(S_SREG, d1); \ + GONEXT(); \ + ENDD(d1); \ + ENDCACHE_S(); \ + ENDD(d0); +#endif /* SIZEOF_DOUBLE == 2*SIZEOF_INT_P */ + +#define _unify_l_float_write_instinit \ + (*_SREG)[0] = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + GONEXT(); + +#define UNIFY_LONGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_LONGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_LONGINT_D0ISFUNC \ + pt1 = (*_PREG)->u.oi.i; \ + (*_PREG) = NEXTOP((*_PREG), oi); + +#define UNIFY_LONGINT_EQUALS \ + GONext(); + +#define UNIFY_LONGINT_ULONGINT_UNK \ + d1 = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_LONGINT_WRITE_INSTINIT \ + * (*_SREG)++ = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + GONextW(); + +#define UNIFY_L_LONGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_LONGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_L_LONGINT_D0ISFUNC \ + pt1 = (*_PREG)->u.oi.i; \ + (*_PREG) = NEXTOP((*_PREG), oi); + +#define UNIFY_L_LONGINT_EQUALS \ + GONext(); + +#define UNIFY_L_LONGINT_ULLONGINT_UNK \ + d1 = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + Bind_Global(S_SREG, d1); \ + GONext(); + +#define UNIFY_L_LONGINT_WRITE_INSTINIT \ + (*_SREG)[0] = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + GONext(); + +#ifdef USE_GMP +#define UNIFY_BIGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_BIGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d1 = *pt0; + +#define UNIFY_BIGINT_D1ISFUNC_GMP \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + GONext(); + +#define UNIFY_BIGINT_UBIGINT_UNK \ + d1 = (*_PREG)->u.oN.b; \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + Bind_Global(pt0, d1); \ + GONext(); +#endif + +#ifdef USE_GMP +#define UNIFY_L_BIGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_BIGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_L_BIGINT_D0ISFUNC_GMP \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + GONext(); + +#define UNIFY_L_BIGINT_ULBIGINT_UNK \ + d1 = (*_PREG)->u.oN.b; \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + Bind_Global(S_SREG, d1); \ + GONext(); \ + ENDCACHE_S(); +#endif + +#define UNIFY_DBTERM_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_DBTERM_UDBTERM_NONVAR \ + BLOCK = (CELL)UNIFY_DBTERM_UDBTERM_NONVAR; \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + YAAM_UNIFYBOUND; + +#define UNIFY_DBTERM_UDBTERM_UNK \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_DBTERM_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_DBTERM_ULDBTERM_NONVAR \ + BLOCK = (CELL)UNIFY_L_DBTERM_ULDBTERM_NONVAR; \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_DBTERM_ULDBTERM_UNK \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + Bind_Global(S_SREG, d1); \ + GONext(); \ + ENDCACHE_S(); + +#define UNIFY_LIST_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + *--SP = Unsigned((*_SREG) + 1); \ + *--SP = READ_MODE; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_LIST_READMODE \ + BLOCK = (CELL)UNIFY_LIST_READMODE; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_SREG) = RepPair(d0); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + GONext(); \ + } + +#define UNIFY_LIST_WRITEMODE \ + START_PREFETCH_W(o); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = HR; \ + (*_PREG) = NEXTOP((*_PREG), o); \ + HR = S_SREG + 2; \ + d0 = AbsPair(S_SREG); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + Bind_Global(pt0, d0); \ + GONextW(); \ + END_PREFETCH_W(); + +#define UNIFY_LIST_WRITE_INSTINIT \ + register CELL d0; \ + (*_PREG) = NEXTOP((*_PREG), o); \ + d0 = AbsPair(HR); \ + CACHE_S(); \ + READ_IN_S(); \ + SP -= 2; \ + SP[0] = WRITE_MODE; \ + SP[1] = Unsigned(S_SREG + 1); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define _unify_l_list_instinit \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = (*_SREG); \ + d0 = *pt0; \ + deref_head(d0, ullist_unk); \ + ullist_nonvar: \ + if (!IsPairTerm(d0)) { \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), o); \ + (*_SREG) = RepPair(d0); \ + GONEXT(); \ + \ + derefa_body(d0, pt0, ullist_unk, ullist_nonvar); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + d0 = AbsPair(S_SREG); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + Bind_Global(pt0, d0); \ + GONEXTW(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _unify_l_list_write_instinit \ + register CELL d0; \ + d0 = AbsPair(HR); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONEXTW(); + +#define _unify_struct_instinit \ + *--SP = Unsigned((*_SREG) + 1); \ + *--SP = READ_MODE; \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = (*_SREG); \ + d0 = *pt0; \ + deref_head(d0, ustruct_unk); \ + ustruct_nonvar: \ + if (!IsApplTerm(d0)) { \ + FAIL(); \ + } \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = RepAppl(d0); \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + if (*S_SREG != d0) { \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONEXT(); \ + \ + derefa_body(d0, pt0, ustruct_unk, ustruct_nonvar); \ + BEGD(d1); \ + d1 = AbsAppl(HR); \ + Bind_Global(pt0, d1); \ + pt0 = HR; \ + ENDD(d1); \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *pt0++ = d0; \ + HR = pt0 + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + (*_SREG) = pt0; \ + GONEXTW(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _unify_struct_write_instinit \ + CACHE_S(); \ + READ_IN_S(); \ + *--SP = Unsigned(S_SREG + 1); \ + *--SP = WRITE_MODE; \ + BEGD(d0); \ + d0 = AbsAppl(HR); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *S_SREG++ = d0; \ + HR = S_SREG + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + ENDD(d0); \ + GONEXTW(); + +#define _unify_l_struc_instinit \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = (*_SREG); \ + d0 = *pt0; \ + deref_head(d0, ulstruct_unk); \ + ulstruct_nonvar: \ + if (!IsApplTerm(d0)) { \ + FAIL(); \ + } \ + (*_SREG) = RepAppl(d0); \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + if (*(*_SREG)++ != d0) { \ + FAIL(); \ + } \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + GONEXT(); \ + \ + derefa_body(d0, pt0, ulstruct_unk, ulstruct_nonvar); \ + BEGD(d1); \ + d1 = AbsAppl(HR); \ + Bind_Global(pt0, d1); \ + pt0 = HR; \ + ENDD(d1); \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *pt0++ = d0; \ + HR = pt0 + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + (*_SREG) = pt0; \ + GONEXTW(); \ + ENDP(pt0); \ + ENDD(d0); + +#define _unify_l_struc_write_instinit \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *S_SREG++ = d0; \ + HR = S_SREG + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONEXTW(); + +#define _save_pair_x_instinit \ + XREG((*_PREG)->u.ox.x) = AbsPair((*_SREG)); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXT(); + +#define _save_pair_x_write_instinit \ + XREG((*_PREG)->u.ox.x) = AbsPair((*_SREG)); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXTW(); + +#define SAVE_PAIR_Y_INSTINIT \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsPair((*_SREG))); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); + +#define SAVE_PAIR_Y_WRITE_INSTINIT \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsPair((*_SREG))); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); + +#define _save_appl_x_instinit \ + XREG((*_PREG)->u.ox.x) = AbsAppl((*_SREG) - 1); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXT(); + +#define _save_appl_x_write_instinit \ + XREG((*_PREG)->u.ox.x) = AbsAppl((*_SREG) - 1); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONEXTW(); + +#define SAVE_APPL_Y_INSTINIT \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsAppl((*_SREG)-1)); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); + +#define SAVE_APPL_Y_WRITE_INSTINIT \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsAppl((*_SREG)-1)); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); + diff --git a/JIT/HPP/singlecode_write.h b/JIT/HPP/singlecode_write.h new file mode 100644 index 000000000..e53777b44 --- /dev/null +++ b/JIT/HPP/singlecode_write.h @@ -0,0 +1,374 @@ +#define WRITE_X_VAR_INSTINIT \ + XREG((*_PREG)->u.x.x) = Unsigned((*_SREG)); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); + +#define WRITE_VOID_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG), e); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); + +#define WRITE_N_VOIDS_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.s.s; \ + (*_PREG) = NEXTOP((*_PREG), s); \ + for (; d0 > 0; d0--) { \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + } \ + GONext(); + +#define _write_y_var_instinit \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.y.y,Unsigned((*_SREG))); \ + (*_PREG) = NEXTOP((*_PREG), y); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONEXT(); + +#define _write_x_val_instinit \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.x.x); \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), x); \ + GONEXT(); + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#ifdef FROZEN_STACKS +#define _write_x_loc_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.x.x); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + deref_head(d0, w_x_unk); \ + w_x_bound: \ + *(*_SREG)++ = d0; \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, w_x_unk, w_x_bound); \ + if (pt0 > HR && pt0<(CELL *)B_FZ) { \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONEXT(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _write_x_loc_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.x.x); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + deref_head(d0, w_x_unk); \ + w_x_bound: \ + *(*_SREG)++ = d0; \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, w_x_unk, w_x_bound); \ + if (pt0 > HR && pt0<(CELL *)B_FZ) { \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + *pt0 = Unsigned((*_SREG)); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONEXT(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#ifdef FROZEN_STACKS +#define _write_x_loc_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.x.x); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + deref_head(d0, w_x_unk); \ + w_x_bound: \ + *(*_SREG)++ = d0; \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, w_x_unk, w_x_bound); \ + if (pt0 > HR) { \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONEXT(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _write_x_loc_instinit \ + BEGD(d0); \ + d0 = XREG((*_PREG)->u.x.x); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + deref_head(d0, w_x_unk); \ + w_x_bound: \ + *(*_SREG)++ = d0; \ + GONEXT(); \ + \ + BEGP(pt0); \ + deref_body(d0, pt0, w_x_unk, w_x_bound); \ + if (pt0 > HR) { \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + *pt0 = Unsigned((*_SREG)); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONEXT(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#ifdef YAPOR_SBA +#define _write_y_val_instinit \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.y.y]; \ + if (d0 == 0) \ + *(*_SREG)++ = (CELL)(YREG+(*_PREG)->u.y.y); \ + else \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONEXT(); +#else /* YAPOR_SBA */ +#define _write_y_val_instinit \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.y.y]; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONEXT(); +#endif /* YAPOR_SBA */ + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#ifdef FROZEN_STACKS +#define _write_y_loc_instinit \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = YREG+(*_PREG)->u.y.y; \ + d0 = *pt0; \ + deref_head(d0, w_y_unk); \ + w_y_bound: \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = d0; \ + GONEXT(); \ + \ + derefa_body(d0, pt0, w_y_unk, w_y_bound); \ + if (pt0 > HR \ + && pt0<(CELL *)B_FZ \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONEXT(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _write_y_loc_instinit \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = YREG+(*_PREG)->u.y.y; \ + d0 = *pt0; \ + deref_head(d0, w_y_unk); \ + w_y_bound: \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = d0; \ + GONEXT(); \ + \ + derefa_body(d0, pt0, w_y_unk, w_y_bound); \ + if (pt0 > HR \ + && pt0<(CELL *)B_FZ \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *pt0 = Unsigned((*_SREG)); \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONEXT(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#ifdef FROZEN_STACKS +#define _write_y_loc_instinit \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = YREG+(*_PREG)->u.y.y; \ + d0 = *pt0; \ + deref_head(d0, w_y_unk); \ + w_y_bound: \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = d0; \ + GONEXT(); \ + \ + derefa_body(d0, pt0, w_y_unk, w_y_bound); \ + if (pt0 > HR \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONEXT(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); +#else /* FROZEN_STACKS */ +#define _write_y_loc_instinit \ + BEGD(d0); \ + BEGP(pt0); \ + pt0 = YREG+(*_PREG)->u.y.y; \ + d0 = *pt0; \ + deref_head(d0, w_y_unk); \ + w_y_bound: \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = d0; \ + GONEXT(); \ + \ + derefa_body(d0, pt0, w_y_unk, w_y_bound); \ + if (pt0 > HR \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *pt0 = Unsigned((*_SREG)); \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONEXT(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONEXT(); \ + } \ + ENDP(pt0); \ + ENDD(d0); +#endif /* FROZEN_STACKS */ +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#define _write_atom_instinit \ + register CELL d0; \ + d0 = (*_PREG)->u.c.c; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), c); \ + GONEXT(); + +#define WRITE_BIGINT_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.N.b; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), N); \ + GONext(); + +#define _write_dbterm_instinit \ + register CELL d0; \ + d0 = (*_PREG)->u.D.D; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), D); \ + GONEXT(); + +#define _write_float_instinit \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.d.d); \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), d); \ + GONEXT(); + +#define WRITE_LONGIT_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.i.i); \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), i); \ + GONext(); + +#define WRITE_N_ATOMS_INSTINIT \ + register CELL d0, d1; \ + d0 = (*_PREG)->u.sc.s; \ + d1 = (*_PREG)->u.sc.c; \ + for (; d0 > 0; d0--) { \ + *(*_SREG)++ = d1; \ + } \ + (*_PREG) = NEXTOP((*_PREG), sc); \ + GONext(); + +#define WRITE_LIST_INSTINIT \ + register CELL d0; \ + d0 = AbsPair(HR); \ + *(*_SREG)++ = d0; \ + SP[-1] = Unsigned((*_SREG)); \ + SP[-2] = 1; \ + SP -= 2; \ + (*_SREG) = HR; \ + HR += 2; \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); + +#define _write_l_list_instinit \ + register CELL d0; \ + (*_PREG) = NEXTOP((*_PREG), e); \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = AbsPair(HR); \ + *S_SREG = d0; \ + WRITEBACK_S(HR); \ + HR += 2; \ + ENDCACHE_S(); \ + GONEXT(); \ + +#define _write_struct_instinit \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + *(*_SREG)++ = d0; \ + SP[-1] = Unsigned((*_SREG)); \ + SP[-2] = 1; \ + SP -= 2; \ + d0 = (CELL) ((*_PREG)->u.fa.f); \ + *H++ = d0; \ + d0 = (*_PREG)->u.fa.a; \ + (*_PREG) = NEXTOP((*_PREG), fa); \ + (*_SREG) = HR; \ + HR += d0; \ + GONEXT(); + +#define _write_l_struc_instinit \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + *(*_SREG) = d0; \ + d0 = (CELL) ((*_PREG)->u.fa.f); \ + *H++ = d0; \ + (*_SREG) = HR; \ + d0 = (*_PREG)->u.fa.a; \ + (*_PREG) = NEXTOP((*_PREG), fa); \ + HR += d0; \ + GONEXT(); + diff --git a/JIT/HPP/sprint_op.hh b/JIT/HPP/sprint_op.hh new file mode 100644 index 000000000..ce0da6d92 --- /dev/null +++ b/JIT/HPP/sprint_op.hh @@ -0,0 +1,3182 @@ +void sprint_op(char*, char*, op_numbers, char*); + +void +sprint_op(char *out, char* prepend_term, op_numbers op, char* append_term) { + char tmp[1024]; + switch(op){ + case _Ystop : + sprintf(tmp, "_Ystop"); + break; + + case _Nstop : + sprintf(tmp, "_Nstop"); + break; + + case _try_me : + sprintf(tmp, "_try_me"); + break; + + case _retry_me : + sprintf(tmp, "_retry_me"); + break; + + case _trust_me : + sprintf(tmp, "_trust_me"); + break; + + case _enter_profiling : + sprintf(tmp, "_enter_profiling"); + break; + + case _retry_profiled : + sprintf(tmp, "_retry_profiled"); + break; + + case _profiled_retry_me : + sprintf(tmp, "_profiled_retry_me"); + break; + + case _profiled_trust_me : + sprintf(tmp, "_profiled_trust_me"); + break; + + case _profiled_retry_logical : + sprintf(tmp, "_profiled_retry_logical"); + break; + + case _profiled_trust_logical : + sprintf(tmp, "_profiled_trust_logical"); + break; + + case _count_call : + sprintf(tmp, "_count_call"); + break; + + case _count_retry : + sprintf(tmp, "_count_retry"); + break; + + case _count_retry_me : + sprintf(tmp, "_count_retry_me"); + break; + + case _count_trust_me : + sprintf(tmp, "_count_trust_me"); + break; + + case _count_retry_logical : + sprintf(tmp, "_count_retry_logical"); + break; + + case _count_trust_logical : + sprintf(tmp, "_count_trust_logical"); + break; + + case _lock_lu : + sprintf(tmp, "_lock_lu"); + break; + + case _unlock_lu : + sprintf(tmp, "_unlock_lu"); + break; + + case _alloc_for_logical_pred : + sprintf(tmp, "_alloc_for_logical_pred"); + break; + + case _copy_idb_term : + sprintf(tmp, "_copy_idb_term"); + break; + + case _unify_idb_term : + sprintf(tmp, "_unify_idb_term"); + break; + + case _ensure_space : + sprintf(tmp, "_ensure_space"); + break; + + case _spy_or_trymark : + sprintf(tmp, "_spy_or_trymark"); + break; + + case _try_and_mark : + sprintf(tmp, "_try_and_mark"); + break; + + case _count_retry_and_mark : + sprintf(tmp, "_count_retry_and_mark"); + break; + + case _profiled_retry_and_mark : + sprintf(tmp, "_profiled_retry_and_mark"); + break; + + case _retry_and_mark : + sprintf(tmp, "_retry_and_mark"); + break; + + case _trust_fail : + sprintf(tmp, "_trust_fail"); + break; + + case _op_fail : + sprintf(tmp, "_op_fail"); + break; + + case _cut : + sprintf(tmp, "_cut"); + break; + + case _cut_t : + sprintf(tmp, "_cut_t"); + break; + + case _cut_e : + sprintf(tmp, "_cut_e"); + break; + + case _save_b_x : + sprintf(tmp, "_save_b_x"); + break; + + case _save_b_y : + sprintf(tmp, "_save_b_y"); + break; + + case _commit_b_x : + sprintf(tmp, "_commit_b_x"); + break; + + case _commit_b_y : + sprintf(tmp, "_commit_b_y"); + break; + + case _execute : + sprintf(tmp, "_execute"); + break; + + case _dexecute : + sprintf(tmp, "_dexecute"); + break; + + case _fcall : + sprintf(tmp, "_fcall"); + break; + + case _call : + sprintf(tmp, "_call"); + break; + + case _procceed : + sprintf(tmp, "_procceed"); + break; + + case _allocate : + sprintf(tmp, "_allocate"); + break; + + case _deallocate : + sprintf(tmp, "_deallocate"); + break; + +#ifdef BEAM + case _retry_eam : + sprintf(tmp, "_retry_eam"); + break; + +#endif +#ifdef BEAM + case _run_eam : + sprintf(tmp, "_run_eam"); + break; + +#endif + case _get_x_var : + sprintf(tmp, "_get_x_var"); + break; + + case _get_y_var : + sprintf(tmp, "_get_y_var"); + break; + + case _get_yy_var : + sprintf(tmp, "_get_yy_var"); + break; + + case _get_x_val : + sprintf(tmp, "_get_x_val"); + break; + + case _get_y_val : + sprintf(tmp, "_get_y_val"); + break; + + case _get_atom : + sprintf(tmp, "_get_atom"); + break; + + case _get_2atoms : + sprintf(tmp, "_get_2atoms"); + break; + + case _get_3atoms : + sprintf(tmp, "_get_3atoms"); + break; + + case _get_4atoms : + sprintf(tmp, "_get_4atoms"); + break; + + case _get_5atoms : + sprintf(tmp, "_get_5atoms"); + break; + + case _get_6atoms : + sprintf(tmp, "_get_6atoms"); + break; + + case _get_list : + sprintf(tmp, "_get_list"); + break; + + case _get_struct : + sprintf(tmp, "_get_struct"); + break; + + case _get_float : + sprintf(tmp, "_get_float"); + break; + + case _get_longint : + sprintf(tmp, "_get_longint"); + break; + + case _get_bigint : + sprintf(tmp, "_get_bigint"); + break; + + case _get_dbterm : + sprintf(tmp, "_get_dbterm"); + break; + + case _glist_valx : + sprintf(tmp, "_glist_valx"); + break; + + case _glist_valy : + sprintf(tmp, "_glist_valy"); + break; + + case _gl_void_varx : + sprintf(tmp, "_gl_void_varx"); + break; + + case _gl_void_vary : + sprintf(tmp, "_gl_void_vary"); + break; + + case _gl_void_valx : + sprintf(tmp, "_gl_void_valx"); + break; + + case _gl_void_valy : + sprintf(tmp, "_gl_void_valy"); + break; + + case _unify_x_var : + sprintf(tmp, "_unify_x_var"); + break; + + case _unify_x_var_write : + sprintf(tmp, "_unify_x_var_write"); + break; + + case _unify_l_x_var : + sprintf(tmp, "_unify_l_x_var"); + break; + + case _unify_l_x_var_write : + sprintf(tmp, "_unify_l_x_var_write"); + break; + + case _unify_x_var2 : + sprintf(tmp, "_unify_x_var2"); + break; + + case _unify_x_var2_write : + sprintf(tmp, "_unify_x_var2_write"); + break; + + case _unify_l_x_var2 : + sprintf(tmp, "_unify_l_x_var2"); + break; + + case _unify_l_x_var2_write : + sprintf(tmp, "_unify_l_x_var2_write"); + break; + + case _unify_y_var : + sprintf(tmp, "_unify_y_var"); + break; + + case _unify_y_var_write : + sprintf(tmp, "_unify_y_var_write"); + break; + + case _unify_l_y_var : + sprintf(tmp, "_unify_l_y_var"); + break; + + case _unify_l_y_var_write : + sprintf(tmp, "_unify_l_y_var_write"); + break; + + case _unify_x_val : + sprintf(tmp, "_unify_x_val"); + break; + + case _unify_x_val_write : + sprintf(tmp, "_unify_x_val_write"); + break; + + case _unify_l_x_val : + sprintf(tmp, "_unify_l_x_val"); + break; + + case _unify_l_x_val_write : + sprintf(tmp, "_uify_l_x_val_write"); + break; + + case _unify_y_val : + sprintf(tmp, "_unify_y_val"); + break; + + case _unify_y_val_write : + sprintf(tmp, "_unify_y_val_write"); + break; + + case _unify_l_y_val : + sprintf(tmp, "_unify_l_y_val"); + break; + + case _unify_l_y_val_write : + sprintf(tmp, "_unify_l_y_val_write"); + break; + + case _unify_x_loc : + sprintf(tmp, "_unify_x_loc"); + break; + + case _unify_x_loc_write : + sprintf(tmp, "_unify_x_loc_write"); + break; + + case _unify_l_x_loc : + sprintf(tmp, "_unify_l_x_loc"); + break; + + case _unify_l_x_loc_write : + sprintf(tmp, "_unify_l_x_loc_write"); + break; + + case _unify_y_loc : + sprintf(tmp, "_unify_y_loc"); + break; + + case _unify_y_loc_write : + sprintf(tmp, "_unify_y_loc_write"); + break; + + case _unify_l_y_loc : + sprintf(tmp, "_unify_l_y_loc"); + break; + + case _unify_l_y_loc_write : + sprintf(tmp, "_unify_l_y_loc_write"); + break; + + case _unify_void : + sprintf(tmp, "_unify_void"); + break; + + case _unify_void_write : + sprintf(tmp, "_unify_void_write"); + break; + + case _unify_l_void : + sprintf(tmp, "_unify_l_void"); + break; + + case _unify_l_void_write : + sprintf(tmp, "_unify_l_void_write"); + break; + + case _unify_n_voids : + sprintf(tmp, "_unify_n_voids"); + break; + + case _unify_n_voids_write : + sprintf(tmp, "_unify_n_voids_write"); + break; + + case _unify_l_n_voids : + sprintf(tmp, "_unify_l_n_voids"); + break; + + case _unify_l_n_voids_write : + sprintf(tmp, "_unify_l_n_voids_write"); + break; + + case _unify_atom : + sprintf(tmp, "_unify_atom"); + break; + + case _unify_atom_write : + sprintf(tmp, "_unify_atom_write"); + break; + + case _unify_l_atom : + sprintf(tmp, "_unify_l_atom"); + break; + + case _unify_l_atom_write : + sprintf(tmp, "_unify_l_atom_write"); + break; + + case _unify_n_atoms : + sprintf(tmp, "_unify_n_atoms"); + break; + + case _unify_n_atoms_write : + sprintf(tmp, "_unify_n_atoms_write"); + break; + + case _unify_float : + sprintf(tmp, "_unify_float"); + break; + + case _unify_float_write : + sprintf(tmp, "_unify_float_write"); + break; + + case _unify_l_float : + sprintf(tmp, "_unify_l_float"); + break; + + case _unify_l_float_write : + sprintf(tmp, "_unify_l_float_write"); + break; + + case _unify_longint : + sprintf(tmp, "_unify_longint"); + break; + + case _unify_longint_write : + sprintf(tmp, "_unify_longint_write"); + break; + + case _unify_l_longint : + sprintf(tmp, "_unify_l_longint"); + break; + + case _unify_l_longint_write : + sprintf(tmp, "_unify_l_longint_write"); + break; + + case _unify_bigint : + sprintf(tmp, "_unify_bigint"); + break; + + case _unify_l_bigint : + sprintf(tmp, "_unify_l_bigint"); + break; + + case _unify_dbterm : + sprintf(tmp, "_unify_dbterm"); + break; + + case _unify_l_dbterm : + sprintf(tmp, "_unify_l_dbterm"); + break; + + case _unify_list : + sprintf(tmp, "_unify_list"); + break; + + case _unify_list_write : + sprintf(tmp, "_unify_list_write"); + break; + + case _unify_l_list : + sprintf(tmp, "_unify_l_list"); + break; + + case _unify_l_list_write : + sprintf(tmp, "_unify_l_list_write"); + break; + + case _unify_struct : + sprintf(tmp, "_unify_struct"); + break; + + case _unify_struct_write : + sprintf(tmp, "_unify_struct_write"); + break; + + case _unify_l_struc : + sprintf(tmp, "_unify_l_struc"); + break; + + case _unify_l_struc_write : + sprintf(tmp, "_unify_l_struc_write"); + break; + + case _put_x_var : + sprintf(tmp, "_put_x_var"); + break; + + case _put_y_var : + sprintf(tmp, "_put_y_var"); + break; + + case _put_x_val : + sprintf(tmp, "_put_x_val"); + break; + + case _put_xx_val : + sprintf(tmp, "_put_xx_val"); + break; + + case _put_y_val : + sprintf(tmp, "_put_y_val"); + break; + + case _put_y_vals : + sprintf(tmp, "_put_y_vals"); + break; + + case _put_unsafe : + sprintf(tmp, "_put_unsafe"); + break; + + case _put_atom : + sprintf(tmp, "_put_atom"); + break; + + case _put_dbterm : + sprintf(tmp, "_put_dbterm"); + break; + + case _put_bigint : + sprintf(tmp, "_put_bigint"); + break; + + case _put_float : + sprintf(tmp, "_put_float"); + break; + + case _put_longint : + sprintf(tmp, "_put_longint"); + break; + + case _put_list : + sprintf(tmp, "_put_list"); + break; + + case _put_struct : + sprintf(tmp, "_put_struct"); + break; + + case _write_x_var : + sprintf(tmp, "_write_x_var"); + break; + + case _write_void : + sprintf(tmp, "_write_void"); + break; + + case _write_n_voids : + sprintf(tmp, "_write_n_voids"); + break; + + case _write_y_var : + sprintf(tmp, "_write_y_var"); + break; + + case _write_x_val : + sprintf(tmp, "_write_x_val"); + break; + + case _write_x_loc : + sprintf(tmp, "_write_x_loc"); + break; + + case _write_y_val : + sprintf(tmp, "_write_y_val"); + break; + + case _write_y_loc : + sprintf(tmp, "_write_y_loc"); + break; + + case _write_atom : + sprintf(tmp, "_write_atom"); + break; + + case _write_bigint : + sprintf(tmp, "_write_bigint"); + break; + + case _write_dbterm : + sprintf(tmp, "_write_dbterm"); + break; + + case _write_float : + sprintf(tmp, "_write_float"); + break; + + case _write_longint : + sprintf(tmp, "_write_longint"); + break; + + case _write_n_atoms : + sprintf(tmp, "_write_n_atoms"); + break; + + case _write_list : + sprintf(tmp, "_write_list"); + break; + + case _write_l_list : + sprintf(tmp, "_write_l_list"); + break; + + case _write_struct : + sprintf(tmp, "_write_struct"); + break; + + case _write_l_struc : + sprintf(tmp, "_write_l_struc"); + break; + + case _save_pair_x : + sprintf(tmp, "_save_pair_x"); + break; + + case _save_pair_x_write : + sprintf(tmp, "_save_pair_x_write"); + break; + + case _save_pair_y : + sprintf(tmp, "_save_pair_y"); + break; + + case _save_pair_y_write : + sprintf(tmp, "_save_pair_y_write"); + break; + + case _save_appl_x : + sprintf(tmp, "_save_appl_x"); + break; + + case _save_appl_x_write : + sprintf(tmp, "_save_appl_x_write"); + break; + + case _save_appl_y : + sprintf(tmp, "_save_appl_y"); + break; + + case _save_appl_y_write : + sprintf(tmp, "_save_appl_y_write"); + break; + + case _jump : + sprintf(tmp, "_jump"); + break; + + case _move_back : + sprintf(tmp, "_move_back"); + break; + + case _skip : + sprintf(tmp, "_skip"); + break; + + case _either : + sprintf(tmp, "_either"); + break; + + case _or_else : + sprintf(tmp, "_or_else"); + break; + + case _pop_n : + sprintf(tmp, "_pop_n"); + break; + + case _pop : + sprintf(tmp, "_pop"); + break; + + case _call_cpred : + sprintf(tmp, "_call_cpred"); + break; + + case _execute_cpred : + sprintf(tmp, "_execute_cpred"); + break; + + case _call_usercpred : + sprintf(tmp, "_call_usercpred"); + break; + + case _call_c_wfail : + sprintf(tmp, "_call_x_wfail"); + break; + + case _try_c : + sprintf(tmp, "_try_c"); + break; + + case _retry_c : + sprintf(tmp, "_retry_c"); + break; + +#ifdef CUT_C + case _cut_c : + sprintf(tmp, "_cut_c"); + break; + +#endif + case _try_userc : + sprintf(tmp, "_try_userc"); + break; + + case _retry_userc : + sprintf(tmp, "_retry_userc"); + break; + +#ifdef CUT_C + case _cut_userc : + sprintf(tmp, "_cut_userc"); + break; + +#endif + case _lock_pred : + sprintf(tmp, "_lock_pred"); + break; + + case _index_pred : + sprintf(tmp, "_index_pred"); + break; + +#ifdef THREADS + case _thread_local : + sprintf(tmp, "_thread_local"); + break; + +#endif + case _expand_index : + sprintf(tmp, "_expand_index"); + break; + + case _expand_clauses : + sprintf(tmp, "_expand_clauses"); + break; + + case _undef_p : + sprintf(tmp, "_undef_p"); + break; + + case _spy_pred : + sprintf(tmp, "_spy_pred"); + break; + + case _try_clause : + sprintf(tmp, "_try_clause"); + break; + + case _try_clause2 : + sprintf(tmp, "_try_clause2"); + break; + + case _try_clause3 : + sprintf(tmp, "_try_clause3"); + break; + + case _try_clause4 : + sprintf(tmp, "_try_clause4"); + break; + + case _retry : + sprintf(tmp, "_retry"); + break; + + case _retry2 : + sprintf(tmp, "_retry2"); + break; + + case _retry3 : + sprintf(tmp, "_retry3"); + break; + + case _retry4 : + sprintf(tmp, "_retry4"); + break; + + case _trust : + sprintf(tmp, "_trust"); + break; + + case _try_in : + sprintf(tmp, "_try_in"); + break; + + case _enter_lu_pred : + sprintf(tmp, "_enter_lu_pred"); + break; + + case _try_logical : + sprintf(tmp, "_try_logical"); + break; + + case _retry_logical : + sprintf(tmp, "_retry_logical"); + break; + + case _trust_logical : + sprintf(tmp, "_trust_logical"); + break; + + case _user_switch : + sprintf(tmp, "_user_switch"); + break; + + case _switch_on_type : + sprintf(tmp, "_switch_on_type"); + break; + + case _switch_list_nl : + sprintf(tmp, "_switch_list_nl"); + break; + + case _switch_on_arg_type : + sprintf(tmp, "_switch_on_arg_type"); + break; + + case _switch_on_sub_arg_type : + sprintf(tmp, "_switch_on_sub_arg_type"); + break; + + case _jump_if_var : + sprintf(tmp, "_jump_if_var"); + break; + + case _jump_if_nonvar : + sprintf(tmp, "_jump_if_nonvar"); + break; + + case _if_not_then : + sprintf(tmp, "_if_not_then"); + break; + + case _switch_on_func : + sprintf(tmp, "_switch_on_func"); + break; + + case _switch_on_cons : + sprintf(tmp, "_switch_on_cons"); + break; + + case _go_on_func : + sprintf(tmp, "_go_on_func"); + break; + + case _go_on_cons : + sprintf(tmp, "_go_on_cons"); + break; + + case _if_func : + sprintf(tmp, "_if_func"); + break; + + case _if_cons : + sprintf(tmp, "_if_cons"); + break; + + case _index_dbref : + sprintf(tmp, "_index_dbref"); + break; + + case _index_blob : + sprintf(tmp, "_index_blob"); + break; + + case _index_long : + sprintf(tmp, "_index_long"); + break; + +#ifdef YAP_JIT + case _jit_handler : + sprintf(tmp, "_jit_handler"); + break; +#endif /*YAP_JIT*/ + + case _p_atom_x : + sprintf(tmp, "_p_atom_x"); + break; + + case _p_atom_y : + sprintf(tmp, "_p_atom_y"); + break; + + case _p_atomic_x : + sprintf(tmp, "_p_atomic_x"); + break; + + case _p_atomic_y : + sprintf(tmp, "_p_atomic_y"); + break; + + case _p_integer_x : + sprintf(tmp, "_p_integer_x"); + break; + + case _p_integer_y : + sprintf(tmp, "_p_integer_y"); + break; + + case _p_nonvar_x : + sprintf(tmp, "_p_nonvar_x"); + break; + + case _p_nonvar_y : + sprintf(tmp, "_p_nonvar_y"); + break; + + case _p_number_x : + sprintf(tmp, "_p_number_x"); + break; + + case _p_number_y : + sprintf(tmp, "_p_number_y"); + break; + + case _p_var_x : + sprintf(tmp, "_p_var_x"); + break; + + case _p_var_y : + sprintf(tmp, "_p_var_y"); + break; + + case _p_db_ref_x : + sprintf(tmp, "_p_db_ref_x"); + break; + + case _p_db_ref_y : + sprintf(tmp, "_p_db_ref_y"); + break; + + case _p_primitive_x : + sprintf(tmp, "_p_primitive_x"); + break; + + case _p_primitive_y : + sprintf(tmp, "_p_primitive_y"); + break; + + case _p_compound_x : + sprintf(tmp, "_p_compound_x"); + break; + + case _p_compound_y : + sprintf(tmp, "_p_compound_y"); + break; + + case _p_float_x : + sprintf(tmp, "_p_float_x"); + break; + + case _p_float_y : + sprintf(tmp, "_p_float_y"); + break; + + case _p_plus_vv : + sprintf(tmp, "_p_plus_vv"); + break; + + case _p_plus_vc : + sprintf(tmp, "_p_plus_vc"); + break; + + case _p_plus_y_vv : + sprintf(tmp, "_p_plus_y_vv"); + break; + + case _p_plus_y_vc : + sprintf(tmp, "_p_plus_y_vc"); + break; + + case _p_minus_vv : + sprintf(tmp, "_p_minus_vv"); + break; + + case _p_minus_cv : + sprintf(tmp, "_p_minus_cv"); + break; + + case _p_minus_y_vv : + sprintf(tmp, "_p_minus_y_vv"); + break; + + case _p_minus_y_cv : + sprintf(tmp, "_p_minus_y_cv"); + break; + + case _p_times_vv : + sprintf(tmp, "_p_times_vv"); + break; + + case _p_times_vc : + sprintf(tmp, "_p_times_vc"); + break; + + case _p_times_y_vv : + sprintf(tmp, "_p_times_y_vv"); + break; + + case _p_times_y_vc : + sprintf(tmp, "_p_times_y_vc"); + break; + + case _p_div_vv : + sprintf(tmp, "_p_div_vv"); + break; + + case _p_div_vc : + sprintf(tmp, "_p_div_vc"); + break; + + case _p_div_cv : + sprintf(tmp, "_p_div_cv"); + break; + + case _p_div_y_vv : + sprintf(tmp, "_p_div_y_vv"); + break; + + case _p_div_y_vc : + sprintf(tmp, "_p_div_y_vc"); + break; + + case _p_div_y_cv : + sprintf(tmp, "_p_div_y_cv"); + break; + + case _p_and_vv : + sprintf(tmp, "_p_and_vv"); + break; + + case _p_and_vc : + sprintf(tmp, "_p_and_vc"); + break; + + case _p_and_y_vv : + sprintf(tmp, "_p_and_y_vv"); + break; + + case _p_and_y_vc : + sprintf(tmp, "_p_and_y_vc"); + break; + + case _p_or_vv : + sprintf(tmp, "_p_or_vv"); + break; + + case _p_or_vc : + sprintf(tmp, "_p_or_vc"); + break; + + case _p_or_y_vv : + sprintf(tmp, "_p_or_y_vv"); + break; + + case _p_or_y_vc : + sprintf(tmp, "_p_or_y_vc"); + break; + + case _p_sll_vv : + sprintf(tmp, "_p_sll_vv"); + break; + + case _p_sll_vc : + sprintf(tmp, "_p_sll_vc"); + break; + + case _p_sll_cv : + sprintf(tmp, "_p_sll_cv"); + break; + + case _p_sll_y_vv : + sprintf(tmp, "_p_sll_y_vv"); + break; + + case _p_sll_y_vc : + sprintf(tmp, "_p_sll_y_vc"); + break; + + case _p_sll_y_cv : + sprintf(tmp, "_p_sll_y_cv"); + break; + + case _p_slr_vv : + sprintf(tmp, "_p_slr_vv"); + break; + + case _p_slr_vc : + sprintf(tmp, "_p_slr_vc"); + break; + + case _p_slr_cv : + sprintf(tmp, "_p_slr_cv"); + break; + + case _p_slr_y_vv : + sprintf(tmp, "_p_slr_y_vv"); + break; + + case _p_slr_y_vc : + sprintf(tmp, "_p_slr_y_vc"); + break; + + case _p_slr_y_cv : + sprintf(tmp, "_p_slr_y_cv"); + break; + + case _call_bfunc_xx : + sprintf(tmp, "_call_bfunc_xx"); + break; + + case _call_bfunc_yx : + sprintf(tmp, "_call_bfunc_yx"); + break; + + case _call_bfunc_xy : + sprintf(tmp, "_call_bfunc_xy"); + break; + + case _call_bfunc_yy : + sprintf(tmp, "_call_bfunc_yy"); + break; + + case _p_equal : + sprintf(tmp, "_p_equal"); + break; + + case _p_dif : + sprintf(tmp, "_p_dif"); + break; + + case _p_eq : + sprintf(tmp, "_p_eq"); + break; + + case _p_arg_vv : + sprintf(tmp, "_p_arg_vv"); + break; + + case _p_arg_cv : + sprintf(tmp, "_p_arg_cv"); + break; + + case _p_arg_y_vv : + sprintf(tmp, "_p_arg_y_vv"); + break; + + case _p_arg_y_cv : + sprintf(tmp, "_p_arg_y_cv"); + break; + + case _p_func2s_vv : + sprintf(tmp, "_p_func2s_vv"); + break; + + case _p_func2s_cv : + sprintf(tmp, "_p_func2s_cv"); + break; + + case _p_func2s_vc : + sprintf(tmp, "_p_func2s_vc"); + break; + + case _p_func2s_y_vv : + sprintf(tmp, "_p_func2s_y_vv"); + break; + + case _p_func2s_y_cv : + sprintf(tmp, "_p_func2s_y_cv"); + break; + + case _p_func2s_y_vc : + sprintf(tmp, "_p_func2s_y_vc"); + break; + + case _p_func2f_xx : + sprintf(tmp, "_p_func2f_xx"); + break; + + case _p_func2f_xy : + sprintf(tmp, "_p_func2f_xy"); + break; + + case _p_func2f_yx : + sprintf(tmp, "_p_func2f_yx"); + break; + + case _p_func2f_yy : + sprintf(tmp, "_p_func2f_yy"); + break; + + case _p_functor : + sprintf(tmp, "_p_functor"); + break; + + case _p_execute2 : + sprintf(tmp, "_p_execute2"); + break; + + case _p_execute : + sprintf(tmp, "_p_execute"); + break; + + case _p_execute_tail : + sprintf(tmp, "_p_execute_tail"); + break; + +#ifdef YAPOR + case _getwork_first_time : + sprintf(tmp, "_getwork_first_time"); + break; + + case _getwork : + sprintf(tmp, "_getwork"); + break; + + case _getwork_seq : + sprintf(tmp, "_getwork_seq"); + break; + + case _sync : + sprintf(tmp, "_sync"); + break; + +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _clause_with_cut : + sprintf(tmp, "_clause_with_cut"); + break; + +#endif + case _table_load_answer : + sprintf(tmp, "_table_load_answer"); + break; + + case _table_try_answer : + sprintf(tmp, "_table_try_answer"); + break; + + case _table_try_single : + sprintf(tmp, "_table_try_single"); + break; + + case _table_try_me : + sprintf(tmp, "_table_try_me"); + break; + + case _table_try : + sprintf(tmp, "_table_try"); + break; + + case _table_retry_me : + sprintf(tmp, "_table_retry_me"); + break; + + case _table_retry : + sprintf(tmp, "_table_retry"); + break; + + case _table_trust_me : + sprintf(tmp, "_table_trust_me"); + break; + + case _table_trust : + sprintf(tmp, "_table_trust"); + break; + + case _table_new_answer : + sprintf(tmp, "_table_new_answer"); + break; + + case _table_answer_resolution : + sprintf(tmp, "_table_answer_resolution"); + break; + + case _table_completion : + sprintf(tmp, "_table_completion"); + break; + +#ifdef THREADS_CONSUMER_SHARING + case _table_answer_resolution_completion: + sprintf(tmp, "_table_answer_resolution_completion"); + break; + +#endif + case _trie_do_var : + sprintf(tmp, "_trie_do_var"); + break; + + case _trie_trust_var : + sprintf(tmp, "_trie_trust_var"); + break; + + case _trie_try_var : + sprintf(tmp, "_trie_try_var"); + break; + + case _trie_retry_var : + sprintf(tmp, "_trie_retry_var"); + break; + + case _trie_do_var_in_pair : + sprintf(tmp, "_trie_do_var_in_pair"); + break; + + case _trie_trust_var_in_pair : + sprintf(tmp, "_trie_trust_var_in_pair"); + break; + + case _trie_try_var_in_pair : + sprintf(tmp, "_trie_try_var_in_pair"); + break; + + case _trie_retry_var_in_pair : + sprintf(tmp, "_trie_retry_var_in_pair"); + break; + + case _trie_do_val : + sprintf(tmp, "_trie_do_val"); + break; + + case _trie_trust_val : + sprintf(tmp, "_trie_trust_val"); + break; + + case _trie_try_val : + sprintf(tmp, "_trie_try_val"); + break; + + case _trie_retry_val : + sprintf(tmp, "_trie_retry_val"); + break; + + case _trie_do_val_in_pair : + sprintf(tmp, "_trie_do_val_in_pair"); + break; + + case _trie_trust_val_in_pair : + sprintf(tmp, "_trie_trust_val_in_pair"); + break; + + case _trie_try_val_in_pair : + sprintf(tmp, "_trie_try_val_in_pair"); + break; + + case _trie_retry_val_in_pair : + sprintf(tmp, "_trie_retry_val_in_pair"); + break; + + case _trie_do_atom : + sprintf(tmp, "_trie_do_atom"); + break; + + case _trie_trust_atom : + sprintf(tmp, "_trie_trust_atom"); + break; + + case _trie_try_atom : + sprintf(tmp, "_trie_try_atom"); + break; + + case _trie_retry_atom : + sprintf(tmp, "_trie_retry_atom"); + break; + + case _trie_do_atom_in_pair : + sprintf(tmp, "_trie_do_atom_in_pair"); + break; + + case _trie_trust_atom_in_pair : + sprintf(tmp, "_trie_trust_atom_in_pair"); + break; + + case _trie_try_atom_in_pair : + sprintf(tmp, "_trie_try_atom_in_pair"); + break; + + case _trie_retry_atom_in_pair : + sprintf(tmp, "_trie_retry_atom_in_pair"); + break; + + case _trie_do_null : + sprintf(tmp, "_trie_do_null"); + break; + + case _trie_trust_null : + sprintf(tmp, "_trie_trust_null"); + break; + + case _trie_try_null : + sprintf(tmp, "_trie_try_null"); + break; + + case _trie_retry_null : + sprintf(tmp, "_trie_retry_null"); + break; + + case _trie_do_null_in_pair : + sprintf(tmp, "_trie_do_null_in_pair"); + break; + + case _trie_trust_null_in_pair : + sprintf(tmp, "_trie_trust_null_in_pair"); + break; + + case _trie_try_null_in_pair : + sprintf(tmp, "_tri_try_null_in_paire"); + break; + + case _trie_retry_null_in_pair : + sprintf(tmp, "_trie_retry_null_in_pair"); + break; + + case _trie_do_pair : + sprintf(tmp, "_trie_do_pair"); + break; + + case _trie_trust_pair : + sprintf(tmp, "_trie_trust_pair"); + break; + + case _trie_try_pair : + sprintf(tmp, "_trie_try_pair"); + break; + + case _trie_retry_pair : + sprintf(tmp, "_trie_retry_pair"); + break; + + case _trie_do_appl : + sprintf(tmp, "_trie_do_appl"); + break; + + case _trie_trust_appl : + sprintf(tmp, "_trie_trust_appl"); + break; + + case _trie_try_appl : + sprintf(tmp, "_trie_try_appl"); + break; + + case _trie_retry_appl : + sprintf(tmp, "_trie_retry_appl"); + break; + + case _trie_do_appl_in_pair : + sprintf(tmp, "_trie_do_appl_in_pair"); + break; + + case _trie_trust_appl_in_pair : + sprintf(tmp, "_trie_trust_appl_in_pair"); + break; + + case _trie_try_appl_in_pair : + sprintf(tmp, "_trie_trty_appkl_in_pair"); + break; + + case _trie_retry_appl_in_pair : + sprintf(tmp, "_trie_retry_appl_in_pair"); + break; + + case _trie_do_extension : + sprintf(tmp, "_trie_do_extension"); + break; + + case _trie_trust_extension : + sprintf(tmp, "_trie_trust_extension"); + break; + + case _trie_try_extension : + sprintf(tmp, "_trie_try_extension"); + break; + + case _trie_retry_extension : + sprintf(tmp, "_trie_retry_extension"); + break; + + case _trie_do_double : + sprintf(tmp, "_trie_do_double"); + break; + + case _trie_trust_double : + sprintf(tmp, "_trie_trust_double"); + break; + + case _trie_try_double : + sprintf(tmp, "_trie_try_double"); + break; + + case _trie_retry_double : + sprintf(tmp, "_trie_retry_double"); + break; + + case _trie_do_longint : + sprintf(tmp, "_trie_do_longint"); + break; + + case _trie_trust_longint : + sprintf(tmp, "_trie_trust_longint"); + break; + + case _trie_try_longint : + sprintf(tmp, "_trie_try_longint"); + break; + + case _trie_retry_longint : + sprintf(tmp, "_trie_retry_longint"); + break; + + case _trie_do_gterm : + sprintf(tmp, "_trie_do_gterm"); + break; + + case _trie_trust_gterm : + sprintf(tmp, "_trie_trust_gterm"); + break; + + case _trie_try_gterm : + sprintf(tmp, "_trie_try_gterm"); + break; + + case _trie_retry_gterm : + sprintf(tmp, "_trie_retry_gterm"); + break; + +#endif + /* this instruction is hardwired */ +#ifdef YAPOR + case _or_last : + sprintf(tmp, "_or_last"); + break; + +#else + case _or_last : + sprintf(tmp, "_or_last"); + break; + +#endif + +#ifdef YAP_JIT + case _traced_Ystop : + sprintf(tmp, "_traced_Ystop"); + break; + + case _traced_Nstop : + sprintf(tmp, "_traced_Nstop"); + break; + + case _traced_try_me : + sprintf(tmp, "_traced_try_me"); + break; + + case _traced_retry_me : + sprintf(tmp, "_traced_retry_me"); + break; + + case _traced_trust_me : + sprintf(tmp, "_traced_trust_me"); + break; + + case _traced_enter_profiling : + sprintf(tmp, "_traced_enter_profiling"); + break; + + case _traced_retry_profiled : + sprintf(tmp, "_traced_retry_profiled"); + break; + + case _traced_profiled_retry_me : + sprintf(tmp, "_traced_profiled_retry_me"); + break; + + case _traced_profiled_trust_me : + sprintf(tmp, "_traced_profiled_trust_me"); + break; + + case _traced_profiled_retry_logical : + sprintf(tmp, "_traced_profiled_retry_logical"); + break; + + case _traced_profiled_trust_logical : + sprintf(tmp, "_traced_profiled_trust_logical"); + break; + + case _traced_count_call : + sprintf(tmp, "_traced_count_call"); + break; + + case _traced_count_retry : + sprintf(tmp, "_traced_count_retry"); + break; + + case _traced_count_retry_me : + sprintf(tmp, "_traced_count_retry_me"); + break; + + case _traced_count_trust_me : + sprintf(tmp, "_traced_count_trust_me"); + break; + + case _traced_count_retry_logical : + sprintf(tmp, "_traced_count_retry_logical"); + break; + + case _traced_count_trust_logical : + sprintf(tmp, "_traced_count_trust_logical"); + break; + + case _traced_lock_lu : + sprintf(tmp, "_traced_lock_lu"); + break; + + case _traced_unlock_lu : + sprintf(tmp, "_traced_unlock_lu"); + break; + + case _traced_alloc_for_logical_pred : + sprintf(tmp, "_traced_alloc_for_logical_pred"); + break; + + case _traced_copy_idb_term : + sprintf(tmp, "_traced_copy_idb_term"); + break; + + case _traced_unify_idb_term : + sprintf(tmp, "_traced_unify_idb_term"); + break; + + case _traced_ensure_space : + sprintf(tmp, "_traced_ensure_space"); + break; + + case _traced_spy_or_trymark : + sprintf(tmp, "_traced_spy_or_trymark"); + break; + + case _traced_try_and_mark : + sprintf(tmp, "_traced_try_and_mark"); + break; + + case _traced_count_retry_and_mark : + sprintf(tmp, "_traced_count_retry_and_mark"); + break; + + case _traced_profiled_retry_and_mark : + sprintf(tmp, "_traced_profiled_retry_and_mark"); + break; + + case _traced_retry_and_mark : + sprintf(tmp, "_traced_retry_and_mark"); + break; + + case _traced_trust_fail : + sprintf(tmp, "_traced_trust_fail"); + break; + + case _traced_op_fail : + sprintf(tmp, "_traced_op_fail"); + break; + + case _traced_cut : + sprintf(tmp, "_traced_cut"); + break; + + case _traced_cut_t : + sprintf(tmp, "_traced_cut_t"); + break; + + case _traced_cut_e : + sprintf(tmp, "_traced_cut_e"); + break; + + case _traced_save_b_x : + sprintf(tmp, "_traced_save_b_x"); + break; + + case _traced_save_b_y : + sprintf(tmp, "_traced_save_b_y"); + break; + + case _traced_commit_b_x : + sprintf(tmp, "_traced_commit_b_x"); + break; + + case _traced_commit_b_y : + sprintf(tmp, "_traced_commit_b_y"); + break; + + case _traced_execute : + sprintf(tmp, "_traced_execute"); + break; + + case _traced_dexecute : + sprintf(tmp, "_traced_dexecute"); + break; + + case _traced_fcall : + sprintf(tmp, "_traced_fcall"); + break; + + case _traced_call : + sprintf(tmp, "_traced_call"); + break; + + case _traced_procceed : + sprintf(tmp, "_traced_procceed"); + break; + + case _traced_allocate : + sprintf(tmp, "_traced_allocate"); + break; + + case _traced_deallocate : + sprintf(tmp, "_traced_deallocate"); + break; + +#ifdef BEAM + case _traced_retry_eam : + sprintf(tmp, "_traced_retry_eam"); + break; + +#endif +#ifdef BEAM + case _traced_run_eam : + sprintf(tmp, "_traced_run_eam"); + break; + +#endif + case _traced_get_x_var : + sprintf(tmp, "_traced_get_x_var"); + break; + + case _traced_get_y_var : + sprintf(tmp, "_traced_get_y_var"); + break; + + case _traced_get_yy_var : + sprintf(tmp, "_traced_get_yy_var"); + break; + + case _traced_get_x_val : + sprintf(tmp, "_traced_get_x_val"); + break; + + case _traced_get_y_val : + sprintf(tmp, "_traced_get_y_val"); + break; + + case _traced_get_atom : + sprintf(tmp, "_traced_get_atom"); + break; + + case _traced_get_2atoms : + sprintf(tmp, "_traced_get_2atoms"); + break; + + case _traced_get_3atoms : + sprintf(tmp, "_traced_get_3atoms"); + break; + + case _traced_get_4atoms : + sprintf(tmp, "_traced_get_4atoms"); + break; + + case _traced_get_5atoms : + sprintf(tmp, "_traced_get_5atoms"); + break; + + case _traced_get_6atoms : + sprintf(tmp, "_traced_get_6atoms"); + break; + + case _traced_get_list : + sprintf(tmp, "_traced_get_list"); + break; + + case _traced_get_struct : + sprintf(tmp, "_traced_get_struct"); + break; + + case _traced_get_float : + sprintf(tmp, "_traced_get_float"); + break; + + case _traced_get_longint : + sprintf(tmp, "_traced_get_longint"); + break; + + case _traced_get_bigint : + sprintf(tmp, "_traced_get_bigint"); + break; + + case _traced_get_dbterm : + sprintf(tmp, "_traced_get_dbterm"); + break; + + case _traced_glist_valx : + sprintf(tmp, "_traced_glist_valx"); + break; + + case _traced_glist_valy : + sprintf(tmp, "_traced_glist_valy"); + break; + + case _traced_gl_void_varx : + sprintf(tmp, "_traced_gl_void_varx"); + break; + + case _traced_gl_void_vary : + sprintf(tmp, "_traced_gl_void_vary"); + break; + + case _traced_gl_void_valx : + sprintf(tmp, "_traced_gl_void_valx"); + break; + + case _traced_gl_void_valy : + sprintf(tmp, "_traced_gl_void_valy"); + break; + + case _traced_unify_x_var : + sprintf(tmp, "_traced_unify_x_var"); + break; + + case _traced_unify_x_var_write : + sprintf(tmp, "_traced_unify_x_var_write"); + break; + + case _traced_unify_l_x_var : + sprintf(tmp, "_traced_unify_l_x_var"); + break; + + case _traced_unify_l_x_var_write : + sprintf(tmp, "_traced_unify_l_x_var_write"); + break; + + case _traced_unify_x_var2 : + sprintf(tmp, "_traced_unify_x_var2"); + break; + + case _traced_unify_x_var2_write : + sprintf(tmp, "_traced_unify_x_var2_write"); + break; + + case _traced_unify_l_x_var2 : + sprintf(tmp, "_traced_unify_l_x_var2"); + break; + + case _traced_unify_l_x_var2_write : + sprintf(tmp, "_traced_unify_l_x_var2_write"); + break; + + case _traced_unify_y_var : + sprintf(tmp, "_traced_unify_y_var"); + break; + + case _traced_unify_y_var_write : + sprintf(tmp, "_traced_unify_y_var_write"); + break; + + case _traced_unify_l_y_var : + sprintf(tmp, "_traced_unify_l_y_var"); + break; + + case _traced_unify_l_y_var_write : + sprintf(tmp, "_traced_unify_l_y_var_write"); + break; + + case _traced_unify_x_val : + sprintf(tmp, "_traced_unify_x_val"); + break; + + case _traced_unify_x_val_write : + sprintf(tmp, "_traced_unify_x_val_write"); + break; + + case _traced_unify_l_x_val : + sprintf(tmp, "_traced_unify_l_x_val"); + break; + + case _traced_unify_l_x_val_write : + sprintf(tmp, "_traced_uify_l_x_val_write"); + break; + + case _traced_unify_y_val : + sprintf(tmp, "_traced_unify_y_val"); + break; + + case _traced_unify_y_val_write : + sprintf(tmp, "_traced_unify_y_val_write"); + break; + + case _traced_unify_l_y_val : + sprintf(tmp, "_traced_unify_l_y_val"); + break; + + case _traced_unify_l_y_val_write : + sprintf(tmp, "_traced_unify_l_y_val_write"); + break; + + case _traced_unify_x_loc : + sprintf(tmp, "_traced_unify_x_loc"); + break; + + case _traced_unify_x_loc_write : + sprintf(tmp, "_traced_unify_x_loc_write"); + break; + + case _traced_unify_l_x_loc : + sprintf(tmp, "_traced_unify_l_x_loc"); + break; + + case _traced_unify_l_x_loc_write : + sprintf(tmp, "_traced_unify_l_x_loc_write"); + break; + + case _traced_unify_y_loc : + sprintf(tmp, "_traced_unify_y_loc"); + break; + + case _traced_unify_y_loc_write : + sprintf(tmp, "_traced_unify_y_loc_write"); + break; + + case _traced_unify_l_y_loc : + sprintf(tmp, "_traced_unify_l_y_loc"); + break; + + case _traced_unify_l_y_loc_write : + sprintf(tmp, "_traced_unify_l_y_loc_write"); + break; + + case _traced_unify_void : + sprintf(tmp, "_traced_unify_void"); + break; + + case _traced_unify_void_write : + sprintf(tmp, "_traced_unify_void_write"); + break; + + case _traced_unify_l_void : + sprintf(tmp, "_traced_unify_l_void"); + break; + + case _traced_unify_l_void_write : + sprintf(tmp, "_traced_unify_l_void_write"); + break; + + case _traced_unify_n_voids : + sprintf(tmp, "_traced_unify_n_voids"); + break; + + case _traced_unify_n_voids_write : + sprintf(tmp, "_traced_unify_n_voids_write"); + break; + + case _traced_unify_l_n_voids : + sprintf(tmp, "_traced_unify_l_n_voids"); + break; + + case _traced_unify_l_n_voids_write : + sprintf(tmp, "_traced_unify_l_n_voids_write"); + break; + + case _traced_unify_atom : + sprintf(tmp, "_traced_unify_atom"); + break; + + case _traced_unify_atom_write : + sprintf(tmp, "_traced_unify_atom_write"); + break; + + case _traced_unify_l_atom : + sprintf(tmp, "_traced_unify_l_atom"); + break; + + case _traced_unify_l_atom_write : + sprintf(tmp, "_traced_unify_l_atom_write"); + break; + + case _traced_unify_n_atoms : + sprintf(tmp, "_traced_unify_n_atoms"); + break; + + case _traced_unify_n_atoms_write : + sprintf(tmp, "_traced_unify_n_atoms_write"); + break; + + case _traced_unify_float : + sprintf(tmp, "_traced_unify_float"); + break; + + case _traced_unify_float_write : + sprintf(tmp, "_traced_unify_float_write"); + break; + + case _traced_unify_l_float : + sprintf(tmp, "_traced_unify_l_float"); + break; + + case _traced_unify_l_float_write : + sprintf(tmp, "_traced_unify_l_float_write"); + break; + + case _traced_unify_longint : + sprintf(tmp, "_traced_unify_longint"); + break; + + case _traced_unify_longint_write : + sprintf(tmp, "_traced_unify_longint_write"); + break; + + case _traced_unify_l_longint : + sprintf(tmp, "_traced_unify_l_longint"); + break; + + case _traced_unify_l_longint_write : + sprintf(tmp, "_traced_unify_l_longint_write"); + break; + + case _traced_unify_bigint : + sprintf(tmp, "_traced_unify_bigint"); + break; + + case _traced_unify_l_bigint : + sprintf(tmp, "_traced_unify_l_bigint"); + break; + + case _traced_unify_dbterm : + sprintf(tmp, "_traced_unify_dbterm"); + break; + + case _traced_unify_l_dbterm : + sprintf(tmp, "_traced_unify_l_dbterm"); + break; + + case _traced_unify_list : + sprintf(tmp, "_traced_unify_list"); + break; + + case _traced_unify_list_write : + sprintf(tmp, "_traced_unify_list_write"); + break; + + case _traced_unify_l_list : + sprintf(tmp, "_traced_unify_l_list"); + break; + + case _traced_unify_l_list_write : + sprintf(tmp, "_traced_unify_l_list_write"); + break; + + case _traced_unify_struct : + sprintf(tmp, "_traced_unify_struct"); + break; + + case _traced_unify_struct_write : + sprintf(tmp, "_traced_unify_struct_write"); + break; + + case _traced_unify_l_struc : + sprintf(tmp, "_traced_unify_l_struc"); + break; + + case _traced_unify_l_struc_write : + sprintf(tmp, "_traced_unify_l_struc_write"); + break; + + case _traced_put_x_var : + sprintf(tmp, "_traced_put_x_var"); + break; + + case _traced_put_y_var : + sprintf(tmp, "_traced_put_y_var"); + break; + + case _traced_put_x_val : + sprintf(tmp, "_traced_put_x_val"); + break; + + case _traced_put_xx_val : + sprintf(tmp, "_traced_put_xx_val"); + break; + + case _traced_put_y_val : + sprintf(tmp, "_traced_put_y_val"); + break; + + case _traced_put_y_vals : + sprintf(tmp, "_traced_put_y_vals"); + break; + + case _traced_put_unsafe : + sprintf(tmp, "_traced_put_unsafe"); + break; + + case _traced_put_atom : + sprintf(tmp, "_traced_put_atom"); + break; + + case _traced_put_dbterm : + sprintf(tmp, "_traced_put_dbterm"); + break; + + case _traced_put_bigint : + sprintf(tmp, "_traced_put_bigint"); + break; + + case _traced_put_float : + sprintf(tmp, "_traced_put_float"); + break; + + case _traced_put_longint : + sprintf(tmp, "_traced_put_longint"); + break; + + case _traced_put_list : + sprintf(tmp, "_traced_put_list"); + break; + + case _traced_put_struct : + sprintf(tmp, "_traced_put_struct"); + break; + + case _traced_write_x_var : + sprintf(tmp, "_traced_write_x_var"); + break; + + case _traced_write_void : + sprintf(tmp, "_traced_write_void"); + break; + + case _traced_write_n_voids : + sprintf(tmp, "_traced_write_n_voids"); + break; + + case _traced_write_y_var : + sprintf(tmp, "_traced_write_y_var"); + break; + + case _traced_write_x_val : + sprintf(tmp, "_traced_write_x_val"); + break; + + case _traced_write_x_loc : + sprintf(tmp, "_traced_write_x_loc"); + break; + + case _traced_write_y_val : + sprintf(tmp, "_traced_write_y_val"); + break; + + case _traced_write_y_loc : + sprintf(tmp, "_traced_write_y_loc"); + break; + + case _traced_write_atom : + sprintf(tmp, "_traced_write_atom"); + break; + + case _traced_write_bigint : + sprintf(tmp, "_traced_write_bigint"); + break; + + case _traced_write_dbterm : + sprintf(tmp, "_traced_write_dbterm"); + break; + + case _traced_write_float : + sprintf(tmp, "_traced_write_float"); + break; + + case _traced_write_longint : + sprintf(tmp, "_traced_write_longint"); + break; + + case _traced_write_n_atoms : + sprintf(tmp, "_traced_write_n_atoms"); + break; + + case _traced_write_list : + sprintf(tmp, "_traced_write_list"); + break; + + case _traced_write_l_list : + sprintf(tmp, "_traced_write_l_list"); + break; + + case _traced_write_struct : + sprintf(tmp, "_traced_write_struct"); + break; + + case _traced_write_l_struc : + sprintf(tmp, "_traced_write_l_struc"); + break; + + case _traced_save_pair_x : + sprintf(tmp, "_traced_save_pair_x"); + break; + + case _traced_save_pair_x_write : + sprintf(tmp, "_traced_save_pair_x_write"); + break; + + case _traced_save_pair_y : + sprintf(tmp, "_traced_save_pair_y"); + break; + + case _traced_save_pair_y_write : + sprintf(tmp, "_traced_save_pair_y_write"); + break; + + case _traced_save_appl_x : + sprintf(tmp, "_traced_save_appl_x"); + break; + + case _traced_save_appl_x_write : + sprintf(tmp, "_traced_save_appl_x_write"); + break; + + case _traced_save_appl_y : + sprintf(tmp, "_traced_save_appl_y"); + break; + + case _traced_save_appl_y_write : + sprintf(tmp, "_traced_save_appl_y_write"); + break; + + case _traced_jump : + sprintf(tmp, "_traced_jump"); + break; + + case _traced_move_back : + sprintf(tmp, "_traced_move_back"); + break; + + case _traced_skip : + sprintf(tmp, "_traced_skip"); + break; + + case _traced_either : + sprintf(tmp, "_traced_either"); + break; + + case _traced_or_else : + sprintf(tmp, "_traced_or_else"); + break; + + case _traced_pop_n : + sprintf(tmp, "_traced_pop_n"); + break; + + case _traced_pop : + sprintf(tmp, "_traced_pop"); + break; + + case _traced_call_cpred : + sprintf(tmp, "_traced_call_cpred"); + break; + + case _traced_execute_cpred : + sprintf(tmp, "_traced_execute_cpred"); + break; + + case _traced_call_usercpred : + sprintf(tmp, "_traced_call_usercpred"); + break; + + case _traced_call_c_wfail : + sprintf(tmp, "_traced_call_x_wfail"); + break; + + case _traced_try_c : + sprintf(tmp, "_traced_try_c"); + break; + + case _traced_retry_c : + sprintf(tmp, "_traced_retry_c"); + break; + +#ifdef CUT_C + case _traced_cut_c : + sprintf(tmp, "_traced_cut_c"); + break; + +#endif + case _traced_try_userc : + sprintf(tmp, "_traced_try_userc"); + break; + + case _traced_retry_userc : + sprintf(tmp, "_traced_retry_userc"); + break; + +#ifdef CUT_C + case _traced_cut_userc : + sprintf(tmp, "_traced_cut_userc"); + break; + +#endif + case _traced_lock_pred : + sprintf(tmp, "_traced_lock_pred"); + break; + + case _traced_index_pred : + sprintf(tmp, "_traced_index_pred"); + break; + +#ifdef THREADS + case _traced_thread_local : + sprintf(tmp, "_traced_thread_local"); + break; + +#endif + case _traced_expand_index : + sprintf(tmp, "_traced_expand_index"); + break; + + case _traced_expand_clauses : + sprintf(tmp, "_traced_expand_clauses"); + break; + + case _traced_undef_p : + sprintf(tmp, "_traced_undef_p"); + break; + + case _traced_spy_pred : + sprintf(tmp, "_traced_spy_pred"); + break; + + case _traced_try_clause : + sprintf(tmp, "_traced_try_clause"); + break; + + case _traced_try_clause2 : + sprintf(tmp, "_traced_try_clause2"); + break; + + case _traced_try_clause3 : + sprintf(tmp, "_traced_try_clause3"); + break; + + case _traced_try_clause4 : + sprintf(tmp, "_traced_try_clause4"); + break; + + case _traced_retry : + sprintf(tmp, "_traced_retry"); + break; + + case _traced_retry2 : + sprintf(tmp, "_traced_retry2"); + break; + + case _traced_retry3 : + sprintf(tmp, "_traced_retry3"); + break; + + case _traced_retry4 : + sprintf(tmp, "_traced_retry4"); + break; + + case _traced_trust : + sprintf(tmp, "_traced_trust"); + break; + + case _traced_try_in : + sprintf(tmp, "_traced_try_in"); + break; + + case _traced_enter_lu_pred : + sprintf(tmp, "_traced_enter_lu_pred"); + break; + + case _traced_try_logical : + sprintf(tmp, "_traced_try_logical"); + break; + + case _traced_retry_logical : + sprintf(tmp, "_traced_retry_logical"); + break; + + case _traced_trust_logical : + sprintf(tmp, "_traced_trust_logical"); + break; + + case _traced_user_switch : + sprintf(tmp, "_traced_user_switch"); + break; + + case _traced_switch_on_type : + sprintf(tmp, "_traced_switch_on_type"); + break; + + case _traced_switch_list_nl : + sprintf(tmp, "_traced_switch_list_nl"); + break; + + case _traced_switch_on_arg_type : + sprintf(tmp, "_traced_switch_on_arg_type"); + break; + + case _traced_switch_on_sub_arg_type : + sprintf(tmp, "_traced_switch_on_sub_arg_type"); + break; + + case _traced_jump_if_var : + sprintf(tmp, "_traced_jump_if_var"); + break; + + case _traced_jump_if_nonvar : + sprintf(tmp, "_traced_jump_if_nonvar"); + break; + + case _traced_if_not_then : + sprintf(tmp, "_traced_if_not_then"); + break; + + case _traced_switch_on_func : + sprintf(tmp, "_traced_switch_on_func"); + break; + + case _traced_switch_on_cons : + sprintf(tmp, "_traced_switch_on_cons"); + break; + + case _traced_go_on_func : + sprintf(tmp, "_traced_go_on_func"); + break; + + case _traced_go_on_cons : + sprintf(tmp, "_traced_go_on_cons"); + break; + + case _traced_if_func : + sprintf(tmp, "_traced_if_func"); + break; + + case _traced_if_cons : + sprintf(tmp, "_traced_if_cons"); + break; + + case _traced_index_dbref : + sprintf(tmp, "_traced_index_dbref"); + break; + + case _traced_index_blob : + sprintf(tmp, "_traced_index_blob"); + break; + + case _traced_index_long : + sprintf(tmp, "_traced_index_long"); + break; + + case _traced_jit_handler : + sprintf(tmp, "_traced_jit_handler"); + break; + + case _traced_p_atom_x : + sprintf(tmp, "_traced_p_atom_x"); + break; + + case _traced_p_atom_y : + sprintf(tmp, "_traced_p_atom_y"); + break; + + case _traced_p_atomic_x : + sprintf(tmp, "_traced_p_atomic_x"); + break; + + case _traced_p_atomic_y : + sprintf(tmp, "_traced_p_atomic_y"); + break; + + case _traced_p_integer_x : + sprintf(tmp, "_traced_p_integer_x"); + break; + + case _traced_p_integer_y : + sprintf(tmp, "_traced_p_integer_y"); + break; + + case _traced_p_nonvar_x : + sprintf(tmp, "_traced_p_nonvar_x"); + break; + + case _traced_p_nonvar_y : + sprintf(tmp, "_traced_p_nonvar_y"); + break; + + case _traced_p_number_x : + sprintf(tmp, "_traced_p_number_x"); + break; + + case _traced_p_number_y : + sprintf(tmp, "_traced_p_number_y"); + break; + + case _traced_p_var_x : + sprintf(tmp, "_traced_p_var_x"); + break; + + case _traced_p_var_y : + sprintf(tmp, "_traced_p_var_y"); + break; + + case _traced_p_db_ref_x : + sprintf(tmp, "_traced_p_db_ref_x"); + break; + + case _traced_p_db_ref_y : + sprintf(tmp, "_traced_p_db_ref_y"); + break; + + case _traced_p_primitive_x : + sprintf(tmp, "_traced_p_primitive_x"); + break; + + case _traced_p_primitive_y : + sprintf(tmp, "_traced_p_primitive_y"); + break; + + case _traced_p_compound_x : + sprintf(tmp, "_traced_p_compound_x"); + break; + + case _traced_p_compound_y : + sprintf(tmp, "_traced_p_compound_y"); + break; + + case _traced_p_float_x : + sprintf(tmp, "_traced_p_float_x"); + break; + + case _traced_p_float_y : + sprintf(tmp, "_traced_p_float_y"); + break; + + case _traced_p_plus_vv : + sprintf(tmp, "_traced_p_plus_vv"); + break; + + case _traced_p_plus_vc : + sprintf(tmp, "_traced_p_plus_vc"); + break; + + case _traced_p_plus_y_vv : + sprintf(tmp, "_traced_p_plus_y_vv"); + break; + + case _traced_p_plus_y_vc : + sprintf(tmp, "_traced_p_plus_y_vc"); + break; + + case _traced_p_minus_vv : + sprintf(tmp, "_traced_p_minus_vv"); + break; + + case _traced_p_minus_cv : + sprintf(tmp, "_traced_p_minus_cv"); + break; + + case _traced_p_minus_y_vv : + sprintf(tmp, "_traced_p_minus_y_vv"); + break; + + case _traced_p_minus_y_cv : + sprintf(tmp, "_traced_p_minus_y_cv"); + break; + + case _traced_p_times_vv : + sprintf(tmp, "_traced_p_times_vv"); + break; + + case _traced_p_times_vc : + sprintf(tmp, "_traced_p_times_vc"); + break; + + case _traced_p_times_y_vv : + sprintf(tmp, "_traced_p_times_y_vv"); + break; + + case _traced_p_times_y_vc : + sprintf(tmp, "_traced_p_times_y_vc"); + break; + + case _traced_p_div_vv : + sprintf(tmp, "_traced_p_div_vv"); + break; + + case _traced_p_div_vc : + sprintf(tmp, "_traced_p_div_vc"); + break; + + case _traced_p_div_cv : + sprintf(tmp, "_traced_p_div_cv"); + break; + + case _traced_p_div_y_vv : + sprintf(tmp, "_traced_p_div_y_vv"); + break; + + case _traced_p_div_y_vc : + sprintf(tmp, "_traced_p_div_y_vc"); + break; + + case _traced_p_div_y_cv : + sprintf(tmp, "_traced_p_div_y_cv"); + break; + + case _traced_p_and_vv : + sprintf(tmp, "_traced_p_and_vv"); + break; + + case _traced_p_and_vc : + sprintf(tmp, "_traced_p_and_vc"); + break; + + case _traced_p_and_y_vv : + sprintf(tmp, "_traced_p_and_y_vv"); + break; + + case _traced_p_and_y_vc : + sprintf(tmp, "_traced_p_and_y_vc"); + break; + + case _traced_p_or_vv : + sprintf(tmp, "_traced_p_or_vv"); + break; + + case _traced_p_or_vc : + sprintf(tmp, "_traced_p_or_vc"); + break; + + case _traced_p_or_y_vv : + sprintf(tmp, "_traced_p_or_y_vv"); + break; + + case _traced_p_or_y_vc : + sprintf(tmp, "_traced_p_or_y_vc"); + break; + + case _traced_p_sll_vv : + sprintf(tmp, "_traced_p_sll_vv"); + break; + + case _traced_p_sll_vc : + sprintf(tmp, "_traced_p_sll_vc"); + break; + + case _traced_p_sll_cv : + sprintf(tmp, "_traced_p_sll_cv"); + break; + + case _traced_p_sll_y_vv : + sprintf(tmp, "_traced_p_sll_y_vv"); + break; + + case _traced_p_sll_y_vc : + sprintf(tmp, "_traced_p_sll_y_vc"); + break; + + case _traced_p_sll_y_cv : + sprintf(tmp, "_traced_p_sll_y_cv"); + break; + + case _traced_p_slr_vv : + sprintf(tmp, "_traced_p_slr_vv"); + break; + + case _traced_p_slr_vc : + sprintf(tmp, "_traced_p_slr_vc"); + break; + + case _traced_p_slr_cv : + sprintf(tmp, "_traced_p_slr_cv"); + break; + + case _traced_p_slr_y_vv : + sprintf(tmp, "_traced_p_slr_y_vv"); + break; + + case _traced_p_slr_y_vc : + sprintf(tmp, "_traced_p_slr_y_vc"); + break; + + case _traced_p_slr_y_cv : + sprintf(tmp, "_traced_p_slr_y_cv"); + break; + + case _traced_call_bfunc_xx : + sprintf(tmp, "_traced_call_bfunc_xx"); + break; + + case _traced_call_bfunc_yx : + sprintf(tmp, "_traced_call_bfunc_yx"); + break; + + case _traced_call_bfunc_xy : + sprintf(tmp, "_traced_call_bfunc_xy"); + break; + + case _traced_call_bfunc_yy : + sprintf(tmp, "_traced_call_bfunc_yy"); + break; + + case _traced_p_equal : + sprintf(tmp, "_traced_p_equal"); + break; + + case _traced_p_dif : + sprintf(tmp, "_traced_p_dif"); + break; + + case _traced_p_eq : + sprintf(tmp, "_traced_p_eq"); + break; + + case _traced_p_arg_vv : + sprintf(tmp, "_traced_p_arg_vv"); + break; + + case _traced_p_arg_cv : + sprintf(tmp, "_traced_p_arg_cv"); + break; + + case _traced_p_arg_y_vv : + sprintf(tmp, "_traced_p_arg_y_vv"); + break; + + case _traced_p_arg_y_cv : + sprintf(tmp, "_traced_p_arg_y_cv"); + break; + + case _traced_p_func2s_vv : + sprintf(tmp, "_traced_p_func2s_vv"); + break; + + case _traced_p_func2s_cv : + sprintf(tmp, "_traced_p_func2s_cv"); + break; + + case _traced_p_func2s_vc : + sprintf(tmp, "_traced_p_func2s_vc"); + break; + + case _traced_p_func2s_y_vv : + sprintf(tmp, "_traced_p_func2s_y_vv"); + break; + + case _traced_p_func2s_y_cv : + sprintf(tmp, "_traced_p_func2s_y_cv"); + break; + + case _traced_p_func2s_y_vc : + sprintf(tmp, "_traced_p_func2s_y_vc"); + break; + + case _traced_p_func2f_xx : + sprintf(tmp, "_traced_p_func2f_xx"); + break; + + case _traced_p_func2f_xy : + sprintf(tmp, "_traced_p_func2f_xy"); + break; + + case _traced_p_func2f_yx : + sprintf(tmp, "_traced_p_func2f_yx"); + break; + + case _traced_p_func2f_yy : + sprintf(tmp, "_traced_p_func2f_yy"); + break; + + case _traced_p_functor : + sprintf(tmp, "_traced_p_functor"); + break; + + case _traced_p_execute2 : + sprintf(tmp, "_traced_p_execute2"); + break; + + case _traced_p_execute : + sprintf(tmp, "_traced_p_execute"); + break; + + case _traced_p_execute_tail : + sprintf(tmp, "_traced_p_execute_tail"); + break; + +#ifdef YAPOR + case _traced_getwork_first_time : + sprintf(tmp, "_traced_getwork_first_time"); + break; + + case _traced_getwork : + sprintf(tmp, "_traced_getwork"); + break; + + case _traced_getwork_seq : + sprintf(tmp, "_traced_getwork_seq"); + break; + + case _traced_sync : + sprintf(tmp, "_traced_sync"); + break; + +#endif +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + case _traced_clause_with_cut : + sprintf(tmp, "_traced_clause_with_cut"); + break; + +#endif + case _traced_table_load_answer : + sprintf(tmp, "_traced_table_load_answer"); + break; + + case _traced_table_try_answer : + sprintf(tmp, "_traced_table_try_answer"); + break; + + case _traced_table_try_single : + sprintf(tmp, "_traced_table_try_single"); + break; + + case _traced_table_try_me : + sprintf(tmp, "_traced_table_try_me"); + break; + + case _traced_table_try : + sprintf(tmp, "_traced_table_try"); + break; + + case _traced_table_retry_me : + sprintf(tmp, "_traced_table_retry_me"); + break; + + case _traced_table_retry : + sprintf(tmp, "_traced_table_retry"); + break; + + case _traced_table_trust_me : + sprintf(tmp, "_traced_table_trust_me"); + break; + + case _traced_table_trust : + sprintf(tmp, "_traced_table_trust"); + break; + + case _traced_table_new_answer : + sprintf(tmp, "_traced_table_new_answer"); + break; + + case _traced_table_answer_resolution : + sprintf(tmp, "_traced_table_answer_resolution"); + break; + + case _traced_table_completion : + sprintf(tmp, "_traced_table_completion"); + break; + +#ifdef THREADS_CONSUMER_SHARING + case _traced_table_answer_resolution_completion: + sprintf(tmp, "_traced_table_answer_resolution_completion"); + break; + +#endif + case _traced_trie_do_var : + sprintf(tmp, "_traced_trie_do_var"); + break; + + case _traced_trie_trust_var : + sprintf(tmp, "_traced_trie_trust_var"); + break; + + case _traced_trie_try_var : + sprintf(tmp, "_traced_trie_try_var"); + break; + + case _traced_trie_retry_var : + sprintf(tmp, "_traced_trie_retry_var"); + break; + + case _traced_trie_do_var_in_pair : + sprintf(tmp, "_traced_trie_do_var_in_pair"); + break; + + case _traced_trie_trust_var_in_pair : + sprintf(tmp, "_traced_trie_trust_var_in_pair"); + break; + + case _traced_trie_try_var_in_pair : + sprintf(tmp, "_traced_trie_try_var_in_pair"); + break; + + case _traced_trie_retry_var_in_pair : + sprintf(tmp, "_traced_trie_retry_var_in_pair"); + break; + + case _traced_trie_do_val : + sprintf(tmp, "_traced_trie_do_val"); + break; + + case _traced_trie_trust_val : + sprintf(tmp, "_traced_trie_trust_val"); + break; + + case _traced_trie_try_val : + sprintf(tmp, "_traced_trie_try_val"); + break; + + case _traced_trie_retry_val : + sprintf(tmp, "_traced_trie_retry_val"); + break; + + case _traced_trie_do_val_in_pair : + sprintf(tmp, "_traced_trie_do_val_in_pair"); + break; + + case _traced_trie_trust_val_in_pair : + sprintf(tmp, "_traced_trie_trust_val_in_pair"); + break; + + case _traced_trie_try_val_in_pair : + sprintf(tmp, "_traced_trie_try_val_in_pair"); + break; + + case _traced_trie_retry_val_in_pair : + sprintf(tmp, "_traced_trie_retry_val_in_pair"); + break; + + case _traced_trie_do_atom : + sprintf(tmp, "_traced_trie_do_atom"); + break; + + case _traced_trie_trust_atom : + sprintf(tmp, "_traced_trie_trust_atom"); + break; + + case _traced_trie_try_atom : + sprintf(tmp, "_traced_trie_try_atom"); + break; + + case _traced_trie_retry_atom : + sprintf(tmp, "_traced_trie_retry_atom"); + break; + + case _traced_trie_do_atom_in_pair : + sprintf(tmp, "_traced_trie_do_atom_in_pair"); + break; + + case _traced_trie_trust_atom_in_pair : + sprintf(tmp, "_traced_trie_trust_atom_in_pair"); + break; + + case _traced_trie_try_atom_in_pair : + sprintf(tmp, "_traced_trie_try_atom_in_pair"); + break; + + case _traced_trie_retry_atom_in_pair : + sprintf(tmp, "_traced_trie_retry_atom_in_pair"); + break; + + case _traced_trie_do_null : + sprintf(tmp, "_traced_trie_do_null"); + break; + + case _traced_trie_trust_null : + sprintf(tmp, "_traced_trie_trust_null"); + break; + + case _traced_trie_try_null : + sprintf(tmp, "_traced_trie_try_null"); + break; + + case _traced_trie_retry_null : + sprintf(tmp, "_traced_trie_retry_null"); + break; + + case _traced_trie_do_null_in_pair : + sprintf(tmp, "_traced_trie_do_null_in_pair"); + break; + + case _traced_trie_trust_null_in_pair : + sprintf(tmp, "_traced_trie_trust_null_in_pair"); + break; + + case _traced_trie_try_null_in_pair : + sprintf(tmp, "_traced_tri_try_null_in_paire"); + break; + + case _traced_trie_retry_null_in_pair : + sprintf(tmp, "_traced_trie_retry_null_in_pair"); + break; + + case _traced_trie_do_pair : + sprintf(tmp, "_traced_trie_do_pair"); + break; + + case _traced_trie_trust_pair : + sprintf(tmp, "_traced_trie_trust_pair"); + break; + + case _traced_trie_try_pair : + sprintf(tmp, "_traced_trie_try_pair"); + break; + + case _traced_trie_retry_pair : + sprintf(tmp, "_traced_trie_retry_pair"); + break; + + case _traced_trie_do_appl : + sprintf(tmp, "_traced_trie_do_appl"); + break; + + case _traced_trie_trust_appl : + sprintf(tmp, "_traced_trie_trust_appl"); + break; + + case _traced_trie_try_appl : + sprintf(tmp, "_traced_trie_try_appl"); + break; + + case _traced_trie_retry_appl : + sprintf(tmp, "_traced_trie_retry_appl"); + break; + + case _traced_trie_do_appl_in_pair : + sprintf(tmp, "_traced_trie_do_appl_in_pair"); + break; + + case _traced_trie_trust_appl_in_pair : + sprintf(tmp, "_traced_trie_trust_appl_in_pair"); + break; + + case _traced_trie_try_appl_in_pair : + sprintf(tmp, "_traced_trie_trty_appkl_in_pair"); + break; + + case _traced_trie_retry_appl_in_pair : + sprintf(tmp, "_traced_trie_retry_appl_in_pair"); + break; + + case _traced_trie_do_extension : + sprintf(tmp, "_traced_trie_do_extension"); + break; + + case _traced_trie_trust_extension : + sprintf(tmp, "_traced_trie_trust_extension"); + break; + + case _traced_trie_try_extension : + sprintf(tmp, "_traced_trie_try_extension"); + break; + + case _traced_trie_retry_extension : + sprintf(tmp, "_traced_trie_retry_extension"); + break; + + case _traced_trie_do_double : + sprintf(tmp, "_traced_trie_do_double"); + break; + + case _traced_trie_trust_double : + sprintf(tmp, "_traced_trie_trust_double"); + break; + + case _traced_trie_try_double : + sprintf(tmp, "_traced_trie_try_double"); + break; + + case _traced_trie_retry_double : + sprintf(tmp, "_traced_trie_retry_double"); + break; + + case _traced_trie_do_longint : + sprintf(tmp, "_traced_trie_do_longint"); + break; + + case _traced_trie_trust_longint : + sprintf(tmp, "_traced_trie_trust_longint"); + break; + + case _traced_trie_try_longint : + sprintf(tmp, "_traced_trie_try_longint"); + break; + + case _traced_trie_retry_longint : + sprintf(tmp, "_traced_trie_retry_longint"); + break; + + case _traced_trie_do_gterm : + sprintf(tmp, "_traced_trie_do_gterm"); + break; + + case _traced_trie_trust_gterm : + sprintf(tmp, "_traced_trie_trust_gterm"); + break; + + case _traced_trie_try_gterm : + sprintf(tmp, "_traced_trie_try_gterm"); + break; + + case _traced_trie_retry_gterm : + sprintf(tmp, "_traced_trie_retry_gterm"); + break; + +#endif + /* this instruction is hardwired */ +#ifdef YAPOR + case _traced_or_last : + sprintf(tmp, "_traced_or_last"); + break; + +#else + case _traced_or_last : + sprintf(tmp, "_traced_or_last"); + break; + +#endif + +#endif /* YAP_JIT */ + + } + strcpy(out, prepend_term); + strcat(out, tmp); + strcat(out, append_term); + } diff --git a/JIT/HPP/sprintblock.h b/JIT/HPP/sprintblock.h new file mode 100644 index 000000000..ee4b421af --- /dev/null +++ b/JIT/HPP/sprintblock.h @@ -0,0 +1,8033 @@ +static inline void +linear_sprint_block(YAP_BBs block, char **buf) { + switch(block) { + case ENTRY: break; + case YAAM_DEREF_BODY_D0PT0: + sprintf(*buf, "YAAM_DEREF_BODY_D0PT0"); + break; + case YAAM_DEREF_BODY_D0PT1: + sprintf(*buf, "YAAM_DEREF_BODY_D0PT1"); + break; + case YAAM_DEREF_BODY_D0S_SREG: + sprintf(*buf, "YAAM_DEREF_BODY_D0S_SREG"); + break; + case YAAM_DEREF_BODY_D1PT0: + sprintf(*buf, "YAAM_DEREF_BODY_D1PT0"); + break; + case YAAM_DEREF_BODY_D1PT1: + sprintf(*buf, "YAAM_DEREF_BODY_D1PT1"); + break; + case YAAM_FAIL: + sprintf(*buf, "YAAM_FAIL"); + break; + case YAAM_CHECK_TRAIL_TR: + sprintf(*buf, "YAAM_CHECK_TRAIL_TR"); + break; + case YAAM_UNIFYBOUND: + break; + case NoStackExecute_Exception: + sprintf(*buf, "NoStackExecute_Exception"); + break; + case NoStackDExecute_Exception: + sprintf(*buf, "NoStackDExecute_Exception"); + break; + case NoStackCall_Exception: + sprintf(*buf, "NoStackCall_Exception"); + break; + case NoStackDeallocate_Exception: + sprintf(*buf, "NoStackDeallocate_Exception"); + break; +#ifdef COROUTINING + case NoStackFail_Exception: + sprintf(*buf, "NoStackFail_Exception"); + break; +#endif + case NoStackCut_Exception: + sprintf(*buf, "NoStackCut_Exception"); + break; + case NoStackCutT_Exception: + sprintf(*buf, "NoStackCutT_Exception"); + break; + case NoStackCutE_Exception: + sprintf(*buf, "NoStackCutE_Exception"); + break; + case NoStackCommitX_Exception: + sprintf(*buf, "NoStackCommitX_Exception"); + break; + case NoStackCommitY_Exception: + sprintf(*buf, "NoStackCommitY_Exception"); + break; + case NoStackEither_Exception: + sprintf(*buf, "NoStackEither_Exception"); + break; + case NoStackPExecute_Exception: + sprintf(*buf, "NoStackPExecute_Exception"); + break; + case NoStackPExecute2_Exception: + sprintf(*buf, "NoStackPExecute2_Exception"); + break; + case NoStackPTExecute_Exception: + sprintf(*buf, "NoStackPTExecute_Exception"); + break; + case TRY_ME_INSTINIT: + sprintf(*buf, "TRY_ME_INSTINIT"); + break; +#ifdef YAPOR + case TRY_ME_YAPOR: + sprintf(*buf, "TRY_ME_YAPOR"); + break; +#endif + case TRY_ME_END: + sprintf(*buf, "TRY_ME_END"); + break; + case RETRY_ME_INSTINIT: + sprintf(*buf, "RETRY_ME_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY_ME_FROZEN: + sprintf(*buf, "RETRY_ME_FROZEN"); + break; +#else + case RETRY_ME_NOFROZEN: + sprintf(*buf, "RETRY_ME_NOFROZEN"); + break; +#endif + case RETRY_ME_END: + sprintf(*buf, "RETRY_ME_END"); + break; + case TRUST_ME_INSTINIT: + sprintf(*buf, "TRUST_ME_INSTINIT"); + break; + case TRUST_ME_IF: + sprintf(*buf, "TRUST_ME_IF"); + break; + case TRUST_ME_END: + sprintf(*buf, "TRUST_ME_END"); + break; + case ENTER_PROFILING_INSTINIT: + sprintf(*buf, "ENTER_PROFILING_INSTINIT"); + break; + case RETRY_PROFILED_INSTINIT: + sprintf(*buf, "RETRY_PROFILED_INSTINIT"); + break; + case PROFILED_RETRY_ME_INSTINIT: + sprintf(*buf, "PROFILED_RETRY_ME_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case PROFILED_RETRY_ME_FROZEN: + sprintf(*buf, "PROFILED_RETRY_ME_FROZEN"); + break; +#else + case PROFILED_RETRY_ME_NOFROZEN: + sprintf(*buf, "PROFILED_RETRY_ME_NOFROZEN"); + break; +#endif + case PROFILED_RETRY_ME_END: + sprintf(*buf, "PROFILED_RETRY_ME_END"); + break; + case PROFILED_TRUST_ME_INSTINIT: + sprintf(*buf, "PROFILED_TRUST_ME_INSTINIT"); + break; + case PROFILED_TRUST_ME_IF: + sprintf(*buf, "PROFILED_TRUST_ME_IF"); + break; + case PROFILED_TRUST_ME_END: + sprintf(*buf, "PROFILED_TRUST_ME_END"); + break; + case PROFILED_RETRY_LOGICAL_INSTINIT: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_INSTINIT"); + break; +#ifdef THREADS + case PROFILED_RETRY_LOGICAL_THREADS: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_THREADS"); + break; +#endif + case PROFILED_RETRY_LOGICAL_POST_THREADS: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_POST_THREADS"); + break; +#ifdef FROZEN_STACKS + case PROFILED_RETRY_LOGICAL_FROZEN: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_FROZEN"); + break; +#else + case PROFILED_RETRY_LOGICAL_NOFROZEN: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_NOFROZEN"); + break; +#endif + case PROFILED_RETRY_LOGICAL_END: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_END"); + break; + case PROFILED_TRUST_LOGICAL_INSTINIT: + sprintf(*buf, "PROFILED_TRUST_LOGICAL_INSTINIT"); + break; + case PROFILED_TRUST_LOGICAL_END: + sprintf(*buf, "PROFILED_TRUST_LOGICAL_END"); + break; + case COUNT_CALL_INSTINIT: + sprintf(*buf, "COUNT_CALL_INSTINIT"); + break; + case COUNT_CALL_MIDDLE: + sprintf(*buf, "COUNT_CALL_MIDDLE"); + break; + case COUNT_CALL_END: + sprintf(*buf, "COUNT_CALL_END"); + break; + case COUNT_RETRY_INSTINIT: + sprintf(*buf, "COUNT_RETRY_INSTINIT"); + break; + case COUNT_RETRY_MIDDLE: + sprintf(*buf, "COUNT_RETRY_MIDDLE"); + break; + case COUNT_RETRY_END: + sprintf(*buf, "COUNT_RETRY_END"); + break; + case COUNT_RETRY_ME_INSTINIT: + sprintf(*buf, "COUNT_RETRY_ME_INSTINIT"); + break; + case COUNT_RETRY_ME_MIDDLE: + sprintf(*buf, "COUNT_RETRY_ME_MIDDLE"); + break; + case COUNT_RETRY_ME_END: + sprintf(*buf, "COUNT_RETRY_ME_END"); + break; + case COUNT_TRUST_ME_INSTINIT: + sprintf(*buf, "COUNT_TRUST_ME_INSTINIT"); + break; + case COUNT_TRUST_ME_MIDDLE: + sprintf(*buf, "COUNT_TRUST_ME_MIDDLE"); + break; + case COUNT_TRUST_ME_END: + sprintf(*buf, "COUNT_TRUST_ME_END"); + break; + case COUNT_RETRY_LOGICAL_INSTINIT: + sprintf(*buf, "COUNT_RETRY_LOGICAL_INSTINIT"); + break; + case COUNT_RETRY_LOGICAL_END: + sprintf(*buf, "COUNT_RETRY_LOGICAL_END"); + break; + case COUNT_TRUST_LOGICAL_INSTINIT: + sprintf(*buf, "COUNT_TRUST_LOGICAL_INSTINIT"); + break; + case COUNT_TRUST_LOGICAL_END: + sprintf(*buf, "COUNT_TRUST_LOGICAL_END"); + break; + case LOCK_LU_INSTINIT: + sprintf(*buf, "LOCK_LU_INSTINIT"); + break; + case LOCK_LU_END: + sprintf(*buf, "LOCK_LU_END"); + break; + case UNLOCK_LU_INSTINIT: + sprintf(*buf, "UNLOCK_LU_INSTINIT"); + break; +#if defined(YAPOR) || defined(THREADS) + case UNLOCK_LU_YAPOR_THREADS: + sprintf(*buf, "UNLOCK_LU_YAPOR_THREADS"); + break; +#endif + case UNLOCK_LU_END: + sprintf(*buf, "UNLOCK_LU_END"); + break; + case ALLOC_FOR_LOGICAL_PRED_INSTINIT: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_INSTINIT"); + break; +#if MULTIPLE_STACKS + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS"); + break; +#if PARALLEL_YAP + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL"); + break; +#endif + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END"); + break; +#else + case ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT"); + break; + case ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF"); + break; +#endif + case ALLOC_FOR_LOGICAL_PRED_END: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_END"); + break; + case COPY_IDB_TERM_INSTINIT: + sprintf(*buf, "COPY_IDB_TERM_INSTINIT"); + break; + case COPY_IDB_TERM_END: + sprintf(*buf, "COPY_IDB_TERM_END"); + break; + case UNIFY_IDB_TERM_INSTINIT: + sprintf(*buf, "UNIFY_IDB_TERM_INSTINIT"); + break; + case UNIFY_IDB_TERM_END: + sprintf(*buf, "UNIFY_IDB_TERM_END"); + break; + case ENSURE_SPACE_INSTINIT: + sprintf(*buf, "ENSURE_SPACE_INSTINIT"); + break; + case ENSURE_SPACE_END: + sprintf(*buf, "ENSURE_SPACE_END"); + break; + case SPY_OR_TRYMARK_INSTINIT: + sprintf(*buf, "SPY_OR_TRYMARK_INSTINIT"); + break; + case TRY_AND_MARK_INSTINIT: + sprintf(*buf, "TRY_AND_MARK_INSTINIT"); + break; +#if defined(YAPOR) || defined(THREADS) +#ifdef YAPOR + case TRY_AND_MARK_YAPOR_THREADS_YAPOR: + sprintf(*buf, "TRY_AND_MARK_YAPOR_THREADS_YAPOR"); + break; +#endif + case TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF: + sprintf(*buf, "TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF"); + break; +#endif + case TRY_AND_MARK_NOYAPOR_NOTHREADS: + sprintf(*buf, "TRY_AND_MARK_NOYAPOR_NOTHREADS"); + break; +#ifdef YAPOR + case TRY_AND_MARK_SET_LOAD: + sprintf(*buf, "TRY_AND_MARK_SET_LOAD"); + break; +#endif + case TRY_AND_MARK_POST_SET_LOAD: + sprintf(*buf, "TRY_AND_MARK_POST_SET_LOAD"); + break; +#if MULTIPLE_STACKS + case TRY_AND_MARK_MULTIPLE_STACKS: + sprintf(*buf, "TRY_AND_MARK_MULTIPLE_STACKS"); + break; +#else + case TRY_AND_MARK_NOMULTIPLE_STACKS_IF: + sprintf(*buf, "TRY_AND_MARK_NOMULTIPLE_STACKS_IF"); + break; +#endif + case TRY_AND_MARK_END: + sprintf(*buf, "TRY_AND_MARK_END"); + break; + case COUNT_RETRY_AND_MARK_INSTINIT: + sprintf(*buf, "COUNT_RETRY_AND_MARK_INSTINIT"); + break; + case PROFILED_RETRY_AND_MARK_INSTINIT: + sprintf(*buf, "PROFILED_RETRY_AND_MARK_INSTINIT"); + break; + case RETRY_AND_MARK_INSTINIT: + sprintf(*buf, "RETRY_AND_MARK_INSTINIT"); + break; +#ifdef YAPOR + case RETRY_AND_MARK_YAPOR: + sprintf(*buf, "RETRY_AND_MARK_YAPOR"); + break; +#endif + case RETRY_AND_MARK_POST_YAPOR: + sprintf(*buf, "RETRY_AND_MARK_POST_YAPOR"); + break; +#ifdef FROZEN_STACKS + case RETRY_AND_MARK_FROZEN: + sprintf(*buf, "RETRY_AND_MARK_FROZEN"); + break; +#else + case RETRY_AND_MARK_NOFROZEN: + sprintf(*buf, "RETRY_AND_MARK_NOFROZEN"); + break; +#endif + case RETRY_AND_MARK_POST_FROZEN: + sprintf(*buf, "RETRY_AND_MARK_POST_FROZEN"); + break; +#if MULTIPLE_STACKS + case RETRY_AND_MARK_MULTIPLE_STACKS: + sprintf(*buf, "RETRY_AND_MARK_MULTIPLE_STACKS"); + break; +#else + case RETRY_AND_MARK_NOMULTIPLE_STACKS_IF: + sprintf(*buf, "RETRY_AND_MARK_NOMULTIPLE_STACKS_IF"); + break; +#endif + case RETRY_AND_MARK_END: + sprintf(*buf, "RETRY_AND_MARK_END"); + break; + case TRUST_FAIL_INSTINIT: + sprintf(*buf, "TRUST_FAIL_INSTINIT"); + break; +#ifdef CUT_C + case TRUST_FAIL_CUT_C: + sprintf(*buf, "TRUST_FAIL_CUT_C"); + break; +#endif +#ifdef YAPOR + case TRUST_FAIL_YAPOR: + sprintf(*buf, "TRUST_FAIL_YAPOR"); + break; +#endif + case TRUST_FAIL_NOYAPOR: + sprintf(*buf, "TRUST_FAIL_NOYAPOR"); + break; +#ifdef YAPOR + case LBL_SHARED_FAIL: + sprintf(*buf, "LBL_SHARED_FAIL"); + break; +#endif + case OP_FAIL_INSTINIT: + sprintf(*buf, "OP_FAIL_INSTINIT"); + break; + case LBL_FAIL_INSTINIT: + sprintf(*buf, "LBL_FAIL_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case LBL_FAIL_LOW_LEVEL_TRACER: + sprintf(*buf, "LBL_FAIL_LOW_LEVEL_TRACER"); + break; +#endif + case LBL_FAIL_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "LBL_FAIL_POST_LOW_LEVEL_TRACER"); + break; + case LBL_FAIL_VARTERM: + sprintf(*buf, "LBL_FAIL_VARTERM"); + break; + case LBL_FAIL_PAIRTERM_INIT: + sprintf(*buf, "LBL_FAIL_PAIRTERM_INIT"); + break; + case LBL_FAIL_PAIRTERM_END_APPL: + sprintf(*buf, "LBL_FAIL_PAIRTERM_END_APPL"); + break; + case LBL_FAIL_END: + sprintf(*buf, "LBL_FAIL_END"); + break; + case CUT_INSTINIT: + sprintf(*buf, "CUT_INSTINIT"); + break; +#ifdef COROUTINING + case CUT_COROUTINING: + sprintf(*buf, "CUT_COROUTINING"); + break; +#endif + case CUT_NOCOROUTINING: + sprintf(*buf, "CUT_NOCOROUTINING"); + break; + case CUT_T_INSTINIT: + sprintf(*buf, "CUT_T_INSTINIT"); + break; +#ifdef COROUTINING + case CUT_T_COROUTINING: + sprintf(*buf, "CUT_T_COROUTINING"); + break; +#endif + case CUT_T_NOCOROUTINING: + sprintf(*buf, "CUT_T_NOCOROUTINING"); + break; + case CUT_E_INSTINIT: + sprintf(*buf, "CUT_E_INSTINIT"); + break; +#ifdef COROUTINING + case CUT_E_COROUTINING: + sprintf(*buf, "CUT_E_COROUTINING"); + break; +#endif + case CUT_E_NOCOROUTINING: + sprintf(*buf, "CUT_E_NOCOROUTINING"); + break; + case SAVE_B_X_INSTINIT: + sprintf(*buf, "SAVE_B_X_INSTINIT"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case SAVE_B_X_YSBA_FROZEN: + sprintf(*buf, "SAVE_B_X_YSBA_FROZEN"); + break; +#else + case SAVE_B_X_NOYSBA_NOFROZEN: + sprintf(*buf, "SAVE_B_X_NOYSBA_NOFROZEN"); + break; +#endif + case SAVE_B_X_END: + sprintf(*buf, "SAVE_B_X_END"); + break; + case SAVE_B_Y_INSTINIT: + sprintf(*buf, "SAVE_B_Y_INSTINIT"); + break; +#if defined(YAPOR_SBA) + case SAVE_B_Y_YSBA: + sprintf(*buf, "SAVE_B_Y_YSBA"); + break; +#else + case SAVE_B_Y_NOYSBA: + sprintf(*buf, "SAVE_B_Y_NOYSBA"); + break; +#endif + case SAVE_B_Y_END: + sprintf(*buf, "SAVE_B_Y_END"); + break; + case COMMIT_B_X_INSTINIT: + sprintf(*buf, "COMMIT_B_X_INSTINIT"); + break; + case COMMIT_B_X_DO_COMMIT_B_X: + sprintf(*buf, "COMMIT_B_X_DO_COMMIT_B_X"); + break; + case COMMIT_B_X_COMMIT_B_X_NVAR: + sprintf(*buf, "COMMIT_B_X_COMMIT_B_X_NVAR"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case COMMIT_B_X_YSBA_FROZEN: + sprintf(*buf, "COMMIT_B_X_YSBA_FROZEN"); + break; +#else + case COMMIT_B_X_NOYSBA_NOFROZEN: + sprintf(*buf, "COMMIT_B_X_NOYSBA_NOFROZEN"); + break; +#endif + case COMMIT_B_X_POST_YSBA_FROZEN: + sprintf(*buf, "COMMIT_B_X_POST_YSBA_FROZEN"); + break; + case COMMIT_B_X_END: + sprintf(*buf, "COMMIT_B_X_END"); + break; + case COMMIT_B_Y_INSTINIT: + sprintf(*buf, "COMMIT_B_Y_INSTINIT"); + break; + case COMMIT_B_Y_DO_COMMIT_B_Y: + sprintf(*buf, "COMMIT_B_Y_DO_COMMIT_B_Y"); + break; + case COMMIT_B_Y_COMMIT_B_Y_NVAR: + sprintf(*buf, "COMMIT_B_Y_COMMIT_B_Y_NVAR"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case COMMIT_B_Y_YSBA_FROZEN: + sprintf(*buf, "COMMIT_B_Y_YSBA_FROZEN"); + break; +#else + case COMMIT_B_Y_NOYSBA_NOFROZEN: + sprintf(*buf, "COMMIT_B_Y_NOYSBA_NOFROZEN"); + break; +#endif + case COMMIT_B_Y_POST_YSBA_FROZEN: + sprintf(*buf, "COMMIT_B_Y_POST_YSBA_FROZEN"); + break; + case COMMIT_B_Y_END: + sprintf(*buf, "COMMIT_B_Y_END"); + break; + case EXECUTE_INSTINIT: + sprintf(*buf, "EXECUTE_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case EXECUTE_LOW_LEVEL_TRACER: + sprintf(*buf, "EXECUTE_LOW_LEVEL_TRACER"); + break; +#endif + case EXECUTE_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "EXECUTE_POST_LOW_LEVEL_TRACER"); + break; + case EXECUTE_POST_NOCHECKING: + sprintf(*buf, "EXECUTE_POST_NOCHECKING"); + break; +#ifdef DEPTH_LIMIT + case EXECUTE_DEPTH_MINOR: + sprintf(*buf, "EXECUTE_DEPTH_MINOR"); + break; + case EXECUTE_DEPTH_MOFPRED: + sprintf(*buf, "EXECUTE_DEPTH_MOFPRED"); + break; + case EXECUTE_DEPTH_END: + sprintf(*buf, "EXECUTE_DEPTH_END"); + break; +#endif + case EXECUTE_END_END: + sprintf(*buf, "EXECUTE_END_END"); + break; + case DEXECUTE_INSTINIT: + sprintf(*buf, "DEXECUTE_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case DEXECUTE_LOW_LEVEL_TRACER: + sprintf(*buf, "DEXECUTE_LOW_LEVEL_TRACER"); + break; +#endif + case DEXECUTE_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "DEXECUTE_POST_LOW_LEVEL_TRACER"); + break; +#ifdef DEPTH_LIMIT + case DEXECUTE_DEPTH_MINOR: + sprintf(*buf, "DEXECUTE_DEPTH_MINOR"); + break; + case DEXECUTE_DEPTH_MOFPRED: + sprintf(*buf, "DEXECUTE_DEPTH_MOFPRED"); + break; + case DEXECUTE_DEPTH_END: + sprintf(*buf, "DEXECUTE_DEPTH_END"); + break; +#endif + case DEXECUTE_END_END: + sprintf(*buf, "DEXECUTE_END_END"); + break; + case FCALL_INST: + break; + case CALL_INSTINIT: + sprintf(*buf, "CALL_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case CALL_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_LOW_LEVEL_TRACER"); + break; +#endif + case CALL_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_POST_LOW_LEVEL_TRACER"); + break; + case CALL_POST_NO_CHECKING: + sprintf(*buf, "CALL_POST_NO_CHECKING"); + break; +#ifdef DEPTH_LIMIT + case CALL_DEPTH_MINOR: + sprintf(*buf, "CALL_DEPTH_MINOR"); + break; + case CALL_DEPTH_MOFPRED: + sprintf(*buf, "CALL_DEPTH_MOFPRED"); + break; + case CALL_DEPTH_END: + sprintf(*buf, "CALL_DEPTH_END"); + break; +#endif + case CALL_END_END: + sprintf(*buf, "CALL_END_END"); + break; + case PROCCEED_INSTINIT: + sprintf(*buf, "PROCCEED_INSTINIT"); + break; +#ifdef DEPTH_LIMIT + case PROCCEED_DEPTH: + sprintf(*buf, "PROCCEED_DEPTH"); + break; +#endif + case PROCCEED_END: + sprintf(*buf, "PROCCEED_END"); + break; + case ALLOCATE_INSTINIT: + sprintf(*buf, "ALLOCATE_INSTINIT"); + break; +#ifdef DEPTH_LIMIT + case ALLOCATE_DEPTH: + sprintf(*buf, "ALLOCATE_DEPTH"); + break; +#endif + case ALLOCATE_END: + sprintf(*buf, "ALLOCATE_END"); + break; + case DEALLOCATE_INSTINIT: + sprintf(*buf, "DEALLOCATE_INSTINIT"); + break; + case DEALLOCATE_POST_CHECK: + sprintf(*buf, "DEALLOCATE_POST_CHECK"); + break; +#ifdef DEPTH_LIMIT + case DEALLOCATE_DEPTH: + sprintf(*buf, "DEALLOCATE_DEPTH"); + break; +#endif + case DEALLOCATE_FROZEN: + sprintf(*buf, "DEALLOCATE_FROZEN"); + break; + case DEALLOCATE_POST_FROZEN: + sprintf(*buf, "DEALLOCATE_POST_FROZEN"); + break; + case DEALLOCATE_END: + sprintf(*buf, "DEALLOCATE_END"); + break; + case GET_X_VAR_INSTINIT: + sprintf(*buf, "GET_X_VAR_INSTINIT"); + break; + case GET_Y_VAR_INSTINIT: + sprintf(*buf, "GET_Y_VAR_INSTINIT"); + break; + case GET_YY_VAR_INSTINIT: + sprintf(*buf, "GET_YY_VAR_INSTINIT"); + break; + case GET_X_VAL_INSTINIT: + sprintf(*buf, "GET_X_VAL_INSTINIT"); + break; + case GET_X_VAL_GVALX_NONVAR: + sprintf(*buf, "GET_X_VAL_GVALX_NONVAR"); + break; + case GET_X_VAL_GVALX_NONVAR_NONVAR: + sprintf(*buf, "GET_X_VAL_GVALX_NONVAR_NONVAR"); + break; + case GET_X_VAL_GVALX_NONVAR_UNK: + sprintf(*buf, "GET_X_VAL_GVALX_NONVAR_UNK"); + break; + case GET_X_VAL_GVALX_UNK: + sprintf(*buf, "GET_X_VAL_GVALX_UNK"); + break; + case GET_X_VAL_GVALX_VAR_NONVAR: + sprintf(*buf, "GET_X_VAL_GVALX_VAR_NONVAR"); + break; + case GET_X_VAL_GVALX_VAR_UNK: + sprintf(*buf, "GET_X_VAL_GVALX_VAR_UNK"); + break; + case GET_Y_VAL_INSTINIT: + sprintf(*buf, "GET_Y_VAL_INSTINIT"); + break; + case GET_Y_VAL_GVALY_NONVAR: + sprintf(*buf, "GET_Y_VAL_GVALY_NONVAR"); + break; + case GET_Y_VAL_GVALY_NONVAR_NONVAR: + sprintf(*buf, "GET_Y_VAL_GVALY_NONVAR_NONVAR"); + break; + case GET_Y_VAL_GVALY_NONVAR_UNK: + sprintf(*buf, "GET_Y_VAL_GVALY_NONVAR_UNK"); + break; + case GET_Y_VAL_GVALY_UNK: + sprintf(*buf, "GET_Y_VAL_GVALY_UNK"); + break; + case GET_Y_VAL_GVALY_VAR_NONVAR: + sprintf(*buf, "GET_Y_VAL_GVALY_VAR_NONVAR"); + break; + case GET_Y_VAL_GVALY_VAR_UNK: + sprintf(*buf, "GET_Y_VAL_GVALY_VAR_UNK"); + break; + case GET_ATOM_INSTINIT: + sprintf(*buf, "GET_ATOM_INSTINIT"); + break; + case GET_ATOM_GATOM_NONVAR: + sprintf(*buf, "GET_ATOM_GATOM_NONVAR"); + break; + case GET_ATOM_GATOM_UNK: + sprintf(*buf, "GET_ATOM_GATOM_UNK"); + break; + case GET_2ATOMS_INSTINIT: + sprintf(*buf, "GET_2ATOMS_INSTINIT"); + break; + case GET_2ATOMS_GATOM_2UNK: + sprintf(*buf, "GET_2ATOMS_GATOM_2UNK"); + break; + case GET_2ATOMS_GATOM_2B: + sprintf(*buf, "GET_2ATOMS_GATOM_2B"); + break; + case GET_2ATOMS_GATOM_2BNONVAR: + sprintf(*buf, "GET_2ATOMS_GATOM_2BNONVAR"); + break; + case GET_2ATOMS_GATOM_2BUNK: + sprintf(*buf, "GET_2ATOMS_GATOM_2BUNK"); + break; + case GET_3ATOMS_INSTINIT: + sprintf(*buf, "GET_3ATOMS_INSTINIT"); + break; + case GET_3ATOMS_GATOM_3UNK: + sprintf(*buf, "GET_3ATOMS_GATOM_3UNK"); + break; + case GET_3ATOMS_GATOM_3B: + sprintf(*buf, "GET_3ATOMS_GATOM_3B"); + break; + case GET_3ATOMS_GATOM_3BUNK: + sprintf(*buf, "GET_3ATOMS_GATOM_3BUNK"); + break; + case GET_3ATOMS_GATOM_3C: + sprintf(*buf, "GET_3ATOMS_GATOM_3C"); + break; + case GET_3ATOMS_GATOM_3CNONVAR: + sprintf(*buf, "GET_3ATOMS_GATOM_3CNONVAR"); + break; + case GET_3ATOMS_GATOM_3CUNK: + sprintf(*buf, "GET_3ATOMS_GATOM_3CUNK"); + break; + case GET_4ATOMS_INSTINIT: + sprintf(*buf, "GET_4ATOMS_INSTINIT"); + break; + case GET_4ATOMS_GATOM_4UNK: + sprintf(*buf, "GET_4ATOMS_GATOM_4UNK"); + break; + case GET_4ATOMS_GATOM_4B: + sprintf(*buf, "GET_4ATOMS_GATOM_4B"); + break; + case GET_4ATOMS_GATOM_4BUNK: + sprintf(*buf, "GET_4ATOMS_GATOM_4BUNK"); + break; + case GET_4ATOMS_GATOM_4C: + sprintf(*buf, "GET_4ATOMS_GATOM_4C"); + break; + case GET_4ATOMS_GATOM_4CUNK: + sprintf(*buf, "GET_4ATOMS_GATOM_4CUNK"); + break; + case GET_4ATOMS_GATOM_4D: + sprintf(*buf, "GET_4ATOMS_GATOM_4D"); + break; + case GET_4ATOMS_GATOM_4DNONVAR: + sprintf(*buf, "GET_4ATOMS_GATOM_4DNONVAR"); + break; + case GET_4ATOMS_GATOM_4DUNK: + sprintf(*buf, "GET_4ATOMS_GATOM_4DUNK"); + break; + case GET_5ATOMS_INSTINIT: + sprintf(*buf, "GET_5ATOMS_INSTINIT"); + break; + case GET_5ATOMS_GATOM_5UNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5UNK"); + break; + case GET_5ATOMS_GATOM_5B: + sprintf(*buf, "GET_5ATOMS_GATOM_5B"); + break; + case GET_5ATOMS_GATOM_5BUNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5BUNK"); + break; + case GET_5ATOMS_GATOM_5C: + sprintf(*buf, "GET_5ATOMS_GATOM_5C"); + break; + case GET_5ATOMS_GATOM_5CUNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5CUNK"); + break; + case GET_5ATOMS_GATOM_5D: + sprintf(*buf, "GET_5ATOMS_GATOM_5D"); + break; + case GET_5ATOMS_GATOM_5DUNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5DUNK"); + break; + case GET_5ATOMS_GATOM_5E: + sprintf(*buf, "GET_5ATOMS_GATOM_5E"); + break; + case GET_5ATOMS_GATOM_5ENONVAR: + sprintf(*buf, "GET_5ATOMS_GATOM_5ENONVAR"); + break; + case GET_5ATOMS_GATOM_5EUNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5EUNK"); + break; + case GET_6ATOMS_INSTINIT: + sprintf(*buf, "GET_6ATOMS_INSTINIT"); + break; + case GET_6ATOMS_GATOM_6UNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6UNK"); + break; + case GET_6ATOMS_GATOM_6B: + sprintf(*buf, "GET_6ATOMS_GATOM_6B"); + break; + case GET_6ATOMS_GATOM_6BUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6BUNK"); + break; + case GET_6ATOMS_GATOM_6C: + sprintf(*buf, "GET_6ATOMS_GATOM_6C"); + break; + case GET_6ATOMS_GATOM_6CUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6CUNK"); + break; + case GET_6ATOMS_GATOM_6D: + sprintf(*buf, "GET_6ATOMS_GATOM_6D"); + break; + case GET_6ATOMS_GATOM_6DUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6DUNK"); + break; + case GET_6ATOMS_GATOM_6E: + sprintf(*buf, "GET_6ATOMS_GATOM_6E"); + break; + case GET_6ATOMS_GATOM_6EUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6EUNK"); + break; + case GET_6ATOMS_GATOM_6F: + sprintf(*buf, "GET_6ATOMS_GATOM_6F"); + break; + case GET_6ATOMS_GATOM_6FNONVAR: + sprintf(*buf, "GET_6ATOMS_GATOM_6FNONVAR"); + break; + case GET_6ATOMS_GATOM_6FUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6FUNK"); + break; + case GET_LIST_INSTINIT: + sprintf(*buf, "GET_LIST_INSTINIT"); + break; + case GET_LIST_GLIST_NONVAR: + sprintf(*buf, "GET_LIST_GLIST_NONVAR"); + break; + case GET_LIST_GLIST_UNK: + sprintf(*buf, "GET_LIST_GLIST_UNK"); + break; + case GET_STRUCT_INSTINIT: + sprintf(*buf, "GET_STRUCT_INSTINIT"); + break; + case GET_STRUCT_GSTRUCT_NONVAR: + sprintf(*buf, "GET_STRUCT_GSTRUCT_NONVAR"); + break; + case GET_STRUCT_GSTRUCT_UNK: + sprintf(*buf, "GET_STRUCT_GSTRUCT_UNK"); + break; + case GET_FLOAT_INSTINIT: + sprintf(*buf, "GET_FLOAT_INSTINIT"); + break; + case GET_FLOAT_GFLOAT_NONVAR: + sprintf(*buf, "GET_FLOAT_GFLOAT_NONVAR"); + break; + case GET_FLOAT_GFLOAT_UNK: + sprintf(*buf, "GET_FLOAT_GFLOAT_UNK"); + break; + case GET_LONGINT_INSTINIT: + sprintf(*buf, "GET_LONGINT_INSTINIT"); + break; + case GET_LONGINT_GLONGINT_NONVAR: + sprintf(*buf, "GET_LONGINT_GLONGINT_NONVAR"); + break; + case GET_LONGINT_GLONGINT_UNK: + sprintf(*buf, "GET_LONGINT_GLONGINT_UNK"); + break; +#ifdef USE_GMP + case GET_BIGINT_INSTINIT: + sprintf(*buf, "GET_BIGINT_INSTINIT"); + break; + case GET_BIGINT_GBIGINT_NONVAR: + sprintf(*buf, "GET_BIGINT_GBIGINT_NONVAR"); + break; + case GET_BIGINT_GBIGINT_UNK: + sprintf(*buf, "GET_BIGINT_GBIGINT_UNK"); + break; +#endif + case GET_DBTERM_INSTINIT: + sprintf(*buf, "GET_DBTERM_INSTINIT"); + break; + case GET_DBTERM_GDBTERM_NONVAR: + sprintf(*buf, "GET_DBTERM_GDBTERM_NONVAR"); + break; + case GET_DBTERM_GDBTERM_UNK: + sprintf(*buf, "GET_DBTERM_GDBTERM_UNK"); + break; + case GLIST_VALX_INSTINIT: + sprintf(*buf, "GLIST_VALX_INSTINIT"); + break; + case GLIST_VALX_GLIST_VALX_READ: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_READ"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_NONVAR"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR_NONVAR: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_NONVAR_NONVAR"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR_UNK: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_NONVAR_UNK"); + break; + case GLIST_VALX_GLIST_VALX_UNK: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_UNK"); + break; + case GLIST_VALX_GLIST_VALX_VAR_NONVAR: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_VAR_NONVAR"); + break; + case GLIST_VALX_GLIST_VALX_VAR_UNK: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_VAR_UNK"); + break; + case GLIST_VALX_GLIST_VALX_WRITE: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_WRITE"); + break; + case GLIST_VALY_INSTINIT: + sprintf(*buf, "GLIST_VALY_INSTINIT"); + break; + case GLIST_VALY_GLIST_VALY_READ: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_READ"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_NONVAR"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR_NONVAR: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_NONVAR_NONVAR"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR_UNK: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_NONVAR_UNK"); + break; + case GLIST_VALY_GLIST_VALY_UNK: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_UNK"); + break; + case GLIST_VALY_GLIST_VALY_VAR_NONVAR: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_VAR_NONVAR"); + break; + case GLIST_VALY_GLIST_VALY_VAR_UNK: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_VAR_UNK"); + break; + case GLIST_VALY_GLIST_VALY_WRITE: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_WRITE"); + break; + case GL_VOID_VARX_INSTINIT: + sprintf(*buf, "GL_VOID_VARX_INSTINIT"); + break; + case GL_VOID_VARX_GLIST_VOID_VARX_READ: + sprintf(*buf, "GL_VOID_VARX_GLIST_VOID_VARX_READ"); + break; + case GL_VOID_VARX_GLIST_VOID_VAR_WRITE: + sprintf(*buf, "GL_VOID_VARX_GLIST_VOID_VAR_WRITE"); + break; + case GL_VOID_VARY_INSTINIT: + sprintf(*buf, "GL_VOID_VARY_INSTINIT"); + break; + case GL_VOID_VARY_GLIST_VOID_VARY_READ: + sprintf(*buf, "GL_VOID_VARY_GLIST_VOID_VARY_READ"); + break; + case GL_VOID_VARY_GLIST_VOID_VARY_WRITE: + sprintf(*buf, "GL_VOID_VARY_GLIST_VOID_VARY_WRITE"); + break; + case GL_VOID_VALX_INSTINIT: + sprintf(*buf, "GL_VOID_VALX_INSTINIT"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_READ: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_READ"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_NONVAR"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_UNK: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_UNK"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_WRITE: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_WRITE"); + break; + case GL_VOID_VALY_INSTINIT: + sprintf(*buf, "GL_VOID_VALY_INSTINIT"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_READ: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_READ"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_NONVAR"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_UNK: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_UNK"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_WRITE: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_WRITE"); + break; + case UNIFY_X_VAR_INSTINIT: + sprintf(*buf, "UNIFY_X_VAR_INSTINIT"); + break; +#ifdef YAPOR_SBA + case UNIFY_X_VAR_YAPOR_SBA: + sprintf(*buf, "UNIFY_X_VAR_YAPOR_SBA"); + break; +#endif + case UNIFY_X_VAR_END: + sprintf(*buf, "UNIFY_X_VAR_END"); + break; + case UNIFY_X_VAR_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_X_VAR_WRITE_INSTINIT"); + break; + case UNIFY_L_X_VAR_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAR_INSTINIT"); + break; +#ifdef YAPOR_SBA + case UNIFY_L_X_VAR_YAPOR_SBA: + sprintf(*buf, "UNIFY_L_X_VAR_YAPOR_SBA"); + break; +#endif + case UNIFY_L_X_VAR_END: + sprintf(*buf, "UNIFY_L_X_VAR_END"); + break; + case UNIFY_L_X_VAR_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAR_WRITE_INSTINIT"); + break; + case UNIFY_X_VAR2_INSTINIT: + sprintf(*buf, "UNIFY_X_VAR2_INSTINIT"); + break; +#ifdef YAPOR_SBA + case UNIFY_X_VAR2_YAPOR_SBA: + sprintf(*buf, "UNIFY_X_VAR2_YAPOR_SBA"); + break; +#endif + case UNIFY_X_VAR2_END: + sprintf(*buf, "UNIFY_X_VAR2_END"); + break; + case UNIFY_X_VAR2_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_X_VAR2_WRITE_INSTINIT"); + break; + case UNIFY_L_X_VAR2_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAR2_INSTINIT"); + break; + case UNIFY_L_X_VAR2_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAR2_WRITE_INSTINIT"); + break; + case UNIFY_Y_VAR_INSTINIT: + sprintf(*buf, "UNIFY_Y_VAR_INSTINIT"); + break; + case UNIFY_Y_VAR_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_Y_VAR_WRITE_INSTINIT"); + break; + case UNIFY_L_Y_VAR_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_VAR_INSTINIT"); + break; + case UNIFY_L_Y_VAR_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_VAR_WRITE_INSTINIT"); + break; + case UNIFY_X_VAL_INSTINIT: + sprintf(*buf, "UNIFY_X_VAL_INSTINIT"); + break; + case UNIFY_X_VAL_UVALX_NONVAR: + sprintf(*buf, "UNIFY_X_VAL_UVALX_NONVAR"); + break; + case UNIFY_X_VAL_UVALX_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_X_VAL_UVALX_NONVAR_NONVAR"); + break; + case UNIFY_X_VAL_UVALX_NONVAR_UNK: + sprintf(*buf, "UNIFY_X_VAL_UVALX_NONVAR_UNK"); + break; + case UNIFY_X_VAL_UVALX_UNK: + sprintf(*buf, "UNIFY_X_VAL_UVALX_UNK"); + break; + case UNIFY_X_VAL_UVALX_VAR_NONVAR: + sprintf(*buf, "UNIFY_X_VAL_UVALX_VAR_NONVAR"); + break; + case UNIFY_X_VAL_UVALX_VAR_UNK: + sprintf(*buf, "UNIFY_X_VAL_UVALX_VAR_UNK"); + break; + case UNIFY_X_VAL_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_X_VAL_WRITE_INSTINIT"); + break; + case UNIFY_L_X_VAL_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAL_INSTINIT"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_NONVAR"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR_UNK: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_NONVAR_UNK"); + break; + case UNIFY_L_X_VAL_ULVALX_UNK: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_UNK"); + break; + case UNIFY_L_X_VAL_ULVALX_VAR_NONVAR: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_VAR_NONVAR"); + break; + case UNIFY_L_X_VAL_ULVALX_VAR_UNK: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_VAR_UNK"); + break; + case UNIFY_L_X_VAL_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAL_WRITE_INSTINIT"); + break; + case UNIFY_Y_VAL_INSTINIT: + sprintf(*buf, "UNIFY_Y_VAL_INSTINIT"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_NONVAR"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_NONVAR_NONVAR"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR_UNK: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_NONVAR_UNK"); + break; + case UNIFY_Y_VAL_UVALY_UNK: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_UNK"); + break; + case UNIFY_Y_VAL_UVALY_VAR_NONVAR: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_VAR_NONVAR"); + break; + case UNIFY_Y_VAL_UVALY_VAR_UNK: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_VAR_UNK"); + break; + case UNIFY_Y_VAL_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_Y_VAL_WRITE_INSTINIT"); + break; + case UNIFY_L_Y_VAL_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_VAL_INSTINIT"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_NONVAR"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK"); + break; + case UNIFY_L_Y_VAL_ULVALY_UNK: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_UNK"); + break; + case UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR"); + break; + case UNIFY_L_Y_VAL_ULVALY_VAR_UNK: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_VAR_UNK"); + break; + case UNIFY_L_Y_VAL_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_VAL_WRITE_INSTINIT"); + break; + case UNIFY_X_LOC_INSTINIT: + sprintf(*buf, "UNIFY_X_LOC_INSTINIT"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_NONVAR"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK"); + break; + case UNIFY_X_LOC_UVALX_LOC_UNK: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_UNK"); + break; + case UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR"); + break; + case UNIFY_X_LOC_UVALX_LOC_VAR_UNK: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_VAR_UNK"); + break; + case UNIFY_X_LOC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_X_LOC_WRITE_INSTINIT"); + break; + case UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR: + sprintf(*buf, "UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR"); + break; + case UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK: + sprintf(*buf, "UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK"); + break; + case UNIFY_L_X_LOC_INSTINIT: + sprintf(*buf, "UNIFY_L_X_LOC_INSTINIT"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_NONVAR"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_UNK: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_UNK"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK"); + break; + case UNIFY_L_X_LOC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_X_LOC_WRITE_INSTINIT"); + break; + case UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR: + sprintf(*buf, "UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR"); + break; + case UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK: + sprintf(*buf, "UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK"); + break; + case UNIFY_Y_LOC_INSTINIT: + sprintf(*buf, "UNIFY_Y_LOC_INSTINIT"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_NONVAR"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK"); + break; + case UNIFY_Y_LOC_UVALY_LOC_UNK: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_UNK"); + break; + case UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR"); + break; + case UNIFY_Y_LOC_UVALY_LOC_VAR_UNK: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_VAR_UNK"); + break; + case UNIFY_Y_LOC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_Y_LOC_WRITE_INSTINIT"); + break; + case UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR: + sprintf(*buf, "UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR"); + break; + case UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK: + sprintf(*buf, "UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK"); + break; + case UNIFY_L_Y_LOC_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_LOC_INSTINIT"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_UNK: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_UNK"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK"); + break; + case UNIFY_L_Y_LOC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_LOC_WRITE_INSTINIT"); + break; + case UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR: + sprintf(*buf, "UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR"); + break; + case UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK: + sprintf(*buf, "UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK"); + break; + case UNIFY_VOID_INSTINIT: + sprintf(*buf, "UNIFY_VOID_INSTINIT"); + break; + case UNIFY_VOID_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_VOID_WRITE_INSTINIT"); + break; + case UNIFY_L_VOID_INSTINIT: + sprintf(*buf, "UNIFY_L_VOID_INSTINIT"); + break; + case UNIFY_L_VOID_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_VOID_WRITE_INSTINIT"); + break; + case UNIFY_N_VOIDS_INSTINIT: + sprintf(*buf, "UNIFY_N_VOIDS_INSTINIT"); + break; + case UNIFY_N_VOIDS_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_N_VOIDS_WRITE_INSTINIT"); + break; + case UNIFY_L_N_VOIDS_INSTINIT: + sprintf(*buf, "UNIFY_L_N_VOIDS_INSTINIT"); + break; + case UNIFY_L_N_VOIDS_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_N_VOIDS_WRITE_INSTINIT"); + break; + case UNIFY_ATOM_INSTINIT: + sprintf(*buf, "UNIFY_ATOM_INSTINIT"); + break; + case UNIFY_ATOM_UATOM_NONVAR: + sprintf(*buf, "UNIFY_ATOM_UATOM_NONVAR"); + break; + case UNIFY_ATOM_UATOM_UNK: + sprintf(*buf, "UNIFY_ATOM_UATOM_UNK"); + break; + case UNIFY_ATOM_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_ATOM_WRITE_INSTINIT"); + break; + case UNIFY_L_ATOM_INSTINIT: + sprintf(*buf, "UNIFY_L_ATOM_INSTINIT"); + break; + case UNIFY_L_ATOM_ULATOM_NONVAR: + sprintf(*buf, "UNIFY_L_ATOM_ULATOM_NONVAR"); + break; + case UNIFY_L_ATOM_ULATOM_UNK: + sprintf(*buf, "UNIFY_L_ATOM_ULATOM_UNK"); + break; + case UNIFY_L_ATOM_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_ATOM_WRITE_INSTINIT"); + break; + case UNIFY_N_ATOMS_INSTINIT: + sprintf(*buf, "UNIFY_N_ATOMS_INSTINIT"); + break; + case UNIFY_N_ATOMS_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_N_ATOMS_WRITE_INSTINIT"); + break; + case UNIFY_FLOAT_INSTINIT: + sprintf(*buf, "UNIFY_FLOAT_INSTINIT"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_INIT: + sprintf(*buf, "UNIFY_FLOAT_UFLOAT_NONVAR_INIT"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR: + sprintf(*buf, "UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_END: + sprintf(*buf, "UNIFY_FLOAT_UFLOAT_NONVAR_END"); + break; + case UNIFY_FLOAT_UFLOAT_UNK: + sprintf(*buf, "UNIFY_FLOAT_UFLOAT_UNK"); + break; + case UNIFY_FLOAT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_FLOAT_WRITE_INSTINIT"); + break; + case UNIFY_L_FLOAT_INSTINIT: + sprintf(*buf, "UNIFY_L_FLOAT_INSTINIT"); + break; + case UNIFY_L_FLOAT_D0ISAPPL: + sprintf(*buf, "UNIFY_L_FLOAT_D0ISAPPL"); + break; + case UNIFY_L_FLOAT_D0ISFUNC: + sprintf(*buf, "UNIFY_L_FLOAT_D0ISFUNC"); + break; + case UNIFY_L_FLOAT_EQUALS: + sprintf(*buf, "UNIFY_L_FLOAT_EQUALS"); + break; + case UNIFY_L_FLOAT_ULFLOAT_UNK: + sprintf(*buf, "UNIFY_L_FLOAT_ULFLOAT_UNK"); + break; + case UNIFY_L_FLOAT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_FLOAT_WRITE_INSTINIT"); + break; + case UNIFY_LONGINT_INSTINIT: + sprintf(*buf, "UNIFY_LONGINT_INSTINIT"); + break; + case UNIFY_LONGINT_D0ISAPPL: + sprintf(*buf, "UNIFY_LONGINT_D0ISAPPL"); + break; + case UNIFY_LONGINT_D0ISFUNC: + sprintf(*buf, "UNIFY_LONGINT_D0ISFUNC"); + break; + case UNIFY_LONGINT_EQUALS: + sprintf(*buf, "UNIFY_LONGINT_EQUALS"); + break; + case UNIFY_LONGINT_ULONGINT_UNK: + sprintf(*buf, "UNIFY_LONGINT_ULONGINT_UNK"); + break; + case UNIFY_LONGINT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_LONGINT_WRITE_INSTINIT"); + break; + case UNIFY_L_LONGINT_INSTINIT: + sprintf(*buf, "UNIFY_L_LONGINT_INSTINIT"); + break; + case UNIFY_L_LONGINT_D0ISAPPL: + sprintf(*buf, "UNIFY_L_LONGINT_D0ISAPPL"); + break; + case UNIFY_L_LONGINT_D0ISFUNC: + sprintf(*buf, "UNIFY_L_LONGINT_D0ISFUNC"); + break; + case UNIFY_L_LONGINT_EQUALS: + sprintf(*buf, "UNIFY_L_LONGINT_EQUALS"); + break; + case UNIFY_L_LONGINT_ULLONGINT_UNK: + sprintf(*buf, "UNIFY_L_LONGINT_ULLONGINT_UNK"); + break; + case UNIFY_L_LONGINT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_LONGINT_WRITE_INSTINIT"); + break; +#ifdef USE_GMP + case UNIFY_BIGINT_INSTINIT: + sprintf(*buf, "UNIFY_BIGINT_INSTINIT"); + break; + case UNIFY_BIGINT_D0ISAPPL: + sprintf(*buf, "UNIFY_BIGINT_D0ISAPPL"); + break; + case UNIFY_BIGINT_D1ISFUNC_GMP: + sprintf(*buf, "UNIFY_BIGINT_D1ISFUNC_GMP"); + break; + case UNIFY_BIGINT_UBIGINT_UNK: + sprintf(*buf, "UNIFY_BIGINT_UBIGINT_UNK"); + break; + case UNIFY_L_BIGINT_INSTINIT: + sprintf(*buf, "UNIFY_L_BIGINT_INSTINIT"); + break; + case UNIFY_L_BIGINT_D0ISAPPL: + sprintf(*buf, "UNIFY_L_BIGINT_D0ISAPPL"); + break; + case UNIFY_L_BIGINT_D0ISFUNC_GMP: + sprintf(*buf, "UNIFY_L_BIGINT_D0ISFUNC_GMP"); + break; + case UNIFY_L_BIGINT_ULBIGINT_UNK: + sprintf(*buf, "UNIFY_L_BIGINT_ULBIGINT_UNK"); + break; +#endif + case UNIFY_DBTERM_INSTINIT: + sprintf(*buf, "UNIFY_DBTERM_INSTINIT"); + break; + case UNIFY_DBTERM_UDBTERM_NONVAR: + sprintf(*buf, "UNIFY_DBTERM_UDBTERM_NONVAR"); + break; + case UNIFY_DBTERM_UDBTERM_UNK: + sprintf(*buf, "UNIFY_DBTERM_UDBTERM_UNK"); + break; + case UNIFY_L_DBTERM_INSTINIT: + sprintf(*buf, "UNIFY_L_DBTERM_INSTINIT"); + break; + case UNIFY_L_DBTERM_ULDBTERM_NONVAR: + sprintf(*buf, "UNIFY_L_DBTERM_ULDBTERM_NONVAR"); + break; + case UNIFY_L_DBTERM_ULDBTERM_UNK: + sprintf(*buf, "UNIFY_L_DBTERM_ULDBTERM_UNK"); + break; + case UNIFY_LIST_INSTINIT: + sprintf(*buf, "UNIFY_LIST_INSTINIT"); + break; + case UNIFY_LIST_READMODE: + sprintf(*buf, "UNIFY_LIST_READMODE"); + break; + case UNIFY_LIST_WRITEMODE: + sprintf(*buf, "UNIFY_LIST_WRITEMODE"); + break; + case UNIFY_LIST_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_LIST_WRITE_INSTINIT"); + break; + case UNIFY_L_LIST_INSTINIT: + sprintf(*buf, "UNIFY_L_LIST_INSTINIT"); + break; + case UNIFY_L_LIST_READMODE: + sprintf(*buf, "UNIFY_L_LIST_READMODE"); + break; + case UNIFY_L_LIST_WRITEMODE: + sprintf(*buf, "UNIFY_L_LIST_WRITEMODE"); + break; + case UNIFY_L_LIST_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_LIST_WRITE_INSTINIT"); + break; + case UNIFY_STRUCT_INSTINIT: + sprintf(*buf, "UNIFY_STRUCT_INSTINIT"); + break; + case UNIFY_STRUCT_READMODE: + sprintf(*buf, "UNIFY_STRUCT_READMODE"); + break; + case UNIFY_STRUCT_WRITEMODE: + sprintf(*buf, "UNIFY_STRUCT_WRITEMODE"); + break; + case UNIFY_STRUCT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_STRUCT_WRITE_INSTINIT"); + break; + case UNIFY_L_STRUC_INSTINIT: + sprintf(*buf, "UNIFY_L_STRUC_INSTINIT"); + break; + case UNIFY_L_STRUC_READMODE: + sprintf(*buf, "UNIFY_L_STRUC_READMODE"); + break; + case UNIFY_L_STRUC_WRITEMODE: + sprintf(*buf, "UNIFY_L_STRUC_WRITEMODE"); + break; + case UNIFY_L_STRUC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_STRUC_WRITE_INSTINIT"); + break; + case PUT_X_VAR_INSTINIT: + sprintf(*buf, "PUT_X_VAR_INSTINIT"); + break; + case PUT_Y_VAR_INSTINIT: + sprintf(*buf, "PUT_Y_VAR_INSTINIT"); + break; + case PUT_X_VAL_INSTINIT: + sprintf(*buf, "PUT_X_VAL_INSTINIT"); + break; + case PUT_XX_VAL_INSTINIT: + sprintf(*buf, "PUT_XX_VAL_INSTINIT"); + break; + case PUT_Y_VAL_INSTINIT: + sprintf(*buf, "PUT_Y_VAL_INSTINIT"); + break; + case PUT_Y_VALS_INSTINIT: + sprintf(*buf, "PUT_Y_VALS_INSTINIT"); + break; + case PUT_UNSAFE_INSTINIT: + sprintf(*buf, "PUT_UNSAFE_INSTINIT"); + break; + case PUT_UNSAFE_PUNSAFE_NONVAR: + sprintf(*buf, "PUT_UNSAFE_PUNSAFE_NONVAR"); + break; + case PUT_UNSAFE_PUNSAFE_UNK: + sprintf(*buf, "PUT_UNSAFE_PUNSAFE_UNK"); + break; + case PUT_ATOM_INSTINIT: + sprintf(*buf, "PUT_ATOM_INSTINIT"); + break; + case PUT_DBTERM_INSTINIT: + sprintf(*buf, "PUT_DBTERM_INSTINIT"); + break; + case PUT_BIGINT_INSTINIT: + sprintf(*buf, "PUT_BIGINT_INSTINIT"); + break; + case PUT_FLOAT_INSTINIT: + sprintf(*buf, "PUT_FLOAT_INSTINIT"); + break; + case PUT_LONGINT_INSTINIT: + sprintf(*buf, "PUT_LONGINT_INSTINIT"); + break; + case PUT_LIST_INSTINIT: + sprintf(*buf, "PUT_LIST_INSTINIT"); + break; + case PUT_STRUCT_INSTINIT: + sprintf(*buf, "PUT_STRUCT_INSTINIT"); + break; + case WRITE_X_VAR_INSTINIT: + sprintf(*buf, "WRITE_X_VAR_INSTINIT"); + break; + case WRITE_VOID_INSTINIT: + sprintf(*buf, "WRITE_VOID_INSTINIT"); + break; + case WRITE_N_VOIDS_INSTINIT: + sprintf(*buf, "WRITE_N_VOIDS_INSTINIT"); + break; + case WRITE_Y_VAR_INSTINIT: + sprintf(*buf, "WRITE_Y_VAR_INSTINIT"); + break; + case WRITE_X_VAL_INSTINIT: + sprintf(*buf, "WRITE_X_VAL_INSTINIT"); + break; + case WRITE_X_LOC_INSTINIT: + sprintf(*buf, "WRITE_X_LOC_INSTINIT"); + break; + case WRITE_X_LOC_W_X_BOUND: + sprintf(*buf, "WRITE_X_LOC_W_X_BOUND"); + break; + case WRITE_X_LOC_W_X_UNK: + sprintf(*buf, "WRITE_X_LOC_W_X_UNK"); + break; + case WRITE_Y_VAL_INSTINIT: + sprintf(*buf, "WRITE_Y_VAL_INSTINIT"); + break; + case WRITE_Y_LOC_INSTINIT: + sprintf(*buf, "WRITE_Y_LOC_INSTINIT"); + break; + case WRITE_Y_LOC_W_Y_BOUND: + sprintf(*buf, "WRITE_Y_LOC_W_Y_BOUND"); + break; + case WRITE_Y_LOC_W_Y_UNK: + sprintf(*buf, "WRITE_Y_LOC_W_Y_UNK"); + break; + case WRITE_ATOM_INSTINIT: + sprintf(*buf, "WRITE_ATOM_INSTINIT"); + break; + case WRITE_BIGINT_INSTINIT: + sprintf(*buf, "WRITE_BIGINT_INSTINIT"); + break; + case WRITE_DBTERM_INSTINIT: + sprintf(*buf, "WRITE_DBTERM_INSTINIT"); + break; + case WRITE_FLOAT_INSTINIT: + sprintf(*buf, "WRITE_FLOAT_INSTINIT"); + break; + case WRITE_LONGIT_INSTINIT: + sprintf(*buf, "WRITE_LONGIT_INSTINIT"); + break; + case WRITE_N_ATOMS_INSTINIT: + sprintf(*buf, "WRITE_N_ATOMS_INSTINIT"); + break; + case WRITE_LIST_INSTINIT: + sprintf(*buf, "WRITE_LIST_INSTINIT"); + break; + case WRITE_L_LIST_INSTINIT: + sprintf(*buf, "WRITE_L_LIST_INSTINIT"); + break; + case WRITE_STRUCT_INSTINIT: + sprintf(*buf, "WRITE_STRUCT_INSTINIT"); + break; + case WRITE_L_STRUC_INSTINIT: + sprintf(*buf, "WRITE_L_STRUC_INSTINIT"); + break; + case SAVE_PAIR_X_INSTINIT: + sprintf(*buf, "SAVE_PAIR_X_INSTINIT"); + break; + case SAVE_PAIR_X_WRITE_INSTINIT: + sprintf(*buf, "SAVE_PAIR_X_WRITE_INSTINIT"); + break; + case SAVE_PAIR_Y_INSTINIT: + sprintf(*buf, "SAVE_PAIR_Y_INSTINIT"); + break; + case SAVE_PAIR_Y_WRITE_INSTINIT: + sprintf(*buf, "SAVE_PAIR_Y_WRITE_INSTINIT"); + break; + case SAVE_APPL_X_INSTINIT: + sprintf(*buf, "SAVE_APPL_X_INSTINIT"); + break; + case SAVE_APPL_X_WRITE_INSTINIT: + sprintf(*buf, "SAVE_APPL_X_WRITE_INSTINIT"); + break; + case SAVE_APPL_Y_INSTINIT: + sprintf(*buf, "SAVE_APPL_Y_INSTINIT"); + break; + case SAVE_APPL_Y_WRITE_INSTINIT: + sprintf(*buf, "SAVE_APPL_Y_WRITE_INSTINIT"); + break; + case JUMP_INSTINIT: + sprintf(*buf, "JUMP_INSTINIT"); + break; + case MOVE_BACK_INSTINIT: + sprintf(*buf, "MOVE_BACK_INSTINIT"); + break; + case SKIP_INSTINIT: + sprintf(*buf, "SKIP_INSTINIT"); + break; + case EITHER_INSTINIT: + sprintf(*buf, "EITHER_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case EITHER_LOW_LEVEL_TRACER: + sprintf(*buf, "EITHER_LOW_LEVEL_TRACER"); + break; +#endif + case EITHER_POST_COROUTINING: + sprintf(*buf, "EITHER_POST_COROUTINING"); + break; + case EITHER_FROZEN_YSBA: + sprintf(*buf, "EITHER_FROZEN_YSBA"); + break; + case EITHER_POST_FROZEN_YSBA: + sprintf(*buf, "EITHER_POST_FROZEN_YSBA"); + break; +#ifdef YAPOR + case EITHER_YAPOR: + sprintf(*buf, "EITHER_YAPOR"); + break; +#endif + case EITHER_END: + sprintf(*buf, "EITHER_END"); + break; + case OR_ELSE_INSTINIT: + sprintf(*buf, "OR_ELSE_INSTINIT"); + break; +#ifdef DEPTH_LIMIT + case OR_ELSE_DEPTH: + sprintf(*buf, "OR_ELSE_DEPTH"); + break; +#endif + case OR_ELSE_POST_DEPTH: + sprintf(*buf, "OR_ELSE_POST_DEPTH"); + break; +#ifdef YAPOR + case OR_ELSE_YAPOR: + sprintf(*buf, "OR_ELSE_YAPOR"); + break; +#endif + case OR_ELSE_END: + sprintf(*buf, "OR_ELSE_END"); + break; + case OR_LAST_INSTINIT: + sprintf(*buf, "OR_LAST_INSTINIT"); + break; +#ifdef YAPOR + case OR_LAST_IFOK_INIT: + sprintf(*buf, "OR_LAST_IFOK_INIT"); + break; +#ifdef DEPTH_LIMIT + case OR_LAST_IFOK_DEPTH: + sprintf(*buf, "OR_LAST_IFOK_DEPTH"); + break; +#endif + case OR_LAST_IFOK_END: + sprintf(*buf, "OR_LAST_IFOK_END"); + break; +#endif + case OR_LAST_NOIF_INIT: + sprintf(*buf, "OR_LAST_NOIF_INIT"); + break; +#ifdef DEPTH_LIMIT + case OR_LAST_NOIF_DEPTH: + sprintf(*buf, "OR_LAST_NOIF_DEPTH"); + break; +#endif + case OR_LAST_NOIF_END: + sprintf(*buf, "OR_LAST_NOIF_END"); + break; +#ifdef YAPOR + case OR_LAST_YAPOR: + sprintf(*buf, "OR_LAST_YAPOR"); + break; +#else + case OR_LAST_NOYAPOR: + sprintf(*buf, "OR_LAST_NOYAPOR"); + break; +#endif + case OR_LAST_END: + sprintf(*buf, "OR_LAST_END"); + break; + case POP_N_INSTINIT: + sprintf(*buf, "POP_N_INSTINIT"); + break; + case POP_N_END: + sprintf(*buf, "POP_N_END"); + break; + case POP_INSTINIT: + sprintf(*buf, "POP_INSTINIT"); + break; + case POP_END: + sprintf(*buf, "POP_END"); + break; + case CALL_CPRED_INSTINIT: + sprintf(*buf, "CALL_CPRED_INSTINIT"); + break; + case CALL_CPRED_TEST_STACK: + sprintf(*buf, "CALL_CPRED_TEST_STACK"); + break; +#ifdef FROZEN_STACKS + case CALL_CPRED_FROZEN_INIT: + sprintf(*buf, "CALL_CPRED_FROZEN_INIT"); + break; + case CALL_CPRED_TOPB: + sprintf(*buf, "CALL_CPRED_TOPB"); + break; +#else + case CALL_CPRED_NOFROZEN: + sprintf(*buf, "CALL_CPRED_NOFROZEN"); + break; +#endif +#ifdef LOW_LEVEL_TRACER + case CALL_CPRED_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_CPRED_LOW_LEVEL_TRACER"); + break; +#endif + case CALL_CPRED_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_CPRED_POST_LOW_LEVEL_TRACER"); + break; +#ifdef SHADOW_S + case CALL_CPRED_SETSREG: + sprintf(*buf, "CALL_CPRED_SETSREG"); + break; +#endif + case CALL_CPRED_END: + sprintf(*buf, "CALL_CPRED_END"); + break; + case EXECUTE_CPRED_INSTINIT: + sprintf(*buf, "EXECUTE_CPRED_INSTINIT"); + break; + case EXECUTE_CPRED_POST_CHECK_TRAIL: + sprintf(*buf, "EXECUTE_CPRED_POST_CHECK_TRAIL"); + break; +#ifdef FROZEN_STACKS + case EXECUTE_CPRED_FROZEN: + sprintf(*buf, "EXECUTE_CPRED_FROZEN"); + break; + case EXECUTE_CPRED_TOPB: + sprintf(*buf, "EXECUTE_CPRED_TOPB"); + break; +#else + case EXECUTE_CPRED_NOFROZEN: + sprintf(*buf, "EXECUTE_CPRED_NOFROZEN"); + break; +#endif + case EXECUTE_CPRED_POST_FROZEN: + sprintf(*buf, "EXECUTE_CPRED_POST_FROZEN"); + break; +#ifdef LOW_LEVEL_TRACER + case EXECUTE_CPRED_LOW_LEVEL_TRACER: + sprintf(*buf, "EXECUTE_CPRED_LOW_LEVEL_TRACER"); + break; +#endif + case EXECUTE_CPRED_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "EXECUTE_CPRED_POST_LOW_LEVEL_TRACER"); + break; + case EXECUTE_CPRED_SAVE_PC: + sprintf(*buf, "EXECUTE_CPRED_SAVE_PC"); + break; +#ifdef DEPTH_LIMIT + case EXECUTE_CPRED_DEPTH_MINOR: + sprintf(*buf, "EXECUTE_CPRED_DEPTH_MINOR"); + break; + case EXECUTE_CPRED_DEPTH_MOFPRED: + sprintf(*buf, "EXECUTE_CPRED_DEPTH_MOFPRED"); + break; + case EXECUTE_CPRED_DEPTH_END: + sprintf(*buf, "EXECUTE_CPRED_DEPTH_END"); + break; +#endif + case EXECUTE_CPRED_END: + sprintf(*buf, "EXECUTE_CPRED_END"); + break; + case CALL_USERCPRED_INSTINIT: + sprintf(*buf, "CALL_USERCPRED_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case CALL_USERCPRED_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_USERCPRED_LOW_LEVEL_TRACER"); + break; +#endif + case CALL_USERCPRED_FROZEN: + sprintf(*buf, "CALL_USERCPRED_FROZEN"); + break; + case CALL_USERCPRED_POST_FROZEN: + sprintf(*buf, "CALL_USERCPRED_POST_FROZEN"); + break; + case CALL_USERCPRED_END: + sprintf(*buf, "CALL_USERCPRED_END"); + break; + case LOCK_PRED_INSTINIT: + sprintf(*buf, "LOCK_PRED_INSTINIT"); + break; + case LOCK_PRED_FIRSTIFOK: + sprintf(*buf, "LOCK_PRED_FIRSTIFOK"); + break; + case LOCK_PRED_SECONDTIFOK: + sprintf(*buf, "LOCK_PRED_SECONDTIFOK"); + break; + case LOCK_PRED_END: + sprintf(*buf, "LOCK_PRED_END"); + break; + case INDEX_PRED_INSTINIT: + sprintf(*buf, "INDEX_PRED_INSTINIT"); + break; + case INDEX_PRED_END: + sprintf(*buf, "INDEX_PRED_END"); + break; +#if THREADS + case THREAD_LOCAL_INSTINIT: + sprintf(*buf, "THREAD_LOCAL_INSTINIT"); + break; +#endif + case EXPAND_INDEX_INSTINIT: + sprintf(*buf, "EXPAND_INDEX_INSTINIT"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_INDEX_YAPOR_THREADS_NOPP: + sprintf(*buf, "EXPAND_INDEX_YAPOR_THREADS_NOPP"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT: + sprintf(*buf, "EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK: + sprintf(*buf, "EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_END: + sprintf(*buf, "EXPAND_INDEX_YAPOR_THREADS_IFOK_END"); + break; +#endif +#ifdef SHADOW_S + case EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS: + sprintf(*buf, "EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS"); + break; +#endif + case EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS: + sprintf(*buf, "EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS"); + break; +#ifdef SHADOW_S + case EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG: + sprintf(*buf, "EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG"); + break; +#endif + case EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG: + sprintf(*buf, "EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_INDEX_UNLOCK: + sprintf(*buf, "EXPAND_INDEX_UNLOCK"); + break; +#endif + case EXPAND_INDEX_END: + sprintf(*buf, "EXPAND_INDEX_END"); + break; + case EXPAND_CLAUSES_INSTINIT: + sprintf(*buf, "EXPAND_CLAUSES_INSTINIT"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_CLAUSES_YAPOR_THREADS_NOPP: + sprintf(*buf, "EXPAND_CLAUSES_YAPOR_THREADS_NOPP"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT: + sprintf(*buf, "EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK: + sprintf(*buf, "EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END: + sprintf(*buf, "EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END"); + break; +#endif + case EXPAND_CLAUSES_NOYAPOR_NOTHREADS: + sprintf(*buf, "EXPAND_CLAUSES_NOYAPOR_NOTHREADS"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_CLAUSES_UNLOCK: + sprintf(*buf, "EXPAND_CLAUSES_UNLOCK"); + break; +#endif + case EXPAND_CLAUSES_END: + sprintf(*buf, "EXPAND_CLAUSES_END"); + break; + case UNDEF_P_INSTINIT: + sprintf(*buf, "UNDEF_P_INSTINIT"); + break; + case UNDEF_P_END: + sprintf(*buf, "UNDEF_P_END"); + break; + case SPY_PRED_INSTINIT: + sprintf(*buf, "SPY_PRED_INSTINIT"); + break; + case SPY_PRED_FIRSTIFOK: + sprintf(*buf, "SPY_PRED_FIRSTIFOK"); + break; + case SPY_PRED_SECONDIFOK_INIT: + sprintf(*buf, "SPY_PRED_SECONDIFOK_INIT"); + break; + case SPY_PRED_SECONDIFOK_FIRSTIFOK: + sprintf(*buf, "SPY_PRED_SECONDIFOK_FIRSTIFOK"); + break; + case SPY_PRED_SECONDIFOK_POST_FIRSTIF: + sprintf(*buf, "SPY_PRED_SECONDIFOK_POST_FIRSTIF"); + break; + case SPY_PRED_SECONDIFOK_SECONDIFOK: + sprintf(*buf, "SPY_PRED_SECONDIFOK_SECONDIFOK"); + break; + case SPY_PRED_SECONDIFOK_THIRDIFOK: + sprintf(*buf, "SPY_PRED_SECONDIFOK_THIRDIFOK"); + break; + case SPY_PRED_THIRDIFOK_INIT: + sprintf(*buf, "SPY_PRED_THIRDIFOK_INIT"); + break; + case SPY_PRED_THIRDIFOK_FIRSTIFOK: + sprintf(*buf, "SPY_PRED_THIRDIFOK_FIRSTIFOK"); + break; + case SPY_PRED_FOURTHIFOK: + sprintf(*buf, "SPY_PRED_FOURTHIFOK"); + break; + case SPY_PRED_POST_FOURTHIF: + sprintf(*buf, "SPY_PRED_POST_FOURTHIF"); + break; + case SPY_PRED_D0ISZERO: + sprintf(*buf, "SPY_PRED_D0ISZERO"); + break; + case SPY_PRED_D0ISNOZERO_INIT: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INIT"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR"); + break; + case SPY_PRED_POST_IFS: + sprintf(*buf, "SPY_PRED_POST_IFS"); + break; +#ifdef THREADS + case SPY_PRED_THREADS_LOCK: + sprintf(*buf, "SPY_PRED_THREADS_LOCK"); + break; +#endif + case SPY_PRED_POST_LOCK: + sprintf(*buf, "SPY_PRED_POST_LOCK"); + break; +#ifdef THREADS + case SPY_PRED_THREADS_UNLOCK: + sprintf(*buf, "SPY_PRED_THREADS_UNLOCK"); + break; +#endif + case SPY_PRED_POST_UNLOCK: + sprintf(*buf, "SPY_PRED_POST_UNLOCK"); + break; +#ifdef LOW_LEVEL_TRACER + case SPY_PRED_LOW_LEVEL_TRACER: + sprintf(*buf, "SPY_PRED_LOW_LEVEL_TRACER"); + break; +#endif + case SPY_PRED_END: + sprintf(*buf, "SPY_PRED_END"); + break; + case TRY_CLAUSE_INSTINIT: + sprintf(*buf, "TRY_CLAUSE_INSTINIT"); + break; +#ifdef YAPOR + case TRY_CLAUSE_YAPOR: + sprintf(*buf, "TRY_CLAUSE_YAPOR"); + break; +#endif + case TRY_CLAUSE_END: + sprintf(*buf, "TRY_CLAUSE_END"); + break; + case TRY_CLAUSE2_INSTINIT: + sprintf(*buf, "TRY_CLAUSE2_INSTINIT"); + break; +#ifdef YAPOR + case TRY_CLAUSE2_YAPOR: + sprintf(*buf, "TRY_CLAUSE2_YAPOR"); + break; +#endif + case TRY_CLAUSE2_END: + sprintf(*buf, "TRY_CLAUSE2_END"); + break; + case TRY_CLAUSE3_INSTINIT: + sprintf(*buf, "TRY_CLAUSE3_INSTINIT"); + break; +#ifdef YAPOR + case TRY_CLAUSE3_YAPOR: + sprintf(*buf, "TRY_CLAUSE3_YAPOR"); + break; +#endif + case TRY_CLAUSE3_END: + sprintf(*buf, "TRY_CLAUSE3_END"); + break; + case TRY_CLAUSE4_INSTINIT: + sprintf(*buf, "TRY_CLAUSE4_INSTINIT"); + break; +#ifdef YAPOR + case TRY_CLAUSE4_YAPOR: + sprintf(*buf, "TRY_CLAUSE4_YAPOR"); + break; +#endif + case TRY_CLAUSE4_END: + sprintf(*buf, "TRY_CLAUSE4_END"); + break; + case RETRY_INSTINIT: + sprintf(*buf, "RETRY_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY_FROZEN: + sprintf(*buf, "RETRY_FROZEN"); + break; +#else + case RETRY_NOFROZEN: + sprintf(*buf, "RETRY_NOFROZEN"); + break; +#endif + case RETRY_END: + sprintf(*buf, "RETRY_END"); + break; + case RETRY2_INSTINIT: + sprintf(*buf, "RETRY2_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY2_FROZEN: + sprintf(*buf, "RETRY2_FROZEN"); + break; +#else + case RETRY2_NOFROZEN: + sprintf(*buf, "RETRY2_NOFROZEN"); + break; +#endif + case RETRY2_END: + sprintf(*buf, "RETRY2_END"); + break; + case RETRY3_INSTINIT: + sprintf(*buf, "RETRY3_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY3_FROZEN: + sprintf(*buf, "RETRY3_FROZEN"); + break; +#else + case RETRY3_NOFROZEN: + sprintf(*buf, "RETRY3_NOFROZEN"); + break; +#endif + case RETRY3_END: + sprintf(*buf, "RETRY3_END"); + break; + case RETRY4_INSTINIT: + sprintf(*buf, "RETRY4_INSTINIT"); + break; +#ifdef FROZEN_STACKS + case RETRY4_FROZEN: + sprintf(*buf, "RETRY4_FROZEN"); + break; +#else + case RETRY4_NOFROZEN: + sprintf(*buf, "RETRY4_NOFROZEN"); + break; +#endif + case RETRY4_END: + sprintf(*buf, "RETRY4_END"); + break; + case TRUST_INSTINIT: + sprintf(*buf, "TRUST_INSTINIT"); + break; +#ifdef YAPOR + case TRUST_IFOK_INIT: + sprintf(*buf, "TRUST_IFOK_INIT"); + break; +#ifdef FROZEN_STACKS + case TRUST_IFOK_FROZEN: + sprintf(*buf, "TRUST_IFOK_FROZEN"); + break; +#endif + case TRUST_IFOK_END: + sprintf(*buf, "TRUST_IFOK_END"); + break; +#endif + case TRUST_NOIF_INIT: + sprintf(*buf, "TRUST_NOIF_INIT"); + break; +#ifdef FROZEN_STACKS + case TRUST_NOIF_FROZEN: + sprintf(*buf, "TRUST_NOIF_FROZEN"); + break; +#endif + case TRUST_END: + sprintf(*buf, "TRUST_END"); + break; + case TRY_IN_INSTINIT: + sprintf(*buf, "TRY_IN_INSTINIT"); + break; + case TRY_IN_END: + sprintf(*buf, "TRY_IN_END"); + break; + case USER_SWITCH_INSTINIT: + sprintf(*buf, "USER_SWITCH_INSTINIT"); + break; + case USER_SWITCH_END: + sprintf(*buf, "USER_SWITCH_END"); + break; + case SWITCH_ON_TYPE_INSTINIT: + sprintf(*buf, "SWITCH_ON_TYPE_INSTINIT"); + break; + case SWITCH_ON_TYPE_END: + sprintf(*buf, "SWITCH_ON_TYPE_END"); + break; + case SWITCH_LIST_NL_INSTINIT: + sprintf(*buf, "SWITCH_LIST_NL_INSTINIT"); + break; + case SWITCH_LIST_NL_END: + sprintf(*buf, "SWITCH_LIST_NL_END"); + break; + case SWITCH_ON_ARG_TYPE_INSTINIT: + sprintf(*buf, "SWITCH_ON_ARG_TYPE_INSTINIT"); + break; + case SWITCH_ON_ARG_TYPE_END: + sprintf(*buf, "SWITCH_ON_ARG_TYPE_END"); + break; + case SWITCH_ON_SUB_ARG_TYPE_INSTINIT: + sprintf(*buf, "SWITCH_ON_SUB_ARG_TYPE_INSTINIT"); + break; + case SWITCH_ON_SUB_ARG_TYPE_END: + sprintf(*buf, "SWITCH_ON_SUB_ARG_TYPE_END"); + break; + case JUMP_IF_VAR_INSTINIT: + sprintf(*buf, "JUMP_IF_VAR_INSTINIT"); + break; + case JUMP_IF_VAR_END: + sprintf(*buf, "JUMP_IF_VAR_END"); + break; + case JUMP_IF_NONVAR_INSTINIT: + sprintf(*buf, "JUMP_IF_NONVAR_INSTINIT"); + break; + case JUMP_IF_NONVAR_END: + sprintf(*buf, "JUMP_IF_NONVAR_END"); + break; + case IF_NOT_THEN_INSTINIT: + sprintf(*buf, "IF_NOT_THEN_INSTINIT"); + break; + case IF_NOT_THEN_END: + sprintf(*buf, "IF_NOT_THEN_END"); + break; + case SWITCH_ON_FUNC_INSTINIT: + sprintf(*buf, "SWITCH_ON_FUNC_INSTINIT"); + break; + case SWITCH_ON_FUNC_END: + sprintf(*buf, "SWITCH_ON_FUNC_END"); + break; + case SWITCH_ON_CONS_INSTINIT: + sprintf(*buf, "SWITCH_ON_CONS_INSTINIT"); + break; + case SWITCH_ON_CONS_END: + sprintf(*buf, "SWITCH_ON_CONS_END"); + break; + case GO_ON_FUNC_INSTINIT: + sprintf(*buf, "GO_ON_FUNC_INSTINIT"); + break; + case GO_ON_FUNC_END: + sprintf(*buf, "GO_ON_FUNC_END"); + break; + case GO_ON_CONS_INSTINIT: + sprintf(*buf, "GO_ON_CONS_INSTINIT"); + break; + case GO_ON_CONS_END: + sprintf(*buf, "GO_ON_CONS_END"); + break; + case IF_FUNC_INSTINIT: + sprintf(*buf, "IF_FUNC_INSTINIT"); + break; + case IF_FUNC_END: + sprintf(*buf, "IF_FUNC_END"); + break; + case IF_CONS_INSTINIT: + sprintf(*buf, "IF_CONS_INSTINIT"); + break; + case IF_CONS_END: + sprintf(*buf, "IF_CONS_END"); + break; + case INDEX_DBREF_INSTINIT: + sprintf(*buf, "INDEX_DBREF_INSTINIT"); + break; + case INDEX_DBREF_END: + sprintf(*buf, "INDEX_DBREF_END"); + break; + case INDEX_BLOB_INSTINIT: + sprintf(*buf, "INDEX_BLOB_INSTINIT"); + break; + case INDEX_BLOB_END: + sprintf(*buf, "INDEX_BLOB_END"); + break; + case INDEX_LONG_INSTINIT: + sprintf(*buf, "INDEX_LONG_INSTINIT"); + break; + case INDEX_LONG_END: + sprintf(*buf, "INDEX_LONG_END"); + break; + case JIT_HANDLER_INSTINIT: + sprintf(*buf, "JIT_HANDLER_INSTINIT"); + break; + case P_ATOM_X_INSTINIT: + sprintf(*buf, "P_ATOM_X_INSTINIT"); + break; + case P_ATOM_X_ATOM: + sprintf(*buf, "P_ATOM_X_ATOM"); + break; + case P_ATOM_X_NOATOM: + sprintf(*buf, "P_ATOM_X_NOATOM"); + break; + case P_ATOM_Y_INSTINIT: + sprintf(*buf, "P_ATOM_Y_INSTINIT"); + break; + case P_ATOM_Y_IFOK: + sprintf(*buf, "P_ATOM_Y_IFOK"); + break; + case P_ATOM_Y_NOIF: + sprintf(*buf, "P_ATOM_Y_NOIF"); + break; + case P_ATOM_Y_END: + sprintf(*buf, "P_ATOM_Y_END"); + break; + case P_ATOMIC_X_INSTINIT: + sprintf(*buf, "P_ATOMIC_X_INSTINIT"); + break; + case P_ATOMIC_X_NONVAR: + sprintf(*buf, "P_ATOMIC_X_NONVAR"); + break; + case P_ATOMIC_X_VAR: + sprintf(*buf, "P_ATOMIC_X_VAR"); + break; + case P_ATOMIC_X_END: + sprintf(*buf, "P_ATOMIC_X_END"); + break; + case P_ATOMIC_Y_INSTINIT: + sprintf(*buf, "P_ATOMIC_Y_INSTINIT"); + break; + case P_ATOMIC_Y_NONVAR: + sprintf(*buf, "P_ATOMIC_Y_NONVAR"); + break; + case P_ATOMIC_Y_VAR: + sprintf(*buf, "P_ATOMIC_Y_VAR"); + break; + case P_ATOMIC_Y_END: + sprintf(*buf, "P_ATOMIC_Y_END"); + break; + case P_INTEGER_X_INSTINIT: + sprintf(*buf, "P_INTEGER_X_INSTINIT"); + break; + case P_INTEGER_X_INTEGER_X_NVAR_OK: + sprintf(*buf, "P_INTEGER_X_INTEGER_X_NVAR_OK"); + break; + case P_INTEGER_X_INTEGER_X_NVAR_NOOK: + sprintf(*buf, "P_INTEGER_X_INTEGER_X_NVAR_NOOK"); + break; + case P_INTEGER_X_INTEGER_X_UNK: + sprintf(*buf, "P_INTEGER_X_INTEGER_X_UNK"); + break; + case P_INTEGER_Y_INSTINIT: + sprintf(*buf, "P_INTEGER_Y_INSTINIT"); + break; + case P_INTEGER_Y_INTEGER_Y_NVAR_OK: + sprintf(*buf, "P_INTEGER_Y_INTEGER_Y_NVAR_OK"); + break; + case P_INTEGER_Y_INTEGER_Y_NVAR_NOOK: + sprintf(*buf, "P_INTEGER_Y_INTEGER_Y_NVAR_NOOK"); + break; + case P_INTEGER_Y_INTEGER_Y_UNK: + sprintf(*buf, "P_INTEGER_Y_INTEGER_Y_UNK"); + break; + case P_NONVAR_X_INSTINIT: + sprintf(*buf, "P_NONVAR_X_INSTINIT"); + break; + case P_NONVAR_X_NONVAR: + sprintf(*buf, "P_NONVAR_X_NONVAR"); + break; + case P_NONVAR_X_NONONVAR: + sprintf(*buf, "P_NONVAR_X_NONONVAR"); + break; + case P_NONVAR_Y_INSTINIT: + sprintf(*buf, "P_NONVAR_Y_INSTINIT"); + break; + case P_NONVAR_Y_NONVAR: + sprintf(*buf, "P_NONVAR_Y_NONVAR"); + break; + case P_NONVAR_Y_NONONVAR: + sprintf(*buf, "P_NONVAR_Y_NONONVAR"); + break; + case P_NUMBER_X_INSTINIT: + sprintf(*buf, "P_NUMBER_X_INSTINIT"); + break; + case P_NUMBER_X_INT: + sprintf(*buf, "P_NUMBER_X_INT"); + break; + case P_NUMBER_X_FUNCTORINT: + sprintf(*buf, "P_NUMBER_X_FUNCTORINT"); + break; + case P_NUMBER_X_FUNCTORDEFAULT: + sprintf(*buf, "P_NUMBER_X_FUNCTORDEFAULT"); + break; + case P_NUMBER_X_POST_IF: + sprintf(*buf, "P_NUMBER_X_POST_IF"); + break; + case P_NUMBER_X_NUMBER_X_UNK: + sprintf(*buf, "P_NUMBER_X_NUMBER_X_UNK"); + break; + case P_NUMBER_Y_INSTINIT: + sprintf(*buf, "P_NUMBER_Y_INSTINIT"); + break; + case P_NUMBER_Y_INT: + sprintf(*buf, "P_NUMBER_Y_INT"); + break; + case P_NUMBER_Y_FUNCTORINT: + sprintf(*buf, "P_NUMBER_Y_FUNCTORINT"); + break; + case P_NUMBER_Y_FUNCTORDEFAULT: + sprintf(*buf, "P_NUMBER_Y_FUNCTORDEFAULT"); + break; + case P_NUMBER_Y_POST_IF: + sprintf(*buf, "P_NUMBER_Y_POST_IF"); + break; + case P_NUMBER_Y_NUMBER_Y_UNK: + sprintf(*buf, "P_NUMBER_Y_NUMBER_Y_UNK"); + break; + case P_VAR_X_INSTINIT: + sprintf(*buf, "P_VAR_X_INSTINIT"); + break; + case P_VAR_X_NONVAR: + sprintf(*buf, "P_VAR_X_NONVAR"); + break; + case P_VAR_X_VAR: + sprintf(*buf, "P_VAR_X_VAR"); + break; + case P_VAR_Y_INSTINIT: + sprintf(*buf, "P_VAR_Y_INSTINIT"); + break; + case P_VAR_Y_NONVAR: + sprintf(*buf, "P_VAR_Y_NONVAR"); + break; + case P_VAR_Y_VAR: + sprintf(*buf, "P_VAR_Y_VAR"); + break; + case P_DB_REF_X_INSTINIT: + sprintf(*buf, "P_DB_REF_X_INSTINIT"); + break; + case P_DB_REF_X_DBREF: + sprintf(*buf, "P_DB_REF_X_DBREF"); + break; + case P_DB_REF_X_NODBREF: + sprintf(*buf, "P_DB_REF_X_NODBREF"); + break; + case P_DB_REF_X_DBREF_X_UNK: + sprintf(*buf, "P_DB_REF_X_DBREF_X_UNK"); + break; + case P_DB_REF_Y_INSTINIT: + sprintf(*buf, "P_DB_REF_Y_INSTINIT"); + break; + case P_DB_REF_Y_DBREF: + sprintf(*buf, "P_DB_REF_Y_DBREF"); + break; + case P_DB_REF_Y_NODBREF: + sprintf(*buf, "P_DB_REF_Y_NODBREF"); + break; + case P_DB_REF_Y_DBREF_Y_UNK: + sprintf(*buf, "P_DB_REF_Y_DBREF_Y_UNK"); + break; + case P_PRIMITIVE_X_INSTINIT: + sprintf(*buf, "P_PRIMITIVE_X_INSTINIT"); + break; + case P_PRIMITIVE_X_PRIMITIVE: + sprintf(*buf, "P_PRIMITIVE_X_PRIMITIVE"); + break; + case P_PRIMITIVE_X_NOPRIMITIVE: + sprintf(*buf, "P_PRIMITIVE_X_NOPRIMITIVE"); + break; + case P_PRIMITIVE_X_PRIMI_X_UNK: + sprintf(*buf, "P_PRIMITIVE_X_PRIMI_X_UNK"); + break; + case P_PRIMITIVE_Y_INSTINIT: + sprintf(*buf, "P_PRIMITIVE_Y_INSTINIT"); + break; + case P_PRIMITIVE_Y_PRIMITIVE: + sprintf(*buf, "P_PRIMITIVE_Y_PRIMITIVE"); + break; + case P_PRIMITIVE_Y_NOPRIMITIVE: + sprintf(*buf, "P_PRIMITIVE_Y_NOPRIMITIVE"); + break; + case P_PRIMITIVE_Y_PRIMI_Y_UNK: + sprintf(*buf, "P_PRIMITIVE_Y_PRIMI_Y_UNK"); + break; + case P_COMPOUND_X_INSTINIT: + sprintf(*buf, "P_COMPOUND_X_INSTINIT"); + break; + case P_COMPOUND_X_PAIR: + sprintf(*buf, "P_COMPOUND_X_PAIR"); + break; + case P_COMPOUND_X_APPL_IFOK: + sprintf(*buf, "P_COMPOUND_X_APPL_IFOK"); + break; + case P_COMPOUND_X_APPL: + sprintf(*buf, "P_COMPOUND_X_APPL"); + break; + case P_COMPOUND_X_NOAPPL: + sprintf(*buf, "P_COMPOUND_X_NOAPPL"); + break; + case P_COMPOUND_X_COMPOUND_X_UNK: + sprintf(*buf, "P_COMPOUND_X_COMPOUND_X_UNK"); + break; + case P_COMPOUND_Y_INSTINIT: + sprintf(*buf, "P_COMPOUND_Y_INSTINIT"); + break; + case P_COMPOUND_Y_PAIR: + sprintf(*buf, "P_COMPOUND_Y_PAIR"); + break; + case P_COMPOUND_Y_APPL_IFOK: + sprintf(*buf, "P_COMPOUND_Y_APPL_IFOK"); + break; + case P_COMPOUND_Y_APPL: + sprintf(*buf, "P_COMPOUND_Y_APPL"); + break; + case P_COMPOUND_Y_NOAPPL: + sprintf(*buf, "P_COMPOUND_Y_NOAPPL"); + break; + case P_COMPOUND_Y_COMPOUND_Y_UNK: + sprintf(*buf, "P_COMPOUND_Y_COMPOUND_Y_UNK"); + break; + case P_FLOAT_X_INSTINIT: + sprintf(*buf, "P_FLOAT_X_INSTINIT"); + break; + case P_FLOAT_X_FLOAT: + sprintf(*buf, "P_FLOAT_X_FLOAT"); + break; + case P_FLOAT_X_POST_IF: + sprintf(*buf, "P_FLOAT_X_POST_IF"); + break; + case P_FLOAT_X_FLOAT_X_UNK: + sprintf(*buf, "P_FLOAT_X_FLOAT_X_UNK"); + break; + case P_FLOAT_Y_INSTINIT: + sprintf(*buf, "P_FLOAT_Y_INSTINIT"); + break; + case P_FLOAT_Y_FLOAT: + sprintf(*buf, "P_FLOAT_Y_FLOAT"); + break; + case P_FLOAT_Y_POST_IF: + sprintf(*buf, "P_FLOAT_Y_POST_IF"); + break; + case P_FLOAT_Y_FLOAT_Y_UNK: + sprintf(*buf, "P_FLOAT_Y_FLOAT_Y_UNK"); + break; + case P_PLUS_VV_INSTINIT: + sprintf(*buf, "P_PLUS_VV_INSTINIT"); + break; + case P_PLUS_VV_PLUS_VV_NVAR: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_NVAR"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT"); + break; + case P_PLUS_VV_PLUS_VV_UNK: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_UNK"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_UNK: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_NVAR_UNK"); + break; + case P_PLUS_VC_INSTINIT: + sprintf(*buf, "P_PLUS_VC_INSTINIT"); + break; + case P_PLUS_VC_PLUS_VC_NVAR_INT: + sprintf(*buf, "P_PLUS_VC_PLUS_VC_NVAR_INT"); + break; + case P_PLUS_VC_PLUS_VC_NVAR_NOINT: + sprintf(*buf, "P_PLUS_VC_PLUS_VC_NVAR_NOINT"); + break; + case P_PLUS_VC_PLUS_VC_UNK: + sprintf(*buf, "P_PLUS_VC_PLUS_VC_UNK"); + break; + case P_PLUS_Y_VV_INSTINIT: + sprintf(*buf, "P_PLUS_Y_VV_INSTINIT"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_UNK: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_UNK"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK"); + break; + case P_PLUS_Y_VC_INSTINIT: + sprintf(*buf, "P_PLUS_Y_VC_INSTINIT"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT: + sprintf(*buf, "P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT: + sprintf(*buf, "P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_UNK: + sprintf(*buf, "P_PLUS_Y_VC_PLUS_Y_VC_UNK"); + break; + case P_MINUS_VV_INSTINIT: + sprintf(*buf, "P_MINUS_VV_INSTINIT"); + break; + case P_MINUS_VV_MINUS_VV_NVAR: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_NVAR"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT"); + break; + case P_MINUS_VV_MINUS_VV_UNK: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_UNK"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_UNK: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_NVAR_UNK"); + break; + case P_MINUS_CV_INSTINIT: + sprintf(*buf, "P_MINUS_CV_INSTINIT"); + break; + case P_MINUS_CV_MINUS_CV_NVAR_INT: + sprintf(*buf, "P_MINUS_CV_MINUS_CV_NVAR_INT"); + break; + case P_MINUS_CV_MINUS_CV_NVAR_NOINT: + sprintf(*buf, "P_MINUS_CV_MINUS_CV_NVAR_NOINT"); + break; + case P_MINUS_CV_MINUS_CV_UNK: + sprintf(*buf, "P_MINUS_CV_MINUS_CV_UNK"); + break; + case P_MINUS_Y_VV_INSTINIT: + sprintf(*buf, "P_MINUS_Y_VV_INSTINIT"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_NVAR: + sprintf(*buf, "P_MINUS_Y_VV_MINUS_Y_VV_NVAR"); + break; + case P_MINUS_Y_VV_INTTERM: + sprintf(*buf, "P_MINUS_Y_VV_INTTERM"); + break; + case P_MINUS_Y_VV_NOINTTERM: + sprintf(*buf, "P_MINUS_Y_VV_NOINTTERM"); + break; + case P_MINUS_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_MINUS_Y_VV_D0EQUALS0L"); + break; + case P_MINUS_Y_VV_NVAR_END: + sprintf(*buf, "P_MINUS_Y_VV_NVAR_END"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_UNK: + sprintf(*buf, "P_MINUS_Y_VV_MINUS_Y_VV_UNK"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK: + sprintf(*buf, "P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK"); + break; + case P_MINUS_Y_CV_INSTINIT: + sprintf(*buf, "P_MINUS_Y_CV_INSTINIT"); + break; + case P_MINUS_Y_CV_MINUS_Y_CV_NVAR: + sprintf(*buf, "P_MINUS_Y_CV_MINUS_Y_CV_NVAR"); + break; + case P_MINUS_Y_CV_INTTERM: + sprintf(*buf, "P_MINUS_Y_CV_INTTERM"); + break; + case P_MINUS_Y_CV_NOINTTERM: + sprintf(*buf, "P_MINUS_Y_CV_NOINTTERM"); + break; + case P_MINUS_Y_CV_D0EQUALS0L: + sprintf(*buf, "P_MINUS_Y_CV_D0EQUALS0L"); + break; + case P_MINUS_Y_CV_NVAR_END: + sprintf(*buf, "P_MINUS_Y_CV_NVAR_END"); + break; + case P_MINUS_Y_CV_MINUS_Y_CV_UNK: + sprintf(*buf, "P_MINUS_Y_CV_MINUS_Y_CV_UNK"); + break; + case P_TIMES_VV_INSTINIT: + sprintf(*buf, "P_TIMES_VV_INSTINIT"); + break; + case P_TIMES_VV_TIMES_VV_NVAR: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_NVAR"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT"); + break; + case P_TIMES_VV_TIMES_VV_UNK: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_UNK"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_UNK: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_NVAR_UNK"); + break; + case P_TIMES_VC_INSTINIT: + sprintf(*buf, "P_TIMES_VC_INSTINIT"); + break; + case P_TIMES_VC_TIMES_VC_NVAR_INT: + sprintf(*buf, "P_TIMES_VC_TIMES_VC_NVAR_INT"); + break; + case P_TIMES_VC_TIMES_VC_NVAR_NOINT: + sprintf(*buf, "P_TIMES_VC_TIMES_VC_NVAR_NOINT"); + break; + case P_TIMES_VC_TIMES_VC_UNK: + sprintf(*buf, "P_TIMES_VC_TIMES_VC_UNK"); + break; + case P_TIMES_Y_VV_INSTINIT: + sprintf(*buf, "P_TIMES_Y_VV_INSTINIT"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_NVAR: + sprintf(*buf, "P_TIMES_Y_VV_TIMES_Y_VV_NVAR"); + break; + case P_TIMES_Y_VV_INTTERM: + sprintf(*buf, "P_TIMES_Y_VV_INTTERM"); + break; + case P_TIMES_Y_VV_NOINTTERM: + sprintf(*buf, "P_TIMES_Y_VV_NOINTTERM"); + break; + case P_TIMES_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_TIMES_Y_VV_D0EQUALS0L"); + break; + case P_TIMES_Y_VV_NVAR_END: + sprintf(*buf, "P_TIMES_Y_VV_NVAR_END"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_UNK: + sprintf(*buf, "P_TIMES_Y_VV_TIMES_Y_VV_UNK"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK: + sprintf(*buf, "P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK"); + break; + case P_TIMES_Y_VC_INSTINIT: + sprintf(*buf, "P_TIMES_Y_VC_INSTINIT"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT: + sprintf(*buf, "P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT: + sprintf(*buf, "P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT"); + break; + case P_TIMES_Y_VC_NVAR_END: + sprintf(*buf, "P_TIMES_Y_VC_NVAR_END"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_UNK: + sprintf(*buf, "P_TIMES_Y_VC_TIMES_Y_VC_UNK"); + break; + case P_DIV_VV_INSTINIT: + sprintf(*buf, "P_DIV_VV_INSTINIT"); + break; + case P_DIV_VV_DIV_VV_NVAR: + sprintf(*buf, "P_DIV_VV_DIV_VV_NVAR"); + break; + case P_DIV_VV_DIV_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_DIV_VV_DIV_VV_NVAR_NVAR_INT"); + break; + case P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT"); + break; + case P_DIV_VV_DIV_VV_UNK: + sprintf(*buf, "P_DIV_VV_DIV_VV_UNK"); + break; + case P_DIV_VV_DIV_VV_NVAR_UNK: + sprintf(*buf, "P_DIV_VV_DIV_VV_NVAR_UNK"); + break; + case P_DIV_VC_INSTINIT: + sprintf(*buf, "P_DIV_VC_INSTINIT"); + break; + case P_DIV_VC_DIV_VC_NVAR: + sprintf(*buf, "P_DIV_VC_DIV_VC_NVAR"); + break; + case P_DIV_VC_INTTERM: + sprintf(*buf, "P_DIV_VC_INTTERM"); + break; + case P_DIV_VC_NOINTTERM: + sprintf(*buf, "P_DIV_VC_NOINTTERM"); + break; + case P_DIV_VC_D0EQUALS0L: + sprintf(*buf, "P_DIV_VC_D0EQUALS0L"); + break; + case P_DIV_VC_NVAR_END: + sprintf(*buf, "P_DIV_VC_NVAR_END"); + break; + case P_DIV_VC_DIV_VC_UNK: + sprintf(*buf, "P_DIV_VC_DIV_VC_UNK"); + break; + case P_DIV_CV_INSTINIT: + sprintf(*buf, "P_DIV_CV_INSTINIT"); + break; + case P_DIV_CV_DIV_CV_NVAR: + sprintf(*buf, "P_DIV_CV_DIV_CV_NVAR"); + break; + case P_DIV_CV_INTTERM_INIT: + sprintf(*buf, "P_DIV_CV_INTTERM_INIT"); + break; + case P_DIV_CV_INTTERM_DIVEQUALS0: + sprintf(*buf, "P_DIV_CV_INTTERM_DIVEQUALS0"); + break; + case P_DIV_CV_INTTERM_END: + sprintf(*buf, "P_DIV_CV_INTTERM_END"); + break; + case P_DIV_CV_NOINTTERM: + sprintf(*buf, "P_DIV_CV_NOINTTERM"); + break; + case P_DIV_CV_D0EQUALS0L: + sprintf(*buf, "P_DIV_CV_D0EQUALS0L"); + break; + case P_DIV_CV_NVAR_END: + sprintf(*buf, "P_DIV_CV_NVAR_END"); + break; + case P_DIV_CV_DIV_CV_UNK: + sprintf(*buf, "P_DIV_CV_DIV_CV_UNK"); + break; + case P_DIV_Y_VV_INSTINIT: + sprintf(*buf, "P_DIV_Y_VV_INSTINIT"); + break; + case P_DIV_Y_VV_DIV_Y_VV_NVAR: + sprintf(*buf, "P_DIV_Y_VV_DIV_Y_VV_NVAR"); + break; + case P_DIV_Y_VV_INTTERM_INIT: + sprintf(*buf, "P_DIV_Y_VV_INTTERM_INIT"); + break; + case P_DIV_Y_VV_INTTERM_DIVEQUALS0: + sprintf(*buf, "P_DIV_Y_VV_INTTERM_DIVEQUALS0"); + break; + case P_DIV_Y_VV_INTTERM_END: + sprintf(*buf, "P_DIV_Y_VV_INTTERM_END"); + break; + case P_DIV_Y_VV_NOINTTERM: + sprintf(*buf, "P_DIV_Y_VV_NOINTTERM"); + break; + case P_DIV_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_DIV_Y_VV_D0EQUALS0L"); + break; + case P_DIV_Y_VV_NVAR_END: + sprintf(*buf, "P_DIV_Y_VV_NVAR_END"); + break; + case P_DIV_Y_VV_DIV_Y_VV_UNK: + sprintf(*buf, "P_DIV_Y_VV_DIV_Y_VV_UNK"); + break; + case P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK: + sprintf(*buf, "P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK"); + break; + case P_DIV_Y_VC_INSTINIT: + sprintf(*buf, "P_DIV_Y_VC_INSTINIT"); + break; + case P_DIV_Y_VC_DIV_Y_VC_NVAR: + sprintf(*buf, "P_DIV_Y_VC_DIV_Y_VC_NVAR"); + break; + case P_DIV_Y_VC_INTTERM: + sprintf(*buf, "P_DIV_Y_VC_INTTERM"); + break; + case P_DIV_Y_VC_NOINTTERM: + sprintf(*buf, "P_DIV_Y_VC_NOINTTERM"); + break; + case P_DIV_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_DIV_Y_VC_D0EQUALS0L"); + break; + case P_DIV_Y_VC_NVAR_END: + sprintf(*buf, "P_DIV_Y_VC_NVAR_END"); + break; + case P_DIV_Y_VC_DIV_Y_VC_UNK: + sprintf(*buf, "P_DIV_Y_VC_DIV_Y_VC_UNK"); + break; + case P_DIV_Y_CV_INSTINIT: + sprintf(*buf, "P_DIV_Y_CV_INSTINIT"); + break; + case P_DIV_Y_CV_DIV_Y_CV_NVAR: + sprintf(*buf, "P_DIV_Y_CV_DIV_Y_CV_NVAR"); + break; + case P_DIV_Y_CV_INTTERM_INIT: + sprintf(*buf, "P_DIV_Y_CV_INTTERM_INIT"); + break; + case P_DIV_Y_CV_INTTERM_DIVEQUALS0: + sprintf(*buf, "P_DIV_Y_CV_INTTERM_DIVEQUALS0"); + break; + case P_DIV_Y_CV_INTTERM_END: + sprintf(*buf, "P_DIV_Y_CV_INTTERM_END"); + break; + case P_DIV_Y_CV_NOINTTERM: + sprintf(*buf, "P_DIV_Y_CV_NOINTTERM"); + break; + case P_DIV_Y_CV_D0EQUALS0L: + sprintf(*buf, "P_DIV_Y_CV_D0EQUALS0L"); + break; + case P_DIV_Y_CV_NVAR_END: + sprintf(*buf, "P_DIV_Y_CV_NVAR_END"); + break; + case P_DIV_Y_CV_DIV_Y_CV_UNK: + sprintf(*buf, "P_DIV_Y_CV_DIV_Y_CV_UNK"); + break; + case P_AND_VV_INSTINIT: + sprintf(*buf, "P_AND_VV_INSTINIT"); + break; + case P_AND_VV_AND_VV_NVAR: + sprintf(*buf, "P_AND_VV_AND_VV_NVAR"); + break; + case P_AND_VV_AND_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_AND_VV_AND_VV_NVAR_NVAR_INT"); + break; + case P_AND_VV_AND_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_AND_VV_AND_VV_NVAR_NVAR_NOINT"); + break; + case P_AND_VV_AND_VV_UNK: + sprintf(*buf, "P_AND_VV_AND_VV_UNK"); + break; + case P_AND_VV_AND_VV_NVAR_UNK: + sprintf(*buf, "P_AND_VV_AND_VV_NVAR_UNK"); + break; + case P_AND_VC_INSTINIT: + sprintf(*buf, "P_AND_VC_INSTINIT"); + break; + case P_AND_VC_AND_VC_NVAR_INT: + sprintf(*buf, "P_AND_VC_AND_VC_NVAR_INT"); + break; + case P_AND_VC_AND_VC_NVAR_NOINT: + sprintf(*buf, "P_AND_VC_AND_VC_NVAR_NOINT"); + break; + case P_AND_VC_AND_VC_UNK: + sprintf(*buf, "P_AND_VC_AND_VC_UNK"); + break; + case P_AND_Y_VV_INSTINIT: + sprintf(*buf, "P_AND_Y_VV_INSTINIT"); + break; + case P_AND_Y_VV_AND_Y_VV_NVAR: + sprintf(*buf, "P_AND_Y_VV_AND_Y_VV_NVAR"); + break; + case P_AND_Y_VV_INTTERM: + sprintf(*buf, "P_AND_Y_VV_INTTERM"); + break; + case P_AND_Y_VV_NOINTTERM: + sprintf(*buf, "P_AND_Y_VV_NOINTTERM"); + break; + case P_AND_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_AND_Y_VV_D0EQUALS0L"); + break; + case P_AND_Y_VV_NVAR_END: + sprintf(*buf, "P_AND_Y_VV_NVAR_END"); + break; + case P_AND_Y_VV_AND_Y_VV_UNK: + sprintf(*buf, "P_AND_Y_VV_AND_Y_VV_UNK"); + break; + case P_AND_Y_VV_AND_Y_VV_NVAR_UNK: + sprintf(*buf, "P_AND_Y_VV_AND_Y_VV_NVAR_UNK"); + break; + case P_AND_Y_VC_INSTINIT: + sprintf(*buf, "P_AND_Y_VC_INSTINIT"); + break; + case P_AND_Y_VC_AND_Y_VC_NVAR: + sprintf(*buf, "P_AND_Y_VC_AND_Y_VC_NVAR"); + break; + case P_AND_Y_VC_INTTERM: + sprintf(*buf, "P_AND_Y_VC_INTTERM"); + break; + case P_AND_Y_VC_NOINTTERM: + sprintf(*buf, "P_AND_Y_VC_NOINTTERM"); + break; + case P_AND_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_AND_Y_VC_D0EQUALS0L"); + break; + case P_AND_Y_VC_NVAR_END: + sprintf(*buf, "P_AND_Y_VC_NVAR_END"); + break; + case P_AND_Y_VC_AND_Y_VC_UNK: + sprintf(*buf, "P_AND_Y_VC_AND_Y_VC_UNK"); + break; + case P_OR_VV_INSTINIT: + sprintf(*buf, "P_OR_VV_INSTINIT"); + break; + case P_OR_VV_OR_VV_NVAR: + sprintf(*buf, "P_OR_VV_OR_VV_NVAR"); + break; + case P_OR_VV_INTTERM: + sprintf(*buf, "P_OR_VV_INTTERM"); + break; + case P_OR_VV_NOINTTERM: + sprintf(*buf, "P_OR_VV_NOINTTERM"); + break; + case P_OR_VV_D0EQUALS0L: + sprintf(*buf, "P_OR_VV_D0EQUALS0L"); + break; + case P_OR_VV_NVAR_END: + sprintf(*buf, "P_OR_VV_NVAR_END"); + break; + case P_OR_VV_OR_VV_UNK: + sprintf(*buf, "P_OR_VV_OR_VV_UNK"); + break; + case P_OR_VV_OR_VV_NVAR_UNK: + sprintf(*buf, "P_OR_VV_OR_VV_NVAR_UNK"); + break; + case P_OR_VC_INSTINIT: + sprintf(*buf, "P_OR_VC_INSTINIT"); + break; + case P_OR_VC_OR_VC_NVAR: + sprintf(*buf, "P_OR_VC_OR_VC_NVAR"); + break; + case P_OR_VC_INTTERM: + sprintf(*buf, "P_OR_VC_INTTERM"); + break; + case P_OR_VC_NOINTTERM: + sprintf(*buf, "P_OR_VC_NOINTTERM"); + break; + case P_OR_VC_D0EQUALS0L: + sprintf(*buf, "P_OR_VC_D0EQUALS0L"); + break; + case P_OR_VC_NVAR_END: + sprintf(*buf, "P_OR_VC_NVAR_END"); + break; + case P_OR_VC_OR_VC_UNK: + sprintf(*buf, "P_OR_VC_OR_VC_UNK"); + break; + case P_OR_Y_VV_INSTINIT: + sprintf(*buf, "P_OR_Y_VV_INSTINIT"); + break; + case P_OR_Y_VV_OR_Y_VV_NVAR: + sprintf(*buf, "P_OR_Y_VV_OR_Y_VV_NVAR"); + break; + case P_OR_Y_VV_INTTERM: + sprintf(*buf, "P_OR_Y_VV_INTTERM"); + break; + case P_OR_Y_VV_NOINTTERM: + sprintf(*buf, "P_OR_Y_VV_NOINTTERM"); + break; + case P_OR_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_OR_Y_VV_D0EQUALS0L"); + break; + case P_OR_Y_VV_NVAR_END: + sprintf(*buf, "P_OR_Y_VV_NVAR_END"); + break; + case P_OR_Y_VV_OR_Y_VV_UNK: + sprintf(*buf, "P_OR_Y_VV_OR_Y_VV_UNK"); + break; + case P_OR_Y_VV_OR_Y_VV_NVAR_UNK: + sprintf(*buf, "P_OR_Y_VV_OR_Y_VV_NVAR_UNK"); + break; + case P_OR_Y_VC_INSTINIT: + sprintf(*buf, "P_OR_Y_VC_INSTINIT"); + break; + case P_OR_Y_VC_OR_Y_VC_NVAR: + sprintf(*buf, "P_OR_Y_VC_OR_Y_VC_NVAR"); + break; + case P_OR_Y_VC_INTTERM: + sprintf(*buf, "P_OR_Y_VC_INTTERM"); + break; + case P_OR_Y_VC_NOINTTERM: + sprintf(*buf, "P_OR_Y_VC_NOINTTERM"); + break; + case P_OR_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_OR_Y_VC_D0EQUALS0L"); + break; + case P_OR_Y_VC_NVAR_END: + sprintf(*buf, "P_OR_Y_VC_NVAR_END"); + break; + case P_OR_Y_VC_OR_Y_VC_UNK: + sprintf(*buf, "P_OR_Y_VC_OR_Y_VC_UNK"); + break; + case P_SLL_VV_INSTINIT: + sprintf(*buf, "P_SLL_VV_INSTINIT"); + break; + case P_SLL_VV_SLL_VV_NVAR: + sprintf(*buf, "P_SLL_VV_SLL_VV_NVAR"); + break; + case P_SLL_VV_INTTERM_INIT: + sprintf(*buf, "P_SLL_VV_INTTERM_INIT"); + break; + case P_SLL_VV_INTTERM_LESS: + sprintf(*buf, "P_SLL_VV_INTTERM_LESS"); + break; + case P_SLL_VV_INTTERM_GREATER: + sprintf(*buf, "P_SLL_VV_INTTERM_GREATER"); + break; + case P_SLL_VV_NOINTTERM: + sprintf(*buf, "P_SLL_VV_NOINTTERM"); + break; + case P_SLL_VV_D0EQUALS0L: + sprintf(*buf, "P_SLL_VV_D0EQUALS0L"); + break; + case P_SLL_VV_NVAR_END: + sprintf(*buf, "P_SLL_VV_NVAR_END"); + break; + case P_SLL_VV_SLL_VV_UNK: + sprintf(*buf, "P_SLL_VV_SLL_VV_UNK"); + break; + case P_SLL_VV_SLL_VV_NVAR_UNK: + sprintf(*buf, "P_SLL_VV_SLL_VV_NVAR_UNK"); + break; + case P_SLL_VC_INSTINIT: + sprintf(*buf, "P_SLL_VC_INSTINIT"); + break; + case P_SLL_VC_SLL_VC_NVAR: + sprintf(*buf, "P_SLL_VC_SLL_VC_NVAR"); + break; + case P_SLL_VC_INTTERM: + sprintf(*buf, "P_SLL_VC_INTTERM"); + break; + case P_SLL_VC_NOINTTERM: + sprintf(*buf, "P_SLL_VC_NOINTTERM"); + break; + case P_SLL_VC_D0EQUALS0L: + sprintf(*buf, "P_SLL_VC_D0EQUALS0L"); + break; + case P_SLL_VC_NVAR_END: + sprintf(*buf, "P_SLL_VC_NVAR_END"); + break; + case P_SLL_VC_SLL_VC_UNK: + sprintf(*buf, "P_SLL_VC_SLL_VC_UNK"); + break; + case P_SLL_CV_INSTINIT: + sprintf(*buf, "P_SLL_CV_INSTINIT"); + break; + case P_SLL_CV_SLL_CV_NVAR_INT: + sprintf(*buf, "P_SLL_CV_SLL_CV_NVAR_INT"); + break; + case P_SLL_CV_SLL_CV_NVAR_NOINT: + sprintf(*buf, "P_SLL_CV_SLL_CV_NVAR_NOINT"); + break; + case P_SLL_CV_SLL_CV_UNK: + sprintf(*buf, "P_SLL_CV_SLL_CV_UNK"); + break; + case P_SLL_Y_VV_INSTINIT: + sprintf(*buf, "P_SLL_Y_VV_INSTINIT"); + break; + case P_SLL_Y_VV_SLL_Y_VV_NVAR: + sprintf(*buf, "P_SLL_Y_VV_SLL_Y_VV_NVAR"); + break; + case P_SLL_Y_VV_INTTERM_INIT: + sprintf(*buf, "P_SLL_Y_VV_INTTERM_INIT"); + break; + case P_SLL_Y_VV_INTERM_LESS: + sprintf(*buf, "P_SLL_Y_VV_INTERM_LESS"); + break; + case P_SLL_Y_VV_INTTERM_GREATER: + sprintf(*buf, "P_SLL_Y_VV_INTTERM_GREATER"); + break; + case P_SLL_Y_VV_NOINTTERM: + sprintf(*buf, "P_SLL_Y_VV_NOINTTERM"); + break; + case P_SLL_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_SLL_Y_VV_D0EQUALS0L"); + break; + case P_SLL_Y_VV_NVAR_END: + sprintf(*buf, "P_SLL_Y_VV_NVAR_END"); + break; + case P_SLL_Y_VV_SLL_Y_VV_UNK: + sprintf(*buf, "P_SLL_Y_VV_SLL_Y_VV_UNK"); + break; + case P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK: + sprintf(*buf, "P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK"); + break; + case P_SLL_Y_VC_INSTINIT: + sprintf(*buf, "P_SLL_Y_VC_INSTINIT"); + break; + case P_SLL_Y_VC_SLL_Y_VC_NVAR: + sprintf(*buf, "P_SLL_Y_VC_SLL_Y_VC_NVAR"); + break; + case P_SLL_Y_VC_INTTERM: + sprintf(*buf, "P_SLL_Y_VC_INTTERM"); + break; + case P_SLL_Y_VC_NOINTTERM: + sprintf(*buf, "P_SLL_Y_VC_NOINTTERM"); + break; + case P_SLL_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_SLL_Y_VC_D0EQUALS0L"); + break; + case P_SLL_Y_VC_NVAR_END: + sprintf(*buf, "P_SLL_Y_VC_NVAR_END"); + break; + case P_SLL_Y_VC_SLL_Y_VC_UNK: + sprintf(*buf, "P_SLL_Y_VC_SLL_Y_VC_UNK"); + break; + case P_SLL_Y_CV_INSTINIT: + sprintf(*buf, "P_SLL_Y_CV_INSTINIT"); + break; + case P_SLL_Y_CV_SLL_Y_CV_NVAR: + sprintf(*buf, "P_SLL_Y_CV_SLL_Y_CV_NVAR"); + break; + case P_SLL_Y_CV_INTTERM_INIT: + sprintf(*buf, "P_SLL_Y_CV_INTTERM_INIT"); + break; + case P_SLL_Y_CV_INTTERM_LESS: + sprintf(*buf, "P_SLL_Y_CV_INTTERM_LESS"); + break; + case P_SLL_Y_CV_INTTERM_GREATER: + sprintf(*buf, "P_SLL_Y_CV_INTTERM_GREATER"); + break; + case P_SLL_Y_CV_NOINTTERM: + sprintf(*buf, "P_SLL_Y_CV_NOINTTERM"); + break; + case P_SLL_Y_CV_D0EQUALS0L: + sprintf(*buf, "P_SLL_Y_CV_D0EQUALS0L"); + break; + case P_SLL_Y_CV_NVAR_END: + sprintf(*buf, "P_SLL_Y_CV_NVAR_END"); + break; + case P_SLL_Y_CV_SLL_Y_CV_UNK: + sprintf(*buf, "P_SLL_Y_CV_SLL_Y_CV_UNK"); + break; + case P_SLR_VV_INSTINIT: + sprintf(*buf, "P_SLR_VV_INSTINIT"); + break; + case P_SLR_VV_SLR_VV_NVAR: + sprintf(*buf, "P_SLR_VV_SLR_VV_NVAR"); + break; + case P_SLR_VV_INTTERM_INIT: + sprintf(*buf, "P_SLR_VV_INTTERM_INIT"); + break; + case P_SLR_VV_INTTERM_LESS: + sprintf(*buf, "P_SLR_VV_INTTERM_LESS"); + break; + case P_SLR_VV_INTTERM_GREATER: + sprintf(*buf, "P_SLR_VV_INTTERM_GREATER"); + break; + case P_SLR_VV_NOINTTERM: + sprintf(*buf, "P_SLR_VV_NOINTTERM"); + break; + case P_SLR_VV_D0EQUALS0L: + sprintf(*buf, "P_SLR_VV_D0EQUALS0L"); + break; + case P_SLR_VV_NVAR_END: + sprintf(*buf, "P_SLR_VV_NVAR_END"); + break; + case P_SLR_VV_SRL_VV_UNK: + sprintf(*buf, "P_SLR_VV_SRL_VV_UNK"); + break; + case P_SLR_VV_SRL_VV_NVAR_UNK: + sprintf(*buf, "P_SLR_VV_SRL_VV_NVAR_UNK"); + break; + case P_SLR_VC_INSTINIT: + sprintf(*buf, "P_SLR_VC_INSTINIT"); + break; + case P_SLR_VC_SLR_VC_NVAR_INT: + sprintf(*buf, "P_SLR_VC_SLR_VC_NVAR_INT"); + break; + case P_SLR_VC_SLR_VC_NVAR_NOINT: + sprintf(*buf, "P_SLR_VC_SLR_VC_NVAR_NOINT"); + break; + case P_SLR_VC_SRL_VC_UNK: + sprintf(*buf, "P_SLR_VC_SRL_VC_UNK"); + break; + case P_SLR_CV_INSTINIT: + sprintf(*buf, "P_SLR_CV_INSTINIT"); + break; + case P_SLR_CV_SLR_CV_NVAR: + sprintf(*buf, "P_SLR_CV_SLR_CV_NVAR"); + break; + case P_SLR_CV_INTTERM_INIT: + sprintf(*buf, "P_SLR_CV_INTTERM_INIT"); + break; + case P_SLR_CV_INTTERM_LESS: + sprintf(*buf, "P_SLR_CV_INTTERM_LESS"); + break; + case P_SLR_CV_INTTERM_GREATER: + sprintf(*buf, "P_SLR_CV_INTTERM_GREATER"); + break; + case P_SLR_CV_NOINTTERM: + sprintf(*buf, "P_SLR_CV_NOINTTERM"); + break; + case P_SLR_CV_D0EQUALS0L: + sprintf(*buf, "P_SLR_CV_D0EQUALS0L"); + break; + case P_SLR_CV_NVAR_END: + sprintf(*buf, "P_SLR_CV_NVAR_END"); + break; + case P_SLR_CV_SLR_CV_UNK: + sprintf(*buf, "P_SLR_CV_SLR_CV_UNK"); + break; + case P_SLR_Y_VV_INSTINIT: + sprintf(*buf, "P_SLR_Y_VV_INSTINIT"); + break; + case P_SLR_Y_VV_SLR_Y_VV_NVAR: + sprintf(*buf, "P_SLR_Y_VV_SLR_Y_VV_NVAR"); + break; + case P_SLR_Y_VV_INTTERM_INIT: + sprintf(*buf, "P_SLR_Y_VV_INTTERM_INIT"); + break; + case P_SLR_Y_VV_INTTERM_LESS: + sprintf(*buf, "P_SLR_Y_VV_INTTERM_LESS"); + break; + case P_SLR_Y_VV_INTTERM_GREATER: + sprintf(*buf, "P_SLR_Y_VV_INTTERM_GREATER"); + break; + case P_SLR_Y_VV_NOINTTERM: + sprintf(*buf, "P_SLR_Y_VV_NOINTTERM"); + break; + case P_SLR_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_SLR_Y_VV_D0EQUALS0L"); + break; + case P_SLR_Y_VV_NVAR_END: + sprintf(*buf, "P_SLR_Y_VV_NVAR_END"); + break; + case P_SLR_Y_VV_SLR_Y_VV_UNK: + sprintf(*buf, "P_SLR_Y_VV_SLR_Y_VV_UNK"); + break; + case P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK: + sprintf(*buf, "P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK"); + break; + case P_SLR_Y_VC_INSTINIT: + sprintf(*buf, "P_SLR_Y_VC_INSTINIT"); + break; + case P_SLR_Y_VC_SLR_Y_VC_NVAR: + sprintf(*buf, "P_SLR_Y_VC_SLR_Y_VC_NVAR"); + break; + case P_SLR_Y_VC_INTTERM: + sprintf(*buf, "P_SLR_Y_VC_INTTERM"); + break; + case P_SLR_Y_VC_NOINTTERM: + sprintf(*buf, "P_SLR_Y_VC_NOINTTERM"); + break; + case P_SLR_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_SLR_Y_VC_D0EQUALS0L"); + break; + case P_SLR_Y_VC_NVAR_END: + sprintf(*buf, "P_SLR_Y_VC_NVAR_END"); + break; + case P_SLR_Y_VC_SLR_Y_VC_UNK: + sprintf(*buf, "P_SLR_Y_VC_SLR_Y_VC_UNK"); + break; + case P_SLR_Y_CV_INSTINIT: + sprintf(*buf, "P_SLR_Y_CV_INSTINIT"); + break; + case P_SLR_Y_CV_SLR_Y_CV_NVAR: + sprintf(*buf, "P_SLR_Y_CV_SLR_Y_CV_NVAR"); + break; + case P_SLR_Y_CV_INTTERM_INIT: + sprintf(*buf, "P_SLR_Y_CV_INTTERM_INIT"); + break; + case P_SLR_Y_CV_INTTERM_LESS: + sprintf(*buf, "P_SLR_Y_CV_INTTERM_LESS"); + break; + case P_SLR_Y_CV_INTTERM_GREATER: + sprintf(*buf, "P_SLR_Y_CV_INTTERM_GREATER"); + break; + case P_SLR_Y_CV_NOINTTERM: + sprintf(*buf, "P_SLR_Y_CV_NOINTTERM"); + break; + case P_SLR_Y_CV_D0EQUALS0L: + sprintf(*buf, "P_SLR_Y_CV_D0EQUALS0L"); + break; + case P_SLR_Y_CV_NVAR_END: + sprintf(*buf, "P_SLR_Y_CV_NVAR_END"); + break; + case P_SLR_Y_CV_SLR_Y_CV_UNK: + sprintf(*buf, "P_SLR_Y_CV_SLR_Y_CV_UNK"); + break; + case CALL_BFUNC_XX_INSTINIT: + sprintf(*buf, "CALL_BFUNC_XX_INSTINIT"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR: + sprintf(*buf, "CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT: + sprintf(*buf, "CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT: + sprintf(*buf, "CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX_UNK: + sprintf(*buf, "CALL_BFUNC_XX_CALL_BFUNC_XX_UNK"); + break; + case CALL_BFUNC_YX_INSTINIT: + sprintf(*buf, "CALL_BFUNC_YX_INSTINIT"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT: + sprintf(*buf, "CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT: + sprintf(*buf, "CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX_UNK: + sprintf(*buf, "CALL_BFUNC_YX_CALL_BFUNC_YX_UNK"); + break; + case CALL_BFUNC_XY_INSTINIT: + sprintf(*buf, "CALL_BFUNC_XY_INSTINIT"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT: + sprintf(*buf, "CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT: + sprintf(*buf, "CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY_UNK: + sprintf(*buf, "CALL_BFUNC_XY_CALL_BFUNC_XY_UNK"); + break; + case CALL_BFUNC_YY_INSTINIT: + sprintf(*buf, "CALL_BFUNC_YY_INSTINIT"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT: + sprintf(*buf, "CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT: + sprintf(*buf, "CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY_UNK: + sprintf(*buf, "CALL_BFUNC_YY_CALL_BFUNC_YY_UNK"); + break; + case P_EQUAL_INSTINIT: + sprintf(*buf, "P_EQUAL_INSTINIT"); + break; + case P_EQUAL_END: + sprintf(*buf, "P_EQUAL_END"); + break; + case P_DIF_INSTINIT: + sprintf(*buf, "P_DIF_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_DIF_LOW_LEVEL_TRACER: + sprintf(*buf, "P_DIF_LOW_LEVEL_TRACER"); + break; +#endif + case P_DIF_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "P_DIF_POST_LOW_LEVEL_TRACER"); + break; + case P_DIF_DIF_NVAR1: + sprintf(*buf, "P_DIF_DIF_NVAR1"); + break; + case P_DIF_DIF_NVAR1_NVAR2: + sprintf(*buf, "P_DIF_DIF_NVAR1_NVAR2"); + break; + break; + case P_DIF_DIF_UNK1: + sprintf(*buf, "P_DIF_DIF_UNK1"); + break; + case P_DIF_DIF_NVAR1_UNK2: + sprintf(*buf, "P_DIF_DIF_NVAR1_UNK2"); + break; + case P_EQ_INSTINIT: + sprintf(*buf, "P_EQ_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_EQ_LOW_LEVEL_TRACER: + sprintf(*buf, "P_EQ_LOW_LEVEL_TRACER"); + break; +#endif + case P_EQ_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "P_EQ_POST_LOW_LEVEL_TRACER"); + break; + case P_EQ_P_EQ_NVAR1: + sprintf(*buf, "P_EQ_P_EQ_NVAR1"); + break; + case P_EQ_P_EQ_NVAR1_NVAR2: + sprintf(*buf, "P_EQ_P_EQ_NVAR1_NVAR2"); + break; + case P_EQ_P_EQ_NVAR1_UNK2: + sprintf(*buf, "P_EQ_P_EQ_NVAR1_UNK2"); + break; + case P_EQ_P_EQ_UNK1: + sprintf(*buf, "P_EQ_P_EQ_UNK1"); + break; + case P_EQ_P_EQ_VAR1_NVAR2: + sprintf(*buf, "P_EQ_P_EQ_VAR1_NVAR2"); + break; + case P_EQ_P_EQ_VAR1_UNK2_END: + sprintf(*buf, "P_EQ_P_EQ_VAR1_UNK2_END"); + break; + case P_ARG_VV_INSTINIT: + sprintf(*buf, "P_ARG_VV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_VV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_ARG_VV_LOW_LEVEL_TRACER"); + break; +#endif + case P_ARG_VV_TEST_D0: + sprintf(*buf, "P_ARG_VV_TEST_D0"); + break; + case P_ARG_VV_ARG_ARG1_NVAR: + sprintf(*buf, "P_ARG_VV_ARG_ARG1_NVAR"); + break; + case P_ARG_VV_TEST_D1: + sprintf(*buf, "P_ARG_VV_TEST_D1"); + break; + case P_ARG_VV_ARG_ARG2_NVAR: + sprintf(*buf, "P_ARG_VV_ARG_ARG2_NVAR"); + break; + case P_ARG_VV_ARG_ARG2_UNK: + sprintf(*buf, "P_ARG_VV_ARG_ARG2_UNK"); + break; + case P_ARG_VV_ARG_ARG1_UNK: + sprintf(*buf, "P_ARG_VV_ARG_ARG1_UNK"); + break; + case P_ARG_CV_INSTINIT: + sprintf(*buf, "P_ARG_CV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_CV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_ARG_CV_LOW_LEVEL_TRACER"); + break; +#endif + case P_ARG_CV_TEST_D1: + sprintf(*buf, "P_ARG_CV_TEST_D1"); + break; + case P_ARG_CV_ARG_ARG2_VC_NVAR: + sprintf(*buf, "P_ARG_CV_ARG_ARG2_VC_NVAR"); + break; + case P_ARG_CV_ARG_ARG2_VC_UNK: + sprintf(*buf, "P_ARG_CV_ARG_ARG2_VC_UNK"); + break; + case P_ARG_Y_VV_INSTINIT: + sprintf(*buf, "P_ARG_Y_VV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_Y_VV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_ARG_Y_VV_LOW_LEVEL_TRACER"); + break; +#endif + case P_ARG_Y_VV_TEST_D0: + sprintf(*buf, "P_ARG_Y_VV_TEST_D0"); + break; + case P_ARG_Y_VV_ARG_Y_ARG1_NVAR: + sprintf(*buf, "P_ARG_Y_VV_ARG_Y_ARG1_NVAR"); + break; + case P_ARG_Y_VV_TEST_D1: + sprintf(*buf, "P_ARG_Y_VV_TEST_D1"); + break; + case P_ARG_Y_VV_ARG_Y_ARG2_NVAR: + sprintf(*buf, "P_ARG_Y_VV_ARG_Y_ARG2_NVAR"); + break; + case P_ARG_Y_VV_ARG_Y_ARG2_UNK: + sprintf(*buf, "P_ARG_Y_VV_ARG_Y_ARG2_UNK"); + break; + case P_ARG_Y_VV_ARG_Y_ARG1_UNK: + sprintf(*buf, "P_ARG_Y_VV_ARG_Y_ARG1_UNK"); + break; + case P_ARG_Y_CV_INSTINIT: + sprintf(*buf, "P_ARG_Y_CV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_Y_CV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_ARG_Y_CV_LOW_LEVEL_TRACER"); + break; +#endif + case P_ARG_Y_CV_TEST_D1: + sprintf(*buf, "P_ARG_Y_CV_TEST_D1"); + break; + case P_ARG_Y_CV_D1APPL_INIT: + sprintf(*buf, "P_ARG_Y_CV_D1APPL_INIT"); + break; + case P_ARG_Y_CV_D1APPL_END: + sprintf(*buf, "P_ARG_Y_CV_D1APPL_END"); + break; + case P_ARG_Y_CV_D1PAIR_INIT: + sprintf(*buf, "P_ARG_Y_CV_D1PAIR_INIT"); + break; + case P_ARG_Y_CV_D1PAIR_LESS0: + sprintf(*buf, "P_ARG_Y_CV_D1PAIR_LESS0"); + break; + case P_ARG_Y_CV_D1PAIR_END: + sprintf(*buf, "P_ARG_Y_CV_D1PAIR_END"); + break; + case P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK: + sprintf(*buf, "P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK"); + break; + case P_FUNCTOR_INSTINIT: + sprintf(*buf, "P_FUNCTOR_INSTINIT"); + break; + case P_FUNCTOR_END: + sprintf(*buf, "P_FUNCTOR_END"); + break; + case P_FUNC2S_VV_INSTINIT: + sprintf(*buf, "P_FUNC2S_VV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_VV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_VV_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_TEST_D0: + sprintf(*buf, "P_FUNC2S_TEST_D0"); + break; + case P_FUNC2S_VV_TEST_D1: + sprintf(*buf, "P_FUNC2S_VV_TEST_D1"); + break; + case P_FUNC2S_VV_D1INT: + sprintf(*buf, "P_FUNC2S_VV_D1INT"); + break; + case P_FUNC2S_VV_D1NOTINT: + sprintf(*buf, "P_FUNC2S_VV_D1NOTINT"); + break; + case P_FUNC2S_VV_D1BIGINT: + sprintf(*buf, "P_FUNC2S_VV_D1BIGINT"); + break; + case P_FUNC2S_VV_D1NOTBIGINT: + sprintf(*buf, "P_FUNC2S_VV_D1NOTBIGINT"); + break; + case P_FUNC2S_VV_D1NOTINT_END: + sprintf(*buf, "P_FUNC2S_VV_D1NOTINT_END"); + break; + case P_FUNC2S_VV_D0NOTATOMIC: + sprintf(*buf, "P_FUNC2S_VV_D0NOTATOMIC"); + break; + case P_FUNC2S_VV_FIRSTIFOK: + sprintf(*buf, "P_FUNC2S_VV_FIRSTIFOK"); + break; + case P_FUNC2S_VV_SECONDIFOK_D0NOTATOM: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_D0NOTATOM"); + break; + case P_FUNC2S_VV_SECONDIFOK_D0ATOM: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_D0ATOM"); + break; + case P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF"); + break; + case P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE"); + break; + case P_FUNC2S_VV_SECONDIFOK_END: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_END"); + break; + case P_FUNC2S_VV_THIRDIFOK: + sprintf(*buf, "P_FUNC2S_VV_THIRDIFOK"); + break; + case P_FUNC2S_VV_ELSE: + sprintf(*buf, "P_FUNC2S_VV_ELSE"); + break; + case P_FUNC2S_VV_FUNC2S_UNK2: + sprintf(*buf, "P_FUNC2S_VV_FUNC2S_UNK2"); + break; + case P_FUNC2S_VV_FUNC2S_UNK: + sprintf(*buf, "P_FUNC2S_VV_FUNC2S_UNK"); + break; + case P_FUNC2S_CV_INSTINIT: + sprintf(*buf, "P_FUNC2S_CV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_CV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_CV_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_CV_TEST_D1: + sprintf(*buf, "P_FUNC2S_CV_TEST_D1"); + break; + case P_FUNC2S_CV_D1INT: + sprintf(*buf, "P_FUNC2S_CV_D1INT"); + break; + case P_FUNC2S_CV_D1NOTINT: + sprintf(*buf, "P_FUNC2S_CV_D1NOTINT"); + break; + case P_FUNC2S_CV_D1NOINT_D1BIGINT: + sprintf(*buf, "P_FUNC2S_CV_D1NOINT_D1BIGINT"); + break; + case P_FUNC2S_CV_D1NOTBIGINT: + sprintf(*buf, "P_FUNC2S_CV_D1NOTBIGINT"); + break; + case P_FUNC2S_CV_POST_IF: + sprintf(*buf, "P_FUNC2S_CV_POST_IF"); + break; + case P_FUNC2S_CV_FIRSTIFOK: + sprintf(*buf, "P_FUNC2S_CV_FIRSTIFOK"); + break; + case P_FUNC2S_CV_D1GREATER_D0NOTATOM: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_D0NOTATOM"); + break; + case P_FUNC2S_CV_D1GREATER_D0ATOM: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_D0ATOM"); + break; + case P_FUNC2S_CV_D1GREATER_POST_IF: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_POST_IF"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_IFOK_INIT"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_IFOK_IFOK"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_IFOK_NOIF"); + break; + case P_FUNC2S_CV_D1GREATER_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_INSIDEWHILE"); + break; + case P_FUNC2S_CV_D1GREATER_END: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_END"); + break; + case P_FUNC2S_CV_D1ISZERO: + sprintf(*buf, "P_FUNC2S_CV_D1ISZERO"); + break; + case P_FUNC2S_CV_ELSE: + sprintf(*buf, "P_FUNC2S_CV_ELSE"); + break; + case P_FUNC2S_CV_END: + sprintf(*buf, "P_FUNC2S_CV_END"); + break; + case P_FUNC2S_VC_INSTINIT: + sprintf(*buf, "P_FUNC2S_VC_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_VC_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_VC_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_VC_TEST_D0: + sprintf(*buf, "P_FUNC2S_VC_TEST_D0"); + break; + case P_FUNC2S_VC_FUNC2S_NVAR_VC: + sprintf(*buf, "P_FUNC2S_VC_FUNC2S_NVAR_VC"); + break; + case P_FUNC2S_VC_D0NOATOMIC: + sprintf(*buf, "P_FUNC2S_VC_D0NOATOMIC"); + break; + case P_FUNC2S_VC_EQUALS: + sprintf(*buf, "P_FUNC2S_VC_EQUALS"); + break; + case P_FUNC2S_VC_D1ISZERO: + sprintf(*buf, "P_FUNC2S_VC_D1ISZERO"); + break; + case P_FUNC2S_VC_D0NOATOM: + sprintf(*buf, "P_FUNC2S_VC_D0NOATOM"); + break; + case P_FUNC2S_VC_D0ATOM: + sprintf(*buf, "P_FUNC2S_VC_D0ATOM"); + break; + case P_FUNC2S_VC_POST_ELSE: + sprintf(*buf, "P_FUNC2S_VC_POST_ELSE"); + break; + case P_FUNC2S_VC_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_VC_IFOK_INIT"); + break; + case P_FUNC2S_VC_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_VC_IFOK_IFOK"); + break; + case P_FUNC2S_VC_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_VC_IFOK_NOIF"); + break; + case P_FUNC2S_VC_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_VC_INSIDEWHILE"); + break; + case P_FUNC2S_VC_END1: + sprintf(*buf, "P_FUNC2S_VC_END1"); + break; + case P_FUNC2S_VC_END2: + sprintf(*buf, "P_FUNC2S_VC_END2"); + break; + case P_FUNC2S_Y_VV_INSTINIT: + sprintf(*buf, "P_FUNC2S_Y_VV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_VV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_Y_VV_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_Y_VV_TEST_D0: + sprintf(*buf, "P_FUNC2S_Y_VV_TEST_D0"); + break; + case P_FUNC2S_Y_VV_TEST_D1: + sprintf(*buf, "P_FUNC2S_Y_VV_TEST_D1"); + break; + case P_FUNC2S_Y_VV_D1INT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1INT"); + break; + case P_FUNC2S_Y_VV_D1NOTINT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1NOTINT"); + break; + case P_FUNC2S_Y_VV_D1BIGINT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1BIGINT"); + break; + case P_FUNC2S_Y_VV_D1NOTBIGINT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1NOTBIGINT"); + break; + case P_FUNC2S_Y_VV_POST_IF: + sprintf(*buf, "P_FUNC2S_Y_VV_POST_IF"); + break; + case P_FUNC2S_Y_VV_D0NOATOMIC: + sprintf(*buf, "P_FUNC2S_Y_VV_D0NOATOMIC"); + break; + case P_FUNC2S_Y_VV_EQUALS: + sprintf(*buf, "P_FUNC2S_Y_VV_EQUALS"); + break; + case P_FUNC2S_Y_VV_D1GREATER_D0NOATOM: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_D0NOATOM"); + break; + case P_FUNC2S_Y_VV_D1GREATER_D0ATOM: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_D0ATOM"); + break; + case P_FUNC2S_Y_VV_D1GREATER_POST_ELSE: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_POST_ELSE"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF"); + break; + case P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE"); + break; + case P_FUNC2S_Y_VV_D1GREATER_END: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_END"); + break; + case P_FUNC2S_Y_VV_D1ISZERO: + sprintf(*buf, "P_FUNC2S_Y_VV_D1ISZERO"); + break; + case P_FUNC2S_Y_VV_ELSE: + sprintf(*buf, "P_FUNC2S_Y_VV_ELSE"); + break; + case P_FUNC2S_Y_VV_END1: + sprintf(*buf, "P_FUNC2S_Y_VV_END1"); + break; + case P_FUNC2S_Y_VV_END2: + sprintf(*buf, "P_FUNC2S_Y_VV_END2"); + break; + case P_FUNC2S_Y_CV_INSTINIT: + sprintf(*buf, "P_FUNC2S_Y_CV_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_CV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_Y_CV_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_Y_CV_TEST_D1: + sprintf(*buf, "P_FUNC2S_Y_CV_TEST_D1"); + break; + case P_FUNC2S_Y_CV_D1INT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1INT"); + break; + case P_FUNC2S_Y_CV_D1NOTINT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1NOTINT"); + break; + case P_FUNC2S_Y_CV_D1BIGINT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1BIGINT"); + break; + case P_FUNC2S_Y_CV_D1NOTBIGINT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1NOTBIGINT"); + break; + case P_FUNC2S_Y_CV_POST_IF: + sprintf(*buf, "P_FUNC2S_Y_CV_POST_IF"); + break; + case P_FUNC2S_Y_CV_EQUALS: + sprintf(*buf, "P_FUNC2S_Y_CV_EQUALS"); + break; + case P_FUNC2S_Y_CV_D1GREATER_D0NOATOM: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_D0NOATOM"); + break; + case P_FUNC2S_Y_CV_D1GREATER_D0ATOM: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_D0ATOM"); + break; + case P_FUNC2S_Y_CV_D1GREATER_POST_ELSE: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_POST_ELSE"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF"); + break; + case P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE"); + break; + case P_FUNC2S_Y_CV_D1GREATER_END: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_END"); + break; + case P_FUNC2S_Y_CV_D1ISZERO: + sprintf(*buf, "P_FUNC2S_Y_CV_D1ISZERO"); + break; + case P_FUNC2S_Y_CV_ELSE: + sprintf(*buf, "P_FUNC2S_Y_CV_ELSE"); + break; + case P_FUNC2S_Y_CV_END: + sprintf(*buf, "P_FUNC2S_Y_CV_END"); + break; + case P_FUNC2S_Y_VC_INSTINIT: + sprintf(*buf, "P_FUNC2S_Y_VC_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_VC_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_Y_VC_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2S_Y_VC_TEST_D0: + sprintf(*buf, "P_FUNC2S_Y_VC_TEST_D0"); + break; + case P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC: + sprintf(*buf, "P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC"); + break; + case P_FUNC2S_Y_VC_D0NOATOMIC: + sprintf(*buf, "P_FUNC2S_Y_VC_D0NOATOMIC"); + break; + case P_FUNC2S_Y_VC_EQUALS: + sprintf(*buf, "P_FUNC2S_Y_VC_EQUALS"); + break; + case P_FUNC2S_Y_VC_D1ISZERO: + sprintf(*buf, "P_FUNC2S_Y_VC_D1ISZERO"); + break; + case P_FUNC2S_Y_VC_D0NOATOM1: + sprintf(*buf, "P_FUNC2S_Y_VC_D0NOATOM1"); + break; + case P_FUNC2S_Y_VC_D0NOATOM2: + sprintf(*buf, "P_FUNC2S_Y_VC_D0NOATOM2"); + break; + case P_FUNC2S_Y_VC_D0ATOM: + sprintf(*buf, "P_FUNC2S_Y_VC_D0ATOM"); + break; + case P_FUNC2S_Y_VC_POST_ELSE: + sprintf(*buf, "P_FUNC2S_Y_VC_POST_ELSE"); + break; + case P_FUNC2S_Y_VC_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_Y_VC_IFOK_INIT"); + break; + case P_FUNC2S_Y_VC_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_Y_VC_IFOK_IFOK"); + break; + case P_FUNC2S_Y_VC_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_Y_VC_IFOK_NOIF"); + break; + case P_FUNC2S_Y_VC_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_Y_VC_INSIDEWHILE"); + break; + case P_FUNC2S_Y_VC_END1: + sprintf(*buf, "P_FUNC2S_Y_VC_END1"); + break; + case P_FUNC2S_Y_VC_END2: + sprintf(*buf, "P_FUNC2S_Y_VC_END2"); + break; + case P_FUNC2F_XX_INSTINIT: + sprintf(*buf, "P_FUNC2F_XX_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_XX_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2F_XX_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2F_XX_TEST_D0: + sprintf(*buf, "P_FUNC2F_XX_TEST_D0"); + break; + case P_FUNC2F_XX_D0APPL: + sprintf(*buf, "P_FUNC2F_XX_D0APPL"); + break; + case P_FUNC2F_XX_D0APPL_D1EXTFUNC: + sprintf(*buf, "P_FUNC2F_XX_D0APPL_D1EXTFUNC"); + break; + case P_FUNC2F_XX_D0APPL_END: + sprintf(*buf, "P_FUNC2F_XX_D0APPL_END"); + break; + case P_FUNC2F_XX_D0PAIR: + sprintf(*buf, "P_FUNC2F_XX_D0PAIR"); + break; + case P_FUNC2F_XX_D0NOCOMPOUND: + sprintf(*buf, "P_FUNC2F_XX_D0NOCOMPOUND"); + break; + case P_FUNC2F_XX_END: + sprintf(*buf, "P_FUNC2F_XX_END"); + break; + case P_FUNC2F_XY_INSTINIT: + sprintf(*buf, "P_FUNC2F_XY_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_XY_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2F_XY_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2F_XY_TEST_D0: + sprintf(*buf, "P_FUNC2F_XY_TEST_D0"); + break; + case P_FUNC2F_XY_D0APPL: + sprintf(*buf, "P_FUNC2F_XY_D0APPL"); + break; + case P_FUNC2F_XY_D0APPL_D1EXTFUNC: + sprintf(*buf, "P_FUNC2F_XY_D0APPL_D1EXTFUNC"); + break; + case P_FUNC2F_XY_D0APPL_END: + sprintf(*buf, "P_FUNC2F_XY_D0APPL_END"); + break; + case P_FUNC2F_XY_D0PAIR: + sprintf(*buf, "P_FUNC2F_XY_D0PAIR"); + break; + case P_FUNC2F_XY_D0NOCOMPOUND: + sprintf(*buf, "P_FUNC2F_XY_D0NOCOMPOUND"); + break; + case P_FUNC2F_XY_END: + sprintf(*buf, "P_FUNC2F_XY_END"); + break; + case P_FUNC2F_YX_INSTINIT: + sprintf(*buf, "P_FUNC2F_YX_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_YX_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2F_YX_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2F_YX_TEST_D0: + sprintf(*buf, "P_FUNC2F_YX_TEST_D0"); + break; + case P_FUNC2F_YX_D0APPL: + sprintf(*buf, "P_FUNC2F_YX_D0APPL"); + break; + case P_FUNC2F_YX_D0APPL_D1EXTFUNC: + sprintf(*buf, "P_FUNC2F_YX_D0APPL_D1EXTFUNC"); + break; + case P_FUNC2F_YX_D0APPL_END: + sprintf(*buf, "P_FUNC2F_YX_D0APPL_END"); + break; + case P_FUNC2F_YX_D0PAIR: + sprintf(*buf, "P_FUNC2F_YX_D0PAIR"); + break; + case P_FUNC2F_YX_D0NOCOMPOUND: + sprintf(*buf, "P_FUNC2F_YX_D0NOCOMPOUND"); + break; + case P_FUNC2F_YX_END: + sprintf(*buf, "P_FUNC2F_YX_END"); + break; + case P_FUNC2F_YY_INSTINIT: + sprintf(*buf, "P_FUNC2F_YY_INSTINIT"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_YY_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2F_YY_LOW_LEVEL_TRACER"); + break; +#endif + case P_FUNC2F_YY_TEST_D0: + sprintf(*buf, "P_FUNC2F_YY_TEST_D0"); + break; + case P_FUNC2F_YY_D0APPL: + sprintf(*buf, "P_FUNC2F_YY_D0APPL"); + break; + case P_FUNC2F_YY_D0APPL_D1EXTFUNC: + sprintf(*buf, "P_FUNC2F_YY_D0APPL_D1EXTFUNC"); + break; + case P_FUNC2F_YY_D0APPL_END: + sprintf(*buf, "P_FUNC2F_YY_D0APPL_END"); + break; + case P_FUNC2F_YY_D0PAIR: + sprintf(*buf, "P_FUNC2F_YY_D0PAIR"); + break; + case P_FUNC2F_YY_D0NOCOMPOUND: + sprintf(*buf, "P_FUNC2F_YY_D0NOCOMPOUND"); + break; + case P_FUNC2F_YY_END: + sprintf(*buf, "P_FUNC2F_YY_END"); + break; + } +} + +static inline void +sprint_block(YAP_BBs block, char **buf) { + switch(block) { + case ENTRY: break; + case YAAM_DEREF_BODY_D0PT0: + sprintf(*buf, "YAAM_DEREF_BODY_D0PT0\n"); + break; + case YAAM_DEREF_BODY_D0PT1: + sprintf(*buf, "YAAM_DEREF_BODY_D0PT1\n"); + break; + case YAAM_DEREF_BODY_D0S_SREG: + sprintf(*buf, "YAAM_DEREF_BODY_D0S_SREG\n"); + break; + case YAAM_DEREF_BODY_D1PT0: + sprintf(*buf, "YAAM_DEREF_BODY_D1PT0\n"); + break; + case YAAM_DEREF_BODY_D1PT1: + sprintf(*buf, "YAAM_DEREF_BODY_D1PT1\n"); + break; + case YAAM_FAIL: + sprintf(*buf, "YAAM_FAIL\n"); + break; + case YAAM_CHECK_TRAIL_TR: + sprintf(*buf, "YAAM_CHECK_TRAIL_TR\n"); + break; + case YAAM_UNIFYBOUND: + break; + case NoStackExecute_Exception: + sprintf(*buf, "NoStackExecute_Exception\n"); + break; + case NoStackDExecute_Exception: + sprintf(*buf, "NoStackDExecute_Exception\n"); + break; + case NoStackCall_Exception: + sprintf(*buf, "NoStackCall_Exception\n"); + break; + case NoStackDeallocate_Exception: + sprintf(*buf, "NoStackDeallocate_Exception\n"); + break; +#ifdef COROUTINING + case NoStackFail_Exception: + sprintf(*buf, "NoStackFail_Exception\n"); + break; +#endif + case NoStackCut_Exception: + sprintf(*buf, "NoStackCut_Exception\n"); + break; + case NoStackCutT_Exception: + sprintf(*buf, "NoStackCutT_Exception\n"); + break; + case NoStackCutE_Exception: + sprintf(*buf, "NoStackCutE_Exception\n"); + break; + case NoStackCommitX_Exception: + sprintf(*buf, "NoStackCommitX_Exception\n"); + break; + case NoStackCommitY_Exception: + sprintf(*buf, "NoStackCommitY_Exception\n"); + break; + case NoStackEither_Exception: + sprintf(*buf, "NoStackEither_Exception\n"); + break; + case NoStackPExecute_Exception: + sprintf(*buf, "NoStackPExecute_Exception\n"); + break; + case NoStackPExecute2_Exception: + sprintf(*buf, "NoStackPExecute2_Exception\n"); + break; + case NoStackPTExecute_Exception: + sprintf(*buf, "NoStackPTExecute_Exception\n"); + break; + case TRY_ME_INSTINIT: + sprintf(*buf, "TRY_ME_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_ME_YAPOR: + sprintf(*buf, "TRY_ME_YAPOR\n"); + break; +#endif + case TRY_ME_END: + sprintf(*buf, "TRY_ME_END\n"); + break; + case RETRY_ME_INSTINIT: + sprintf(*buf, "RETRY_ME_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY_ME_FROZEN: + sprintf(*buf, "RETRY_ME_FROZEN\n"); + break; +#else + case RETRY_ME_NOFROZEN: + sprintf(*buf, "RETRY_ME_NOFROZEN\n"); + break; +#endif + case RETRY_ME_END: + sprintf(*buf, "RETRY_ME_END\n"); + break; + case TRUST_ME_INSTINIT: + sprintf(*buf, "TRUST_ME_INSTINIT\n"); + break; + case TRUST_ME_IF: + sprintf(*buf, "TRUST_ME_IF\n"); + break; + case TRUST_ME_END: + sprintf(*buf, "TRUST_ME_END\n"); + break; + case ENTER_PROFILING_INSTINIT: + sprintf(*buf, "ENTER_PROFILING_INSTINIT\n"); + break; + case RETRY_PROFILED_INSTINIT: + sprintf(*buf, "RETRY_PROFILED_INSTINIT\n"); + break; + case PROFILED_RETRY_ME_INSTINIT: + sprintf(*buf, "PROFILED_RETRY_ME_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case PROFILED_RETRY_ME_FROZEN: + sprintf(*buf, "PROFILED_RETRY_ME_FROZEN\n"); + break; +#else + case PROFILED_RETRY_ME_NOFROZEN: + sprintf(*buf, "PROFILED_RETRY_ME_NOFROZEN\n"); + break; +#endif + case PROFILED_RETRY_ME_END: + sprintf(*buf, "PROFILED_RETRY_ME_END\n"); + break; + case PROFILED_TRUST_ME_INSTINIT: + sprintf(*buf, "PROFILED_TRUST_ME_INSTINIT\n"); + break; + case PROFILED_TRUST_ME_IF: + sprintf(*buf, "PROFILED_TRUST_ME_IF\n"); + break; + case PROFILED_TRUST_ME_END: + sprintf(*buf, "PROFILED_TRUST_ME_END\n"); + break; + case PROFILED_RETRY_LOGICAL_INSTINIT: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_INSTINIT\n"); + break; +#ifdef THREADS + case PROFILED_RETRY_LOGICAL_THREADS: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_THREADS\n"); + break; +#endif + case PROFILED_RETRY_LOGICAL_POST_THREADS: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_POST_THREADS\n"); + break; +#ifdef FROZEN_STACKS + case PROFILED_RETRY_LOGICAL_FROZEN: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_FROZEN\n"); + break; +#else + case PROFILED_RETRY_LOGICAL_NOFROZEN: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_NOFROZEN\n"); + break; +#endif + case PROFILED_RETRY_LOGICAL_END: + sprintf(*buf, "PROFILED_RETRY_LOGICAL_END\n"); + break; + case PROFILED_TRUST_LOGICAL_INSTINIT: + sprintf(*buf, "PROFILED_TRUST_LOGICAL_INSTINIT\n"); + break; + case PROFILED_TRUST_LOGICAL_END: + sprintf(*buf, "PROFILED_TRUST_LOGICAL_END\n"); + break; + case COUNT_CALL_INSTINIT: + sprintf(*buf, "COUNT_CALL_INSTINIT\n"); + break; + case COUNT_CALL_MIDDLE: + sprintf(*buf, "COUNT_CALL_MIDDLE\n"); + break; + case COUNT_CALL_END: + sprintf(*buf, "COUNT_CALL_END\n"); + break; + case COUNT_RETRY_INSTINIT: + sprintf(*buf, "COUNT_RETRY_INSTINIT\n"); + break; + case COUNT_RETRY_MIDDLE: + sprintf(*buf, "COUNT_RETRY_MIDDLE\n"); + break; + case COUNT_RETRY_END: + sprintf(*buf, "COUNT_RETRY_END\n"); + break; + case COUNT_RETRY_ME_INSTINIT: + sprintf(*buf, "COUNT_RETRY_ME_INSTINIT\n"); + break; + case COUNT_RETRY_ME_MIDDLE: + sprintf(*buf, "COUNT_RETRY_ME_MIDDLE\n"); + break; + case COUNT_RETRY_ME_END: + sprintf(*buf, "COUNT_RETRY_ME_END\n"); + break; + case COUNT_TRUST_ME_INSTINIT: + sprintf(*buf, "COUNT_TRUST_ME_INSTINIT\n"); + break; + case COUNT_TRUST_ME_MIDDLE: + sprintf(*buf, "COUNT_TRUST_ME_MIDDLE\n"); + break; + case COUNT_TRUST_ME_END: + sprintf(*buf, "COUNT_TRUST_ME_END\n"); + break; + case COUNT_RETRY_LOGICAL_INSTINIT: + sprintf(*buf, "COUNT_RETRY_LOGICAL_INSTINIT\n"); + break; + case COUNT_RETRY_LOGICAL_END: + sprintf(*buf, "COUNT_RETRY_LOGICAL_END\n"); + break; + case COUNT_TRUST_LOGICAL_INSTINIT: + sprintf(*buf, "COUNT_TRUST_LOGICAL_INSTINIT\n"); + break; + case COUNT_TRUST_LOGICAL_END: + sprintf(*buf, "COUNT_TRUST_LOGICAL_END\n"); + break; + case LOCK_LU_INSTINIT: + sprintf(*buf, "LOCK_LU_INSTINIT\n"); + break; + case LOCK_LU_END: + sprintf(*buf, "LOCK_LU_END\n"); + break; + case UNLOCK_LU_INSTINIT: + sprintf(*buf, "UNLOCK_LU_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case UNLOCK_LU_YAPOR_THREADS: + sprintf(*buf, "UNLOCK_LU_YAPOR_THREADS\n"); + break; +#endif + case UNLOCK_LU_END: + sprintf(*buf, "UNLOCK_LU_END\n"); + break; + case ALLOC_FOR_LOGICAL_PRED_INSTINIT: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_INSTINIT\n"); + break; +#if MULTIPLE_STACKS + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS\n"); + break; +#if PARALLEL_YAP + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL\n"); + break; +#endif + case ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END\n"); + break; +#else + case ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT\n"); + break; + case ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF\n"); + break; +#endif + case ALLOC_FOR_LOGICAL_PRED_END: + sprintf(*buf, "ALLOC_FOR_LOGICAL_PRED_END\n"); + break; + case COPY_IDB_TERM_INSTINIT: + sprintf(*buf, "COPY_IDB_TERM_INSTINIT\n"); + break; + case COPY_IDB_TERM_END: + sprintf(*buf, "COPY_IDB_TERM_END\n"); + break; + case UNIFY_IDB_TERM_INSTINIT: + sprintf(*buf, "UNIFY_IDB_TERM_INSTINIT\n"); + break; + case UNIFY_IDB_TERM_END: + sprintf(*buf, "UNIFY_IDB_TERM_END\n"); + break; + case ENSURE_SPACE_INSTINIT: + sprintf(*buf, "ENSURE_SPACE_INSTINIT\n"); + break; + case ENSURE_SPACE_END: + sprintf(*buf, "ENSURE_SPACE_END\n"); + break; + case SPY_OR_TRYMARK_INSTINIT: + sprintf(*buf, "SPY_OR_TRYMARK_INSTINIT\n"); + break; + case TRY_AND_MARK_INSTINIT: + sprintf(*buf, "TRY_AND_MARK_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) +#ifdef YAPOR + case TRY_AND_MARK_YAPOR_THREADS_YAPOR: + sprintf(*buf, "TRY_AND_MARK_YAPOR_THREADS_YAPOR\n"); + break; +#endif + case TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF: + sprintf(*buf, "TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF\n"); + break; +#endif + case TRY_AND_MARK_NOYAPOR_NOTHREADS: + sprintf(*buf, "TRY_AND_MARK_NOYAPOR_NOTHREADS\n"); + break; +#ifdef YAPOR + case TRY_AND_MARK_SET_LOAD: + sprintf(*buf, "TRY_AND_MARK_SET_LOAD\n"); + break; +#endif + case TRY_AND_MARK_POST_SET_LOAD: + sprintf(*buf, "TRY_AND_MARK_POST_SET_LOAD\n"); + break; +#if MULTIPLE_STACKS + case TRY_AND_MARK_MULTIPLE_STACKS: + sprintf(*buf, "TRY_AND_MARK_MULTIPLE_STACKS\n"); + break; +#else + case TRY_AND_MARK_NOMULTIPLE_STACKS_IF: + sprintf(*buf, "TRY_AND_MARK_NOMULTIPLE_STACKS_IF\n"); + break; +#endif + case TRY_AND_MARK_END: + sprintf(*buf, "TRY_AND_MARK_END\n"); + break; + case COUNT_RETRY_AND_MARK_INSTINIT: + sprintf(*buf, "COUNT_RETRY_AND_MARK_INSTINIT\n"); + break; + case PROFILED_RETRY_AND_MARK_INSTINIT: + sprintf(*buf, "PROFILED_RETRY_AND_MARK_INSTINIT\n"); + break; + case RETRY_AND_MARK_INSTINIT: + sprintf(*buf, "RETRY_AND_MARK_INSTINIT\n"); + break; +#ifdef YAPOR + case RETRY_AND_MARK_YAPOR: + sprintf(*buf, "RETRY_AND_MARK_YAPOR\n"); + break; +#endif + case RETRY_AND_MARK_POST_YAPOR: + sprintf(*buf, "RETRY_AND_MARK_POST_YAPOR\n"); + break; +#ifdef FROZEN_STACKS + case RETRY_AND_MARK_FROZEN: + sprintf(*buf, "RETRY_AND_MARK_FROZEN\n"); + break; +#else + case RETRY_AND_MARK_NOFROZEN: + sprintf(*buf, "RETRY_AND_MARK_NOFROZEN\n"); + break; +#endif + case RETRY_AND_MARK_POST_FROZEN: + sprintf(*buf, "RETRY_AND_MARK_POST_FROZEN\n"); + break; +#if MULTIPLE_STACKS + case RETRY_AND_MARK_MULTIPLE_STACKS: + sprintf(*buf, "RETRY_AND_MARK_MULTIPLE_STACKS\n"); + break; +#else + case RETRY_AND_MARK_NOMULTIPLE_STACKS_IF: + sprintf(*buf, "RETRY_AND_MARK_NOMULTIPLE_STACKS_IF\n"); + break; +#endif + case RETRY_AND_MARK_END: + sprintf(*buf, "RETRY_AND_MARK_END\n"); + break; + case TRUST_FAIL_INSTINIT: + sprintf(*buf, "TRUST_FAIL_INSTINIT\n"); + break; +#ifdef CUT_C + case TRUST_FAIL_CUT_C: + sprintf(*buf, "TRUST_FAIL_CUT_C\n"); + break; +#endif +#ifdef YAPOR + case TRUST_FAIL_YAPOR: + sprintf(*buf, "TRUST_FAIL_YAPOR\n"); + break; +#endif + case TRUST_FAIL_NOYAPOR: + sprintf(*buf, "TRUST_FAIL_NOYAPOR\n"); + break; +#ifdef YAPOR + case LBL_SHARED_FAIL: + sprintf(*buf, "LBL_SHARED_FAIL\n"); + break; +#endif + case OP_FAIL_INSTINIT: + sprintf(*buf, "OP_FAIL_INSTINIT\n"); + break; + case LBL_FAIL_INSTINIT: + sprintf(*buf, "LBL_FAIL_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case LBL_FAIL_LOW_LEVEL_TRACER: + sprintf(*buf, "LBL_FAIL_LOW_LEVEL_TRACER\n"); + break; +#endif + case LBL_FAIL_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "LBL_FAIL_POST_LOW_LEVEL_TRACER\n"); + break; + case LBL_FAIL_VARTERM: + sprintf(*buf, "LBL_FAIL_VARTERM\n"); + break; + case LBL_FAIL_PAIRTERM_INIT: + sprintf(*buf, "LBL_FAIL_PAIRTERM_INIT\n"); + break; + case LBL_FAIL_PAIRTERM_END_APPL: + sprintf(*buf, "LBL_FAIL_PAIRTERM_END_APPL\n"); + break; + case LBL_FAIL_END: + sprintf(*buf, "LBL_FAIL_END\n"); + break; + case CUT_INSTINIT: + sprintf(*buf, "CUT_INSTINIT\n"); + break; +#ifdef COROUTINING + case CUT_COROUTINING: + sprintf(*buf, "CUT_COROUTINING\n"); + break; +#endif + case CUT_NOCOROUTINING: + sprintf(*buf, "CUT_NOCOROUTINING\n"); + break; + case CUT_T_INSTINIT: + sprintf(*buf, "CUT_T_INSTINIT\n"); + break; +#ifdef COROUTINING + case CUT_T_COROUTINING: + sprintf(*buf, "CUT_T_COROUTINING\n"); + break; +#endif + case CUT_T_NOCOROUTINING: + sprintf(*buf, "CUT_T_NOCOROUTINING\n"); + break; + case CUT_E_INSTINIT: + sprintf(*buf, "CUT_E_INSTINIT\n"); + break; +#ifdef COROUTINING + case CUT_E_COROUTINING: + sprintf(*buf, "CUT_E_COROUTINING\n"); + break; +#endif + case CUT_E_NOCOROUTINING: + sprintf(*buf, "CUT_E_NOCOROUTINING\n"); + break; + case SAVE_B_X_INSTINIT: + sprintf(*buf, "SAVE_B_X_INSTINIT\n"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case SAVE_B_X_YSBA_FROZEN: + sprintf(*buf, "SAVE_B_X_YSBA_FROZEN\n"); + break; +#else + case SAVE_B_X_NOYSBA_NOFROZEN: + sprintf(*buf, "SAVE_B_X_NOYSBA_NOFROZEN\n"); + break; +#endif + case SAVE_B_X_END: + sprintf(*buf, "SAVE_B_X_END\n"); + break; + case SAVE_B_Y_INSTINIT: + sprintf(*buf, "SAVE_B_Y_INSTINIT\n"); + break; +#if defined(YAPOR_SBA) + case SAVE_B_Y_YSBA: + sprintf(*buf, "SAVE_B_Y_YSBA\n"); + break; +#else + case SAVE_B_Y_NOYSBA: + sprintf(*buf, "SAVE_B_Y_NOYSBA\n"); + break; +#endif + case SAVE_B_Y_END: + sprintf(*buf, "SAVE_B_Y_END\n"); + break; + case COMMIT_B_X_INSTINIT: + sprintf(*buf, "COMMIT_B_X_INSTINIT\n"); + break; + case COMMIT_B_X_DO_COMMIT_B_X: + sprintf(*buf, "COMMIT_B_X_DO_COMMIT_B_X\n"); + break; + case COMMIT_B_X_COMMIT_B_X_NVAR: + sprintf(*buf, "COMMIT_B_X_COMMIT_B_X_NVAR\n"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case COMMIT_B_X_YSBA_FROZEN: + sprintf(*buf, "COMMIT_B_X_YSBA_FROZEN\n"); + break; +#else + case COMMIT_B_X_NOYSBA_NOFROZEN: + sprintf(*buf, "COMMIT_B_X_NOYSBA_NOFROZEN\n"); + break; +#endif + case COMMIT_B_X_POST_YSBA_FROZEN: + sprintf(*buf, "COMMIT_B_X_POST_YSBA_FROZEN\n"); + break; + case COMMIT_B_X_END: + sprintf(*buf, "COMMIT_B_X_END\n"); + break; + case COMMIT_B_Y_INSTINIT: + sprintf(*buf, "COMMIT_B_Y_INSTINIT\n"); + break; + case COMMIT_B_Y_DO_COMMIT_B_Y: + sprintf(*buf, "COMMIT_B_Y_DO_COMMIT_B_Y\n"); + break; + case COMMIT_B_Y_COMMIT_B_Y_NVAR: + sprintf(*buf, "COMMIT_B_Y_COMMIT_B_Y_NVAR\n"); + break; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + case COMMIT_B_Y_YSBA_FROZEN: + sprintf(*buf, "COMMIT_B_Y_YSBA_FROZEN\n"); + break; +#else + case COMMIT_B_Y_NOYSBA_NOFROZEN: + sprintf(*buf, "COMMIT_B_Y_NOYSBA_NOFROZEN\n"); + break; +#endif + case COMMIT_B_Y_POST_YSBA_FROZEN: + sprintf(*buf, "COMMIT_B_Y_POST_YSBA_FROZEN\n"); + break; + case COMMIT_B_Y_END: + sprintf(*buf, "COMMIT_B_Y_END\n"); + break; + case EXECUTE_INSTINIT: + sprintf(*buf, "EXECUTE_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case EXECUTE_LOW_LEVEL_TRACER: + sprintf(*buf, "EXECUTE_LOW_LEVEL_TRACER\n"); + break; +#endif + case EXECUTE_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "EXECUTE_POST_LOW_LEVEL_TRACER\n"); + break; + case EXECUTE_POST_NOCHECKING: + sprintf(*buf, "EXECUTE_POST_NOCHECKING\n"); + break; +#ifdef DEPTH_LIMIT + case EXECUTE_DEPTH_MINOR: + sprintf(*buf, "EXECUTE_DEPTH_MINOR\n"); + break; + case EXECUTE_DEPTH_MOFPRED: + sprintf(*buf, "EXECUTE_DEPTH_MOFPRED\n"); + break; + case EXECUTE_DEPTH_END: + sprintf(*buf, "EXECUTE_DEPTH_END\n"); + break; +#endif + case EXECUTE_END_END: + sprintf(*buf, "EXECUTE_END_END\n"); + break; + case DEXECUTE_INSTINIT: + sprintf(*buf, "DEXECUTE_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case DEXECUTE_LOW_LEVEL_TRACER: + sprintf(*buf, "DEXECUTE_LOW_LEVEL_TRACER\n"); + break; +#endif + case DEXECUTE_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "DEXECUTE_POST_LOW_LEVEL_TRACER\n"); + break; +#ifdef DEPTH_LIMIT + case DEXECUTE_DEPTH_MINOR: + sprintf(*buf, "DEXECUTE_DEPTH_MINOR\n"); + break; + case DEXECUTE_DEPTH_MOFPRED: + sprintf(*buf, "DEXECUTE_DEPTH_MOFPRED\n"); + break; + case DEXECUTE_DEPTH_END: + sprintf(*buf, "DEXECUTE_DEPTH_END\n"); + break; +#endif + case DEXECUTE_END_END: + sprintf(*buf, "DEXECUTE_END_END\n"); + break; + case FCALL_INST: + break; + case CALL_INSTINIT: + sprintf(*buf, "CALL_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case CALL_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_LOW_LEVEL_TRACER\n"); + break; +#endif + case CALL_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_POST_LOW_LEVEL_TRACER\n"); + break; + case CALL_POST_NO_CHECKING: + sprintf(*buf, "CALL_POST_NO_CHECKING\n"); + break; +#ifdef DEPTH_LIMIT + case CALL_DEPTH_MINOR: + sprintf(*buf, "CALL_DEPTH_MINOR\n"); + break; + case CALL_DEPTH_MOFPRED: + sprintf(*buf, "CALL_DEPTH_MOFPRED\n"); + break; + case CALL_DEPTH_END: + sprintf(*buf, "CALL_DEPTH_END\n"); + break; +#endif + case CALL_END_END: + sprintf(*buf, "CALL_END_END\n"); + break; + case PROCCEED_INSTINIT: + sprintf(*buf, "PROCCEED_INSTINIT\n"); + break; +#ifdef DEPTH_LIMIT + case PROCCEED_DEPTH: + sprintf(*buf, "PROCCEED_DEPTH\n"); + break; +#endif + case PROCCEED_END: + sprintf(*buf, "PROCCEED_END\n"); + break; + case ALLOCATE_INSTINIT: + sprintf(*buf, "ALLOCATE_INSTINIT\n"); + break; +#ifdef DEPTH_LIMIT + case ALLOCATE_DEPTH: + sprintf(*buf, "ALLOCATE_DEPTH\n"); + break; +#endif + case ALLOCATE_END: + sprintf(*buf, "ALLOCATE_END\n"); + break; + case DEALLOCATE_INSTINIT: + sprintf(*buf, "DEALLOCATE_INSTINIT\n"); + break; + case DEALLOCATE_POST_CHECK: + sprintf(*buf, "DEALLOCATE_POST_CHECK\n"); + break; +#ifdef DEPTH_LIMIT + case DEALLOCATE_DEPTH: + sprintf(*buf, "DEALLOCATE_DEPTH\n"); + break; +#endif + case DEALLOCATE_FROZEN: + sprintf(*buf, "DEALLOCATE_FROZEN\n"); + break; + case DEALLOCATE_POST_FROZEN: + sprintf(*buf, "DEALLOCATE_POST_FROZEN\n"); + break; + case DEALLOCATE_END: + sprintf(*buf, "DEALLOCATE_END\n"); + break; + case GET_X_VAR_INSTINIT: + sprintf(*buf, "GET_X_VAR_INSTINIT\n"); + break; + case GET_Y_VAR_INSTINIT: + sprintf(*buf, "GET_Y_VAR_INSTINIT\n"); + break; + case GET_YY_VAR_INSTINIT: + sprintf(*buf, "GET_YY_VAR_INSTINIT\n"); + break; + case GET_X_VAL_INSTINIT: + sprintf(*buf, "GET_X_VAL_INSTINIT\n"); + break; + case GET_X_VAL_GVALX_NONVAR: + sprintf(*buf, "GET_X_VAL_GVALX_NONVAR\n"); + break; + case GET_X_VAL_GVALX_NONVAR_NONVAR: + sprintf(*buf, "GET_X_VAL_GVALX_NONVAR_NONVAR\n"); + break; + case GET_X_VAL_GVALX_NONVAR_UNK: + sprintf(*buf, "GET_X_VAL_GVALX_NONVAR_UNK\n"); + break; + case GET_X_VAL_GVALX_UNK: + sprintf(*buf, "GET_X_VAL_GVALX_UNK\n"); + break; + case GET_X_VAL_GVALX_VAR_NONVAR: + sprintf(*buf, "GET_X_VAL_GVALX_VAR_NONVAR\n"); + break; + case GET_X_VAL_GVALX_VAR_UNK: + sprintf(*buf, "GET_X_VAL_GVALX_VAR_UNK\n"); + break; + case GET_Y_VAL_INSTINIT: + sprintf(*buf, "GET_Y_VAL_INSTINIT\n"); + break; + case GET_Y_VAL_GVALY_NONVAR: + sprintf(*buf, "GET_Y_VAL_GVALY_NONVAR\n"); + break; + case GET_Y_VAL_GVALY_NONVAR_NONVAR: + sprintf(*buf, "GET_Y_VAL_GVALY_NONVAR_NONVAR\n"); + break; + case GET_Y_VAL_GVALY_NONVAR_UNK: + sprintf(*buf, "GET_Y_VAL_GVALY_NONVAR_UNK\n"); + break; + case GET_Y_VAL_GVALY_UNK: + sprintf(*buf, "GET_Y_VAL_GVALY_UNK\n"); + break; + case GET_Y_VAL_GVALY_VAR_NONVAR: + sprintf(*buf, "GET_Y_VAL_GVALY_VAR_NONVAR\n"); + break; + case GET_Y_VAL_GVALY_VAR_UNK: + sprintf(*buf, "GET_Y_VAL_GVALY_VAR_UNK\n"); + break; + case GET_ATOM_INSTINIT: + sprintf(*buf, "GET_ATOM_INSTINIT\n"); + break; + case GET_ATOM_GATOM_NONVAR: + sprintf(*buf, "GET_ATOM_GATOM_NONVAR\n"); + break; + case GET_ATOM_GATOM_UNK: + sprintf(*buf, "GET_ATOM_GATOM_UNK\n"); + break; + case GET_2ATOMS_INSTINIT: + sprintf(*buf, "GET_2ATOMS_INSTINIT\n"); + break; + case GET_2ATOMS_GATOM_2UNK: + sprintf(*buf, "GET_2ATOMS_GATOM_2UNK\n"); + break; + case GET_2ATOMS_GATOM_2B: + sprintf(*buf, "GET_2ATOMS_GATOM_2B\n"); + break; + case GET_2ATOMS_GATOM_2BNONVAR: + sprintf(*buf, "GET_2ATOMS_GATOM_2BNONVAR\n"); + break; + case GET_2ATOMS_GATOM_2BUNK: + sprintf(*buf, "GET_2ATOMS_GATOM_2BUNK\n"); + break; + case GET_3ATOMS_INSTINIT: + sprintf(*buf, "GET_3ATOMS_INSTINIT\n"); + break; + case GET_3ATOMS_GATOM_3UNK: + sprintf(*buf, "GET_3ATOMS_GATOM_3UNK\n"); + break; + case GET_3ATOMS_GATOM_3B: + sprintf(*buf, "GET_3ATOMS_GATOM_3B\n"); + break; + case GET_3ATOMS_GATOM_3BUNK: + sprintf(*buf, "GET_3ATOMS_GATOM_3BUNK\n"); + break; + case GET_3ATOMS_GATOM_3C: + sprintf(*buf, "GET_3ATOMS_GATOM_3C\n"); + break; + case GET_3ATOMS_GATOM_3CNONVAR: + sprintf(*buf, "GET_3ATOMS_GATOM_3CNONVAR\n"); + break; + case GET_3ATOMS_GATOM_3CUNK: + sprintf(*buf, "GET_3ATOMS_GATOM_3CUNK\n"); + break; + case GET_4ATOMS_INSTINIT: + sprintf(*buf, "GET_4ATOMS_INSTINIT\n"); + break; + case GET_4ATOMS_GATOM_4UNK: + sprintf(*buf, "GET_4ATOMS_GATOM_4UNK\n"); + break; + case GET_4ATOMS_GATOM_4B: + sprintf(*buf, "GET_4ATOMS_GATOM_4B\n"); + break; + case GET_4ATOMS_GATOM_4BUNK: + sprintf(*buf, "GET_4ATOMS_GATOM_4BUNK\n"); + break; + case GET_4ATOMS_GATOM_4C: + sprintf(*buf, "GET_4ATOMS_GATOM_4C\n"); + break; + case GET_4ATOMS_GATOM_4CUNK: + sprintf(*buf, "GET_4ATOMS_GATOM_4CUNK\n"); + break; + case GET_4ATOMS_GATOM_4D: + sprintf(*buf, "GET_4ATOMS_GATOM_4D\n"); + break; + case GET_4ATOMS_GATOM_4DNONVAR: + sprintf(*buf, "GET_4ATOMS_GATOM_4DNONVAR\n"); + break; + case GET_4ATOMS_GATOM_4DUNK: + sprintf(*buf, "GET_4ATOMS_GATOM_4DUNK\n"); + break; + case GET_5ATOMS_INSTINIT: + sprintf(*buf, "GET_5ATOMS_INSTINIT\n"); + break; + case GET_5ATOMS_GATOM_5UNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5UNK\n"); + break; + case GET_5ATOMS_GATOM_5B: + sprintf(*buf, "GET_5ATOMS_GATOM_5B\n"); + break; + case GET_5ATOMS_GATOM_5BUNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5BUNK\n"); + break; + case GET_5ATOMS_GATOM_5C: + sprintf(*buf, "GET_5ATOMS_GATOM_5C\n"); + break; + case GET_5ATOMS_GATOM_5CUNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5CUNK\n"); + break; + case GET_5ATOMS_GATOM_5D: + sprintf(*buf, "GET_5ATOMS_GATOM_5D\n"); + break; + case GET_5ATOMS_GATOM_5DUNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5DUNK\n"); + break; + case GET_5ATOMS_GATOM_5E: + sprintf(*buf, "GET_5ATOMS_GATOM_5E\n"); + break; + case GET_5ATOMS_GATOM_5ENONVAR: + sprintf(*buf, "GET_5ATOMS_GATOM_5ENONVAR\n"); + break; + case GET_5ATOMS_GATOM_5EUNK: + sprintf(*buf, "GET_5ATOMS_GATOM_5EUNK\n"); + break; + case GET_6ATOMS_INSTINIT: + sprintf(*buf, "GET_6ATOMS_INSTINIT\n"); + break; + case GET_6ATOMS_GATOM_6UNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6UNK\n"); + break; + case GET_6ATOMS_GATOM_6B: + sprintf(*buf, "GET_6ATOMS_GATOM_6B\n"); + break; + case GET_6ATOMS_GATOM_6BUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6BUNK\n"); + break; + case GET_6ATOMS_GATOM_6C: + sprintf(*buf, "GET_6ATOMS_GATOM_6C\n"); + break; + case GET_6ATOMS_GATOM_6CUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6CUNK\n"); + break; + case GET_6ATOMS_GATOM_6D: + sprintf(*buf, "GET_6ATOMS_GATOM_6D\n"); + break; + case GET_6ATOMS_GATOM_6DUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6DUNK\n"); + break; + case GET_6ATOMS_GATOM_6E: + sprintf(*buf, "GET_6ATOMS_GATOM_6E\n"); + break; + case GET_6ATOMS_GATOM_6EUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6EUNK\n"); + break; + case GET_6ATOMS_GATOM_6F: + sprintf(*buf, "GET_6ATOMS_GATOM_6F\n"); + break; + case GET_6ATOMS_GATOM_6FNONVAR: + sprintf(*buf, "GET_6ATOMS_GATOM_6FNONVAR\n"); + break; + case GET_6ATOMS_GATOM_6FUNK: + sprintf(*buf, "GET_6ATOMS_GATOM_6FUNK\n"); + break; + case GET_LIST_INSTINIT: + sprintf(*buf, "GET_LIST_INSTINIT\n"); + break; + case GET_LIST_GLIST_NONVAR: + sprintf(*buf, "GET_LIST_GLIST_NONVAR\n"); + break; + case GET_LIST_GLIST_UNK: + sprintf(*buf, "GET_LIST_GLIST_UNK\n"); + break; + case GET_STRUCT_INSTINIT: + sprintf(*buf, "GET_STRUCT_INSTINIT\n"); + break; + case GET_STRUCT_GSTRUCT_NONVAR: + sprintf(*buf, "GET_STRUCT_GSTRUCT_NONVAR\n"); + break; + case GET_STRUCT_GSTRUCT_UNK: + sprintf(*buf, "GET_STRUCT_GSTRUCT_UNK\n"); + break; + case GET_FLOAT_INSTINIT: + sprintf(*buf, "GET_FLOAT_INSTINIT\n"); + break; + case GET_FLOAT_GFLOAT_NONVAR: + sprintf(*buf, "GET_FLOAT_GFLOAT_NONVAR\n"); + break; + case GET_FLOAT_GFLOAT_UNK: + sprintf(*buf, "GET_FLOAT_GFLOAT_UNK\n"); + break; + case GET_LONGINT_INSTINIT: + sprintf(*buf, "GET_LONGINT_INSTINIT\n"); + break; + case GET_LONGINT_GLONGINT_NONVAR: + sprintf(*buf, "GET_LONGINT_GLONGINT_NONVAR\n"); + break; + case GET_LONGINT_GLONGINT_UNK: + sprintf(*buf, "GET_LONGINT_GLONGINT_UNK\n"); + break; +#ifdef USE_GMP + case GET_BIGINT_INSTINIT: + sprintf(*buf, "GET_BIGINT_INSTINIT\n"); + break; + case GET_BIGINT_GBIGINT_NONVAR: + sprintf(*buf, "GET_BIGINT_GBIGINT_NONVAR\n"); + break; + case GET_BIGINT_GBIGINT_UNK: + sprintf(*buf, "GET_BIGINT_GBIGINT_UNK\n"); + break; +#endif + case GET_DBTERM_INSTINIT: + sprintf(*buf, "GET_DBTERM_INSTINIT\n"); + break; + case GET_DBTERM_GDBTERM_NONVAR: + sprintf(*buf, "GET_DBTERM_GDBTERM_NONVAR\n"); + break; + case GET_DBTERM_GDBTERM_UNK: + sprintf(*buf, "GET_DBTERM_GDBTERM_UNK\n"); + break; + case GLIST_VALX_INSTINIT: + sprintf(*buf, "GLIST_VALX_INSTINIT\n"); + break; + case GLIST_VALX_GLIST_VALX_READ: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_READ\n"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_NONVAR\n"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR_NONVAR: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_NONVAR_NONVAR\n"); + break; + case GLIST_VALX_GLIST_VALX_NONVAR_UNK: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_NONVAR_UNK\n"); + break; + case GLIST_VALX_GLIST_VALX_UNK: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_UNK\n"); + break; + case GLIST_VALX_GLIST_VALX_VAR_NONVAR: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_VAR_NONVAR\n"); + break; + case GLIST_VALX_GLIST_VALX_VAR_UNK: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_VAR_UNK\n"); + break; + case GLIST_VALX_GLIST_VALX_WRITE: + sprintf(*buf, "GLIST_VALX_GLIST_VALX_WRITE\n"); + break; + case GLIST_VALY_INSTINIT: + sprintf(*buf, "GLIST_VALY_INSTINIT\n"); + break; + case GLIST_VALY_GLIST_VALY_READ: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_READ\n"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_NONVAR\n"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR_NONVAR: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_NONVAR_NONVAR\n"); + break; + case GLIST_VALY_GLIST_VALY_NONVAR_UNK: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_NONVAR_UNK\n"); + break; + case GLIST_VALY_GLIST_VALY_UNK: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_UNK\n"); + break; + case GLIST_VALY_GLIST_VALY_VAR_NONVAR: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_VAR_NONVAR\n"); + break; + case GLIST_VALY_GLIST_VALY_VAR_UNK: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_VAR_UNK\n"); + break; + case GLIST_VALY_GLIST_VALY_WRITE: + sprintf(*buf, "GLIST_VALY_GLIST_VALY_WRITE\n"); + break; + case GL_VOID_VARX_INSTINIT: + sprintf(*buf, "GL_VOID_VARX_INSTINIT\n"); + break; + case GL_VOID_VARX_GLIST_VOID_VARX_READ: + sprintf(*buf, "GL_VOID_VARX_GLIST_VOID_VARX_READ\n"); + break; + case GL_VOID_VARX_GLIST_VOID_VAR_WRITE: + sprintf(*buf, "GL_VOID_VARX_GLIST_VOID_VAR_WRITE\n"); + break; + case GL_VOID_VARY_INSTINIT: + sprintf(*buf, "GL_VOID_VARY_INSTINIT\n"); + break; + case GL_VOID_VARY_GLIST_VOID_VARY_READ: + sprintf(*buf, "GL_VOID_VARY_GLIST_VOID_VARY_READ\n"); + break; + case GL_VOID_VARY_GLIST_VOID_VARY_WRITE: + sprintf(*buf, "GL_VOID_VARY_GLIST_VOID_VARY_WRITE\n"); + break; + case GL_VOID_VALX_INSTINIT: + sprintf(*buf, "GL_VOID_VALX_INSTINIT\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_READ: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_READ\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_NONVAR\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_UNK: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_UNK\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK\n"); + break; + case GL_VOID_VALX_GLIST_VOID_VALX_WRITE: + sprintf(*buf, "GL_VOID_VALX_GLIST_VOID_VALX_WRITE\n"); + break; + case GL_VOID_VALY_INSTINIT: + sprintf(*buf, "GL_VOID_VALY_INSTINIT\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_READ: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_READ\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_NONVAR\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_UNK: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_UNK\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK\n"); + break; + case GL_VOID_VALY_GLIST_VOID_VALY_WRITE: + sprintf(*buf, "GL_VOID_VALY_GLIST_VOID_VALY_WRITE\n"); + break; + case UNIFY_X_VAR_INSTINIT: + sprintf(*buf, "UNIFY_X_VAR_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_X_VAR_YAPOR_SBA: + sprintf(*buf, "UNIFY_X_VAR_YAPOR_SBA\n"); + break; +#endif + case UNIFY_X_VAR_END: + sprintf(*buf, "UNIFY_X_VAR_END\n"); + break; + case UNIFY_X_VAR_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_X_VAR_WRITE_INSTINIT\n"); + break; + case UNIFY_L_X_VAR_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAR_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_L_X_VAR_YAPOR_SBA: + sprintf(*buf, "UNIFY_L_X_VAR_YAPOR_SBA\n"); + break; +#endif + case UNIFY_L_X_VAR_END: + sprintf(*buf, "UNIFY_L_X_VAR_END\n"); + break; + case UNIFY_L_X_VAR_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAR_WRITE_INSTINIT\n"); + break; + case UNIFY_X_VAR2_INSTINIT: + sprintf(*buf, "UNIFY_X_VAR2_INSTINIT\n"); + break; +#ifdef YAPOR_SBA + case UNIFY_X_VAR2_YAPOR_SBA: + sprintf(*buf, "UNIFY_X_VAR2_YAPOR_SBA\n"); + break; +#endif + case UNIFY_X_VAR2_END: + sprintf(*buf, "UNIFY_X_VAR2_END\n"); + break; + case UNIFY_X_VAR2_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_X_VAR2_WRITE_INSTINIT\n"); + break; + case UNIFY_L_X_VAR2_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAR2_INSTINIT\n"); + break; + case UNIFY_L_X_VAR2_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAR2_WRITE_INSTINIT\n"); + break; + case UNIFY_Y_VAR_INSTINIT: + sprintf(*buf, "UNIFY_Y_VAR_INSTINIT\n"); + break; + case UNIFY_Y_VAR_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_Y_VAR_WRITE_INSTINIT\n"); + break; + case UNIFY_L_Y_VAR_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_VAR_INSTINIT\n"); + break; + case UNIFY_L_Y_VAR_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_VAR_WRITE_INSTINIT\n"); + break; + case UNIFY_X_VAL_INSTINIT: + sprintf(*buf, "UNIFY_X_VAL_INSTINIT\n"); + break; + case UNIFY_X_VAL_UVALX_NONVAR: + sprintf(*buf, "UNIFY_X_VAL_UVALX_NONVAR\n"); + break; + case UNIFY_X_VAL_UVALX_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_X_VAL_UVALX_NONVAR_NONVAR\n"); + break; + case UNIFY_X_VAL_UVALX_NONVAR_UNK: + sprintf(*buf, "UNIFY_X_VAL_UVALX_NONVAR_UNK\n"); + break; + case UNIFY_X_VAL_UVALX_UNK: + sprintf(*buf, "UNIFY_X_VAL_UVALX_UNK\n"); + break; + case UNIFY_X_VAL_UVALX_VAR_NONVAR: + sprintf(*buf, "UNIFY_X_VAL_UVALX_VAR_NONVAR\n"); + break; + case UNIFY_X_VAL_UVALX_VAR_UNK: + sprintf(*buf, "UNIFY_X_VAL_UVALX_VAR_UNK\n"); + break; + case UNIFY_X_VAL_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_X_VAL_WRITE_INSTINIT\n"); + break; + case UNIFY_L_X_VAL_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAL_INSTINIT\n"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_NONVAR\n"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR\n"); + break; + case UNIFY_L_X_VAL_ULVALX_NONVAR_UNK: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_NONVAR_UNK\n"); + break; + case UNIFY_L_X_VAL_ULVALX_UNK: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_UNK\n"); + break; + case UNIFY_L_X_VAL_ULVALX_VAR_NONVAR: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_VAR_NONVAR\n"); + break; + case UNIFY_L_X_VAL_ULVALX_VAR_UNK: + sprintf(*buf, "UNIFY_L_X_VAL_ULVALX_VAR_UNK\n"); + break; + case UNIFY_L_X_VAL_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_X_VAL_WRITE_INSTINIT\n"); + break; + case UNIFY_Y_VAL_INSTINIT: + sprintf(*buf, "UNIFY_Y_VAL_INSTINIT\n"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_NONVAR\n"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_NONVAR_NONVAR\n"); + break; + case UNIFY_Y_VAL_UVALY_NONVAR_UNK: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_NONVAR_UNK\n"); + break; + case UNIFY_Y_VAL_UVALY_UNK: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_UNK\n"); + break; + case UNIFY_Y_VAL_UVALY_VAR_NONVAR: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_VAR_NONVAR\n"); + break; + case UNIFY_Y_VAL_UVALY_VAR_UNK: + sprintf(*buf, "UNIFY_Y_VAL_UVALY_VAR_UNK\n"); + break; + case UNIFY_Y_VAL_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_Y_VAL_WRITE_INSTINIT\n"); + break; + case UNIFY_L_Y_VAL_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_VAL_INSTINIT\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_NONVAR\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_UNK: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_UNK\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR\n"); + break; + case UNIFY_L_Y_VAL_ULVALY_VAR_UNK: + sprintf(*buf, "UNIFY_L_Y_VAL_ULVALY_VAR_UNK\n"); + break; + case UNIFY_L_Y_VAL_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_VAL_WRITE_INSTINIT\n"); + break; + case UNIFY_X_LOC_INSTINIT: + sprintf(*buf, "UNIFY_X_LOC_INSTINIT\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_NONVAR\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_UNK: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_UNK\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR\n"); + break; + case UNIFY_X_LOC_UVALX_LOC_VAR_UNK: + sprintf(*buf, "UNIFY_X_LOC_UVALX_LOC_VAR_UNK\n"); + break; + case UNIFY_X_LOC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_X_LOC_WRITE_INSTINIT\n"); + break; + case UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR: + sprintf(*buf, "UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR\n"); + break; + case UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK: + sprintf(*buf, "UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK\n"); + break; + case UNIFY_L_X_LOC_INSTINIT: + sprintf(*buf, "UNIFY_L_X_LOC_INSTINIT\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_NONVAR\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_UNK: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_UNK\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR\n"); + break; + case UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK: + sprintf(*buf, "UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK\n"); + break; + case UNIFY_L_X_LOC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_X_LOC_WRITE_INSTINIT\n"); + break; + case UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR: + sprintf(*buf, "UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR\n"); + break; + case UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK: + sprintf(*buf, "UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK\n"); + break; + case UNIFY_Y_LOC_INSTINIT: + sprintf(*buf, "UNIFY_Y_LOC_INSTINIT\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_NONVAR\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_UNK: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_UNK\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR\n"); + break; + case UNIFY_Y_LOC_UVALY_LOC_VAR_UNK: + sprintf(*buf, "UNIFY_Y_LOC_UVALY_LOC_VAR_UNK\n"); + break; + case UNIFY_Y_LOC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_Y_LOC_WRITE_INSTINIT\n"); + break; + case UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR: + sprintf(*buf, "UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR\n"); + break; + case UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK: + sprintf(*buf, "UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK\n"); + break; + case UNIFY_L_Y_LOC_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_LOC_INSTINIT\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_UNK: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_UNK\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR\n"); + break; + case UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK: + sprintf(*buf, "UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK\n"); + break; + case UNIFY_L_Y_LOC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_Y_LOC_WRITE_INSTINIT\n"); + break; + case UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR: + sprintf(*buf, "UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR\n"); + break; + case UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK: + sprintf(*buf, "UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK\n"); + break; + case UNIFY_VOID_INSTINIT: + sprintf(*buf, "UNIFY_VOID_INSTINIT\n"); + break; + case UNIFY_VOID_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_VOID_WRITE_INSTINIT\n"); + break; + case UNIFY_L_VOID_INSTINIT: + sprintf(*buf, "UNIFY_L_VOID_INSTINIT\n"); + break; + case UNIFY_L_VOID_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_VOID_WRITE_INSTINIT\n"); + break; + case UNIFY_N_VOIDS_INSTINIT: + sprintf(*buf, "UNIFY_N_VOIDS_INSTINIT\n"); + break; + case UNIFY_N_VOIDS_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_N_VOIDS_WRITE_INSTINIT\n"); + break; + case UNIFY_L_N_VOIDS_INSTINIT: + sprintf(*buf, "UNIFY_L_N_VOIDS_INSTINIT\n"); + break; + case UNIFY_L_N_VOIDS_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_N_VOIDS_WRITE_INSTINIT\n"); + break; + case UNIFY_ATOM_INSTINIT: + sprintf(*buf, "UNIFY_ATOM_INSTINIT\n"); + break; + case UNIFY_ATOM_UATOM_NONVAR: + sprintf(*buf, "UNIFY_ATOM_UATOM_NONVAR\n"); + break; + case UNIFY_ATOM_UATOM_UNK: + sprintf(*buf, "UNIFY_ATOM_UATOM_UNK\n"); + break; + case UNIFY_ATOM_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_ATOM_WRITE_INSTINIT\n"); + break; + case UNIFY_L_ATOM_INSTINIT: + sprintf(*buf, "UNIFY_L_ATOM_INSTINIT\n"); + break; + case UNIFY_L_ATOM_ULATOM_NONVAR: + sprintf(*buf, "UNIFY_L_ATOM_ULATOM_NONVAR\n"); + break; + case UNIFY_L_ATOM_ULATOM_UNK: + sprintf(*buf, "UNIFY_L_ATOM_ULATOM_UNK\n"); + break; + case UNIFY_L_ATOM_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_ATOM_WRITE_INSTINIT\n"); + break; + case UNIFY_N_ATOMS_INSTINIT: + sprintf(*buf, "UNIFY_N_ATOMS_INSTINIT\n"); + break; + case UNIFY_N_ATOMS_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_N_ATOMS_WRITE_INSTINIT\n"); + break; + case UNIFY_FLOAT_INSTINIT: + sprintf(*buf, "UNIFY_FLOAT_INSTINIT\n"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_INIT: + sprintf(*buf, "UNIFY_FLOAT_UFLOAT_NONVAR_INIT\n"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR: + sprintf(*buf, "UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR\n"); + break; + case UNIFY_FLOAT_UFLOAT_NONVAR_END: + sprintf(*buf, "UNIFY_FLOAT_UFLOAT_NONVAR_END\n"); + break; + case UNIFY_FLOAT_UFLOAT_UNK: + sprintf(*buf, "UNIFY_FLOAT_UFLOAT_UNK\n"); + break; + case UNIFY_FLOAT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_FLOAT_WRITE_INSTINIT\n"); + break; + case UNIFY_L_FLOAT_INSTINIT: + sprintf(*buf, "UNIFY_L_FLOAT_INSTINIT\n"); + break; + case UNIFY_L_FLOAT_D0ISAPPL: + sprintf(*buf, "UNIFY_L_FLOAT_D0ISAPPL\n"); + break; + case UNIFY_L_FLOAT_D0ISFUNC: + sprintf(*buf, "UNIFY_L_FLOAT_D0ISFUNC\n"); + break; + case UNIFY_L_FLOAT_EQUALS: + sprintf(*buf, "UNIFY_L_FLOAT_EQUALS\n"); + break; + case UNIFY_L_FLOAT_ULFLOAT_UNK: + sprintf(*buf, "UNIFY_L_FLOAT_ULFLOAT_UNK\n"); + break; + case UNIFY_L_FLOAT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_FLOAT_WRITE_INSTINIT\n"); + break; + case UNIFY_LONGINT_INSTINIT: + sprintf(*buf, "UNIFY_LONGINT_INSTINIT\n"); + break; + case UNIFY_LONGINT_D0ISAPPL: + sprintf(*buf, "UNIFY_LONGINT_D0ISAPPL\n"); + break; + case UNIFY_LONGINT_D0ISFUNC: + sprintf(*buf, "UNIFY_LONGINT_D0ISFUNC\n"); + break; + case UNIFY_LONGINT_EQUALS: + sprintf(*buf, "UNIFY_LONGINT_EQUALS\n"); + break; + case UNIFY_LONGINT_ULONGINT_UNK: + sprintf(*buf, "UNIFY_LONGINT_ULONGINT_UNK\n"); + break; + case UNIFY_LONGINT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_LONGINT_WRITE_INSTINIT\n"); + break; + case UNIFY_L_LONGINT_INSTINIT: + sprintf(*buf, "UNIFY_L_LONGINT_INSTINIT\n"); + break; + case UNIFY_L_LONGINT_D0ISAPPL: + sprintf(*buf, "UNIFY_L_LONGINT_D0ISAPPL\n"); + break; + case UNIFY_L_LONGINT_D0ISFUNC: + sprintf(*buf, "UNIFY_L_LONGINT_D0ISFUNC\n"); + break; + case UNIFY_L_LONGINT_EQUALS: + sprintf(*buf, "UNIFY_L_LONGINT_EQUALS\n"); + break; + case UNIFY_L_LONGINT_ULLONGINT_UNK: + sprintf(*buf, "UNIFY_L_LONGINT_ULLONGINT_UNK\n"); + break; + case UNIFY_L_LONGINT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_LONGINT_WRITE_INSTINIT\n"); + break; +#ifdef USE_GMP + case UNIFY_BIGINT_INSTINIT: + sprintf(*buf, "UNIFY_BIGINT_INSTINIT\n"); + break; + case UNIFY_BIGINT_D0ISAPPL: + sprintf(*buf, "UNIFY_BIGINT_D0ISAPPL\n"); + break; + case UNIFY_BIGINT_D1ISFUNC_GMP: + sprintf(*buf, "UNIFY_BIGINT_D1ISFUNC_GMP\n"); + break; + case UNIFY_BIGINT_UBIGINT_UNK: + sprintf(*buf, "UNIFY_BIGINT_UBIGINT_UNK\n"); + break; + case UNIFY_L_BIGINT_INSTINIT: + sprintf(*buf, "UNIFY_L_BIGINT_INSTINIT\n"); + break; + case UNIFY_L_BIGINT_D0ISAPPL: + sprintf(*buf, "UNIFY_L_BIGINT_D0ISAPPL\n"); + break; + case UNIFY_L_BIGINT_D0ISFUNC_GMP: + sprintf(*buf, "UNIFY_L_BIGINT_D0ISFUNC_GMP\n"); + break; + case UNIFY_L_BIGINT_ULBIGINT_UNK: + sprintf(*buf, "UNIFY_L_BIGINT_ULBIGINT_UNK\n"); + break; +#endif + case UNIFY_DBTERM_INSTINIT: + sprintf(*buf, "UNIFY_DBTERM_INSTINIT\n"); + break; + case UNIFY_DBTERM_UDBTERM_NONVAR: + sprintf(*buf, "UNIFY_DBTERM_UDBTERM_NONVAR\n"); + break; + case UNIFY_DBTERM_UDBTERM_UNK: + sprintf(*buf, "UNIFY_DBTERM_UDBTERM_UNK\n"); + break; + case UNIFY_L_DBTERM_INSTINIT: + sprintf(*buf, "UNIFY_L_DBTERM_INSTINIT\n"); + break; + case UNIFY_L_DBTERM_ULDBTERM_NONVAR: + sprintf(*buf, "UNIFY_L_DBTERM_ULDBTERM_NONVAR\n"); + break; + case UNIFY_L_DBTERM_ULDBTERM_UNK: + sprintf(*buf, "UNIFY_L_DBTERM_ULDBTERM_UNK\n"); + break; + case UNIFY_LIST_INSTINIT: + sprintf(*buf, "UNIFY_LIST_INSTINIT\n"); + break; + case UNIFY_LIST_READMODE: + sprintf(*buf, "UNIFY_LIST_READMODE\n"); + break; + case UNIFY_LIST_WRITEMODE: + sprintf(*buf, "UNIFY_LIST_WRITEMODE\n"); + break; + case UNIFY_LIST_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_LIST_WRITE_INSTINIT\n"); + break; + case UNIFY_L_LIST_INSTINIT: + sprintf(*buf, "UNIFY_L_LIST_INSTINIT\n"); + break; + case UNIFY_L_LIST_READMODE: + sprintf(*buf, "UNIFY_L_LIST_READMODE\n"); + break; + case UNIFY_L_LIST_WRITEMODE: + sprintf(*buf, "UNIFY_L_LIST_WRITEMODE\n"); + break; + case UNIFY_L_LIST_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_LIST_WRITE_INSTINIT\n"); + break; + case UNIFY_STRUCT_INSTINIT: + sprintf(*buf, "UNIFY_STRUCT_INSTINIT\n"); + break; + case UNIFY_STRUCT_READMODE: + sprintf(*buf, "UNIFY_STRUCT_READMODE\n"); + break; + case UNIFY_STRUCT_WRITEMODE: + sprintf(*buf, "UNIFY_STRUCT_WRITEMODE\n"); + break; + case UNIFY_STRUCT_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_STRUCT_WRITE_INSTINIT\n"); + break; + case UNIFY_L_STRUC_INSTINIT: + sprintf(*buf, "UNIFY_L_STRUC_INSTINIT\n"); + break; + case UNIFY_L_STRUC_READMODE: + sprintf(*buf, "UNIFY_L_STRUC_READMODE\n"); + break; + case UNIFY_L_STRUC_WRITEMODE: + sprintf(*buf, "UNIFY_L_STRUC_WRITEMODE\n"); + break; + case UNIFY_L_STRUC_WRITE_INSTINIT: + sprintf(*buf, "UNIFY_L_STRUC_WRITE_INSTINIT\n"); + break; + case PUT_X_VAR_INSTINIT: + sprintf(*buf, "PUT_X_VAR_INSTINIT\n"); + break; + case PUT_Y_VAR_INSTINIT: + sprintf(*buf, "PUT_Y_VAR_INSTINIT\n"); + break; + case PUT_X_VAL_INSTINIT: + sprintf(*buf, "PUT_X_VAL_INSTINIT\n"); + break; + case PUT_XX_VAL_INSTINIT: + sprintf(*buf, "PUT_XX_VAL_INSTINIT\n"); + break; + case PUT_Y_VAL_INSTINIT: + sprintf(*buf, "PUT_Y_VAL_INSTINIT\n"); + break; + case PUT_Y_VALS_INSTINIT: + sprintf(*buf, "PUT_Y_VALS_INSTINIT\n"); + break; + case PUT_UNSAFE_INSTINIT: + sprintf(*buf, "PUT_UNSAFE_INSTINIT\n"); + break; + case PUT_UNSAFE_PUNSAFE_NONVAR: + sprintf(*buf, "PUT_UNSAFE_PUNSAFE_NONVAR\n"); + break; + case PUT_UNSAFE_PUNSAFE_UNK: + sprintf(*buf, "PUT_UNSAFE_PUNSAFE_UNK\n"); + break; + case PUT_ATOM_INSTINIT: + sprintf(*buf, "PUT_ATOM_INSTINIT\n"); + break; + case PUT_DBTERM_INSTINIT: + sprintf(*buf, "PUT_DBTERM_INSTINIT\n"); + break; + case PUT_BIGINT_INSTINIT: + sprintf(*buf, "PUT_BIGINT_INSTINIT\n"); + break; + case PUT_FLOAT_INSTINIT: + sprintf(*buf, "PUT_FLOAT_INSTINIT\n"); + break; + case PUT_LONGINT_INSTINIT: + sprintf(*buf, "PUT_LONGINT_INSTINIT\n"); + break; + case PUT_LIST_INSTINIT: + sprintf(*buf, "PUT_LIST_INSTINIT\n"); + break; + case PUT_STRUCT_INSTINIT: + sprintf(*buf, "PUT_STRUCT_INSTINIT\n"); + break; + case WRITE_X_VAR_INSTINIT: + sprintf(*buf, "WRITE_X_VAR_INSTINIT\n"); + break; + case WRITE_VOID_INSTINIT: + sprintf(*buf, "WRITE_VOID_INSTINIT\n"); + break; + case WRITE_N_VOIDS_INSTINIT: + sprintf(*buf, "WRITE_N_VOIDS_INSTINIT\n"); + break; + case WRITE_Y_VAR_INSTINIT: + sprintf(*buf, "WRITE_Y_VAR_INSTINIT\n"); + break; + case WRITE_X_VAL_INSTINIT: + sprintf(*buf, "WRITE_X_VAL_INSTINIT\n"); + break; + case WRITE_X_LOC_INSTINIT: + sprintf(*buf, "WRITE_X_LOC_INSTINIT\n"); + break; + case WRITE_X_LOC_W_X_BOUND: + sprintf(*buf, "WRITE_X_LOC_W_X_BOUND\n"); + break; + case WRITE_X_LOC_W_X_UNK: + sprintf(*buf, "WRITE_X_LOC_W_X_UNK\n"); + break; + case WRITE_Y_VAL_INSTINIT: + sprintf(*buf, "WRITE_Y_VAL_INSTINIT\n"); + break; + case WRITE_Y_LOC_INSTINIT: + sprintf(*buf, "WRITE_Y_LOC_INSTINIT\n"); + break; + case WRITE_Y_LOC_W_Y_BOUND: + sprintf(*buf, "WRITE_Y_LOC_W_Y_BOUND\n"); + break; + case WRITE_Y_LOC_W_Y_UNK: + sprintf(*buf, "WRITE_Y_LOC_W_Y_UNK\n"); + break; + case WRITE_ATOM_INSTINIT: + sprintf(*buf, "WRITE_ATOM_INSTINIT\n"); + break; + case WRITE_BIGINT_INSTINIT: + sprintf(*buf, "WRITE_BIGINT_INSTINIT\n"); + break; + case WRITE_DBTERM_INSTINIT: + sprintf(*buf, "WRITE_DBTERM_INSTINIT\n"); + break; + case WRITE_FLOAT_INSTINIT: + sprintf(*buf, "WRITE_FLOAT_INSTINIT\n"); + break; + case WRITE_LONGIT_INSTINIT: + sprintf(*buf, "WRITE_LONGIT_INSTINIT\n"); + break; + case WRITE_N_ATOMS_INSTINIT: + sprintf(*buf, "WRITE_N_ATOMS_INSTINIT\n"); + break; + case WRITE_LIST_INSTINIT: + sprintf(*buf, "WRITE_LIST_INSTINIT\n"); + break; + case WRITE_L_LIST_INSTINIT: + sprintf(*buf, "WRITE_L_LIST_INSTINIT\n"); + break; + case WRITE_STRUCT_INSTINIT: + sprintf(*buf, "WRITE_STRUCT_INSTINIT\n"); + break; + case WRITE_L_STRUC_INSTINIT: + sprintf(*buf, "WRITE_L_STRUC_INSTINIT\n"); + break; + case SAVE_PAIR_X_INSTINIT: + sprintf(*buf, "SAVE_PAIR_X_INSTINIT\n"); + break; + case SAVE_PAIR_X_WRITE_INSTINIT: + sprintf(*buf, "SAVE_PAIR_X_WRITE_INSTINIT\n"); + break; + case SAVE_PAIR_Y_INSTINIT: + sprintf(*buf, "SAVE_PAIR_Y_INSTINIT\n"); + break; + case SAVE_PAIR_Y_WRITE_INSTINIT: + sprintf(*buf, "SAVE_PAIR_Y_WRITE_INSTINIT\n"); + break; + case SAVE_APPL_X_INSTINIT: + sprintf(*buf, "SAVE_APPL_X_INSTINIT\n"); + break; + case SAVE_APPL_X_WRITE_INSTINIT: + sprintf(*buf, "SAVE_APPL_X_WRITE_INSTINIT\n"); + break; + case SAVE_APPL_Y_INSTINIT: + sprintf(*buf, "SAVE_APPL_Y_INSTINIT\n"); + break; + case SAVE_APPL_Y_WRITE_INSTINIT: + sprintf(*buf, "SAVE_APPL_Y_WRITE_INSTINIT\n"); + break; + case JUMP_INSTINIT: + sprintf(*buf, "JUMP_INSTINIT\n"); + break; + case MOVE_BACK_INSTINIT: + sprintf(*buf, "MOVE_BACK_INSTINIT\n"); + break; + case SKIP_INSTINIT: + sprintf(*buf, "SKIP_INSTINIT\n"); + break; + case EITHER_INSTINIT: + sprintf(*buf, "EITHER_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case EITHER_LOW_LEVEL_TRACER: + sprintf(*buf, "EITHER_LOW_LEVEL_TRACER\n"); + break; +#endif + case EITHER_POST_COROUTINING: + sprintf(*buf, "EITHER_POST_COROUTINING\n"); + break; + case EITHER_FROZEN_YSBA: + sprintf(*buf, "EITHER_FROZEN_YSBA\n"); + break; + case EITHER_POST_FROZEN_YSBA: + sprintf(*buf, "EITHER_POST_FROZEN_YSBA\n"); + break; +#ifdef YAPOR + case EITHER_YAPOR: + sprintf(*buf, "EITHER_YAPOR\n"); + break; +#endif + case EITHER_END: + sprintf(*buf, "EITHER_END\n"); + break; + case OR_ELSE_INSTINIT: + sprintf(*buf, "OR_ELSE_INSTINIT\n"); + break; +#ifdef DEPTH_LIMIT + case OR_ELSE_DEPTH: + sprintf(*buf, "OR_ELSE_DEPTH\n"); + break; +#endif + case OR_ELSE_POST_DEPTH: + sprintf(*buf, "OR_ELSE_POST_DEPTH\n"); + break; +#ifdef YAPOR + case OR_ELSE_YAPOR: + sprintf(*buf, "OR_ELSE_YAPOR\n"); + break; +#endif + case OR_ELSE_END: + sprintf(*buf, "OR_ELSE_END\n"); + break; + case OR_LAST_INSTINIT: + sprintf(*buf, "OR_LAST_INSTINIT\n"); + break; +#ifdef YAPOR + case OR_LAST_IFOK_INIT: + sprintf(*buf, "OR_LAST_IFOK_INIT\n"); + break; +#ifdef DEPTH_LIMIT + case OR_LAST_IFOK_DEPTH: + sprintf(*buf, "OR_LAST_IFOK_DEPTH\n"); + break; +#endif + case OR_LAST_IFOK_END: + sprintf(*buf, "OR_LAST_IFOK_END\n"); + break; +#endif + case OR_LAST_NOIF_INIT: + sprintf(*buf, "OR_LAST_NOIF_INIT\n"); + break; +#ifdef DEPTH_LIMIT + case OR_LAST_NOIF_DEPTH: + sprintf(*buf, "OR_LAST_NOIF_DEPTH\n"); + break; +#endif + case OR_LAST_NOIF_END: + sprintf(*buf, "OR_LAST_NOIF_END\n"); + break; +#ifdef YAPOR + case OR_LAST_YAPOR: + sprintf(*buf, "OR_LAST_YAPOR\n"); + break; +#else + case OR_LAST_NOYAPOR: + sprintf(*buf, "OR_LAST_NOYAPOR\n"); + break; +#endif + case OR_LAST_END: + sprintf(*buf, "OR_LAST_END\n"); + break; + case POP_N_INSTINIT: + sprintf(*buf, "POP_N_INSTINIT\n"); + break; + case POP_N_END: + sprintf(*buf, "POP_N_END\n"); + break; + case POP_INSTINIT: + sprintf(*buf, "POP_INSTINIT\n"); + break; + case POP_END: + sprintf(*buf, "POP_END\n"); + break; + case CALL_CPRED_INSTINIT: + sprintf(*buf, "CALL_CPRED_INSTINIT\n"); + break; + case CALL_CPRED_TEST_STACK: + sprintf(*buf, "CALL_CPRED_TEST_STACK\n"); + break; +#ifdef FROZEN_STACKS + case CALL_CPRED_FROZEN_INIT: + sprintf(*buf, "CALL_CPRED_FROZEN_INIT\n"); + break; + case CALL_CPRED_TOPB: + sprintf(*buf, "CALL_CPRED_TOPB\n"); + break; +#else + case CALL_CPRED_NOFROZEN: + sprintf(*buf, "CALL_CPRED_NOFROZEN\n"); + break; +#endif +#ifdef LOW_LEVEL_TRACER + case CALL_CPRED_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_CPRED_LOW_LEVEL_TRACER\n"); + break; +#endif + case CALL_CPRED_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_CPRED_POST_LOW_LEVEL_TRACER\n"); + break; +#ifdef SHADOW_S + case CALL_CPRED_SETSREG: + sprintf(*buf, "CALL_CPRED_SETSREG\n"); + break; +#endif + case CALL_CPRED_END: + sprintf(*buf, "CALL_CPRED_END\n"); + break; + case EXECUTE_CPRED_INSTINIT: + sprintf(*buf, "EXECUTE_CPRED_INSTINIT\n"); + break; + case EXECUTE_CPRED_POST_CHECK_TRAIL: + sprintf(*buf, "EXECUTE_CPRED_POST_CHECK_TRAIL\n"); + break; +#ifdef FROZEN_STACKS + case EXECUTE_CPRED_FROZEN: + sprintf(*buf, "EXECUTE_CPRED_FROZEN\n"); + break; + case EXECUTE_CPRED_TOPB: + sprintf(*buf, "EXECUTE_CPRED_TOPB\n"); + break; +#else + case EXECUTE_CPRED_NOFROZEN: + sprintf(*buf, "EXECUTE_CPRED_NOFROZEN\n"); + break; +#endif + case EXECUTE_CPRED_POST_FROZEN: + sprintf(*buf, "EXECUTE_CPRED_POST_FROZEN\n"); + break; +#ifdef LOW_LEVEL_TRACER + case EXECUTE_CPRED_LOW_LEVEL_TRACER: + sprintf(*buf, "EXECUTE_CPRED_LOW_LEVEL_TRACER\n"); + break; +#endif + case EXECUTE_CPRED_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "EXECUTE_CPRED_POST_LOW_LEVEL_TRACER\n"); + break; + case EXECUTE_CPRED_SAVE_PC: + sprintf(*buf, "EXECUTE_CPRED_SAVE_PC\n"); + break; +#ifdef DEPTH_LIMIT + case EXECUTE_CPRED_DEPTH_MINOR: + sprintf(*buf, "EXECUTE_CPRED_DEPTH_MINOR\n"); + break; + case EXECUTE_CPRED_DEPTH_MOFPRED: + sprintf(*buf, "EXECUTE_CPRED_DEPTH_MOFPRED\n"); + break; + case EXECUTE_CPRED_DEPTH_END: + sprintf(*buf, "EXECUTE_CPRED_DEPTH_END\n"); + break; +#endif + case EXECUTE_CPRED_END: + sprintf(*buf, "EXECUTE_CPRED_END\n"); + break; + case CALL_USERCPRED_INSTINIT: + sprintf(*buf, "CALL_USERCPRED_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case CALL_USERCPRED_LOW_LEVEL_TRACER: + sprintf(*buf, "CALL_USERCPRED_LOW_LEVEL_TRACER\n"); + break; +#endif + case CALL_USERCPRED_FROZEN: + sprintf(*buf, "CALL_USERCPRED_FROZEN\n"); + break; + case CALL_USERCPRED_POST_FROZEN: + sprintf(*buf, "CALL_USERCPRED_POST_FROZEN\n"); + break; + case CALL_USERCPRED_END: + sprintf(*buf, "CALL_USERCPRED_END\n"); + break; + case LOCK_PRED_INSTINIT: + sprintf(*buf, "LOCK_PRED_INSTINIT\n"); + break; + case LOCK_PRED_FIRSTIFOK: + sprintf(*buf, "LOCK_PRED_FIRSTIFOK\n"); + break; + case LOCK_PRED_SECONDTIFOK: + sprintf(*buf, "LOCK_PRED_SECONDTIFOK\n"); + break; + case LOCK_PRED_END: + sprintf(*buf, "LOCK_PRED_END\n"); + break; + case INDEX_PRED_INSTINIT: + sprintf(*buf, "INDEX_PRED_INSTINIT\n"); + break; + case INDEX_PRED_END: + sprintf(*buf, "INDEX_PRED_END\n"); + break; +#if THREADS + case THREAD_LOCAL_INSTINIT: + sprintf(*buf, "THREAD_LOCAL_INSTINIT\n"); + break; +#endif + case EXPAND_INDEX_INSTINIT: + sprintf(*buf, "EXPAND_INDEX_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_INDEX_YAPOR_THREADS_NOPP: + sprintf(*buf, "EXPAND_INDEX_YAPOR_THREADS_NOPP\n"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT: + sprintf(*buf, "EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT\n"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK: + sprintf(*buf, "EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK\n"); + break; + case EXPAND_INDEX_YAPOR_THREADS_IFOK_END: + sprintf(*buf, "EXPAND_INDEX_YAPOR_THREADS_IFOK_END\n"); + break; +#endif +#ifdef SHADOW_S + case EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS: + sprintf(*buf, "EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS\n"); + break; +#endif + case EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS: + sprintf(*buf, "EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS\n"); + break; +#ifdef SHADOW_S + case EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG: + sprintf(*buf, "EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG\n"); + break; +#endif + case EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG: + sprintf(*buf, "EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_INDEX_UNLOCK: + sprintf(*buf, "EXPAND_INDEX_UNLOCK\n"); + break; +#endif + case EXPAND_INDEX_END: + sprintf(*buf, "EXPAND_INDEX_END\n"); + break; + case EXPAND_CLAUSES_INSTINIT: + sprintf(*buf, "EXPAND_CLAUSES_INSTINIT\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_CLAUSES_YAPOR_THREADS_NOPP: + sprintf(*buf, "EXPAND_CLAUSES_YAPOR_THREADS_NOPP\n"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT: + sprintf(*buf, "EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT\n"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK: + sprintf(*buf, "EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK\n"); + break; + case EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END: + sprintf(*buf, "EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END\n"); + break; +#endif + case EXPAND_CLAUSES_NOYAPOR_NOTHREADS: + sprintf(*buf, "EXPAND_CLAUSES_NOYAPOR_NOTHREADS\n"); + break; +#if defined(YAPOR) || defined(THREADS) + case EXPAND_CLAUSES_UNLOCK: + sprintf(*buf, "EXPAND_CLAUSES_UNLOCK\n"); + break; +#endif + case EXPAND_CLAUSES_END: + sprintf(*buf, "EXPAND_CLAUSES_END\n"); + break; + case UNDEF_P_INSTINIT: + sprintf(*buf, "UNDEF_P_INSTINIT\n"); + break; + case UNDEF_P_END: + sprintf(*buf, "UNDEF_P_END\n"); + break; + case SPY_PRED_INSTINIT: + sprintf(*buf, "SPY_PRED_INSTINIT\n"); + break; + case SPY_PRED_FIRSTIFOK: + sprintf(*buf, "SPY_PRED_FIRSTIFOK\n"); + break; + case SPY_PRED_SECONDIFOK_INIT: + sprintf(*buf, "SPY_PRED_SECONDIFOK_INIT\n"); + break; + case SPY_PRED_SECONDIFOK_FIRSTIFOK: + sprintf(*buf, "SPY_PRED_SECONDIFOK_FIRSTIFOK\n"); + break; + case SPY_PRED_SECONDIFOK_POST_FIRSTIF: + sprintf(*buf, "SPY_PRED_SECONDIFOK_POST_FIRSTIF\n"); + break; + case SPY_PRED_SECONDIFOK_SECONDIFOK: + sprintf(*buf, "SPY_PRED_SECONDIFOK_SECONDIFOK\n"); + break; + case SPY_PRED_SECONDIFOK_THIRDIFOK: + sprintf(*buf, "SPY_PRED_SECONDIFOK_THIRDIFOK\n"); + break; + case SPY_PRED_THIRDIFOK_INIT: + sprintf(*buf, "SPY_PRED_THIRDIFOK_INIT\n"); + break; + case SPY_PRED_THIRDIFOK_FIRSTIFOK: + sprintf(*buf, "SPY_PRED_THIRDIFOK_FIRSTIFOK\n"); + break; + case SPY_PRED_FOURTHIFOK: + sprintf(*buf, "SPY_PRED_FOURTHIFOK\n"); + break; + case SPY_PRED_POST_FOURTHIF: + sprintf(*buf, "SPY_PRED_POST_FOURTHIF\n"); + break; + case SPY_PRED_D0ISZERO: + sprintf(*buf, "SPY_PRED_D0ISZERO\n"); + break; + case SPY_PRED_D0ISNOZERO_INIT: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INIT\n"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT\n"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR\n"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR\n"); + break; + case SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR: + sprintf(*buf, "SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR\n"); + break; + case SPY_PRED_POST_IFS: + sprintf(*buf, "SPY_PRED_POST_IFS\n"); + break; +#ifdef THREADS + case SPY_PRED_THREADS_LOCK: + sprintf(*buf, "SPY_PRED_THREADS_LOCK\n"); + break; +#endif + case SPY_PRED_POST_LOCK: + sprintf(*buf, "SPY_PRED_POST_LOCK\n"); + break; +#ifdef THREADS + case SPY_PRED_THREADS_UNLOCK: + sprintf(*buf, "SPY_PRED_THREADS_UNLOCK\n"); + break; +#endif + case SPY_PRED_POST_UNLOCK: + sprintf(*buf, "SPY_PRED_POST_UNLOCK\n"); + break; +#ifdef LOW_LEVEL_TRACER + case SPY_PRED_LOW_LEVEL_TRACER: + sprintf(*buf, "SPY_PRED_LOW_LEVEL_TRACER\n"); + break; +#endif + case SPY_PRED_END: + sprintf(*buf, "SPY_PRED_END\n"); + break; + case TRY_CLAUSE_INSTINIT: + sprintf(*buf, "TRY_CLAUSE_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_CLAUSE_YAPOR: + sprintf(*buf, "TRY_CLAUSE_YAPOR\n"); + break; +#endif + case TRY_CLAUSE_END: + sprintf(*buf, "TRY_CLAUSE_END\n"); + break; + case TRY_CLAUSE2_INSTINIT: + sprintf(*buf, "TRY_CLAUSE2_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_CLAUSE2_YAPOR: + sprintf(*buf, "TRY_CLAUSE2_YAPOR\n"); + break; +#endif + case TRY_CLAUSE2_END: + sprintf(*buf, "TRY_CLAUSE2_END\n"); + break; + case TRY_CLAUSE3_INSTINIT: + sprintf(*buf, "TRY_CLAUSE3_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_CLAUSE3_YAPOR: + sprintf(*buf, "TRY_CLAUSE3_YAPOR\n"); + break; +#endif + case TRY_CLAUSE3_END: + sprintf(*buf, "TRY_CLAUSE3_END\n"); + break; + case TRY_CLAUSE4_INSTINIT: + sprintf(*buf, "TRY_CLAUSE4_INSTINIT\n"); + break; +#ifdef YAPOR + case TRY_CLAUSE4_YAPOR: + sprintf(*buf, "TRY_CLAUSE4_YAPOR\n"); + break; +#endif + case TRY_CLAUSE4_END: + sprintf(*buf, "TRY_CLAUSE4_END\n"); + break; + case RETRY_INSTINIT: + sprintf(*buf, "RETRY_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY_FROZEN: + sprintf(*buf, "RETRY_FROZEN\n"); + break; +#else + case RETRY_NOFROZEN: + sprintf(*buf, "RETRY_NOFROZEN\n"); + break; +#endif + case RETRY_END: + sprintf(*buf, "RETRY_END\n"); + break; + case RETRY2_INSTINIT: + sprintf(*buf, "RETRY2_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY2_FROZEN: + sprintf(*buf, "RETRY2_FROZEN\n"); + break; +#else + case RETRY2_NOFROZEN: + sprintf(*buf, "RETRY2_NOFROZEN\n"); + break; +#endif + case RETRY2_END: + sprintf(*buf, "RETRY2_END\n"); + break; + case RETRY3_INSTINIT: + sprintf(*buf, "RETRY3_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY3_FROZEN: + sprintf(*buf, "RETRY3_FROZEN\n"); + break; +#else + case RETRY3_NOFROZEN: + sprintf(*buf, "RETRY3_NOFROZEN\n"); + break; +#endif + case RETRY3_END: + sprintf(*buf, "RETRY3_END\n"); + break; + case RETRY4_INSTINIT: + sprintf(*buf, "RETRY4_INSTINIT\n"); + break; +#ifdef FROZEN_STACKS + case RETRY4_FROZEN: + sprintf(*buf, "RETRY4_FROZEN\n"); + break; +#else + case RETRY4_NOFROZEN: + sprintf(*buf, "RETRY4_NOFROZEN\n"); + break; +#endif + case RETRY4_END: + sprintf(*buf, "RETRY4_END\n"); + break; + case TRUST_INSTINIT: + sprintf(*buf, "TRUST_INSTINIT\n"); + break; +#ifdef YAPOR + case TRUST_IFOK_INIT: + sprintf(*buf, "TRUST_IFOK_INIT\n"); + break; +#ifdef FROZEN_STACKS + case TRUST_IFOK_FROZEN: + sprintf(*buf, "TRUST_IFOK_FROZEN\n"); + break; +#endif + case TRUST_IFOK_END: + sprintf(*buf, "TRUST_IFOK_END\n"); + break; +#endif + case TRUST_NOIF_INIT: + sprintf(*buf, "TRUST_NOIF_INIT\n"); + break; +#ifdef FROZEN_STACKS + case TRUST_NOIF_FROZEN: + sprintf(*buf, "TRUST_NOIF_FROZEN\n"); + break; +#endif + case TRUST_END: + sprintf(*buf, "TRUST_END\n"); + break; + case TRY_IN_INSTINIT: + sprintf(*buf, "TRY_IN_INSTINIT\n"); + break; + case TRY_IN_END: + sprintf(*buf, "TRY_IN_END\n"); + break; + case USER_SWITCH_INSTINIT: + sprintf(*buf, "USER_SWITCH_INSTINIT\n"); + break; + case USER_SWITCH_END: + sprintf(*buf, "USER_SWITCH_END\n"); + break; + case SWITCH_ON_TYPE_INSTINIT: + sprintf(*buf, "SWITCH_ON_TYPE_INSTINIT\n"); + break; + case SWITCH_ON_TYPE_END: + sprintf(*buf, "SWITCH_ON_TYPE_END\n"); + break; + case SWITCH_LIST_NL_INSTINIT: + sprintf(*buf, "SWITCH_LIST_NL_INSTINIT\n"); + break; + case SWITCH_LIST_NL_END: + sprintf(*buf, "SWITCH_LIST_NL_END\n"); + break; + case SWITCH_ON_ARG_TYPE_INSTINIT: + sprintf(*buf, "SWITCH_ON_ARG_TYPE_INSTINIT\n"); + break; + case SWITCH_ON_ARG_TYPE_END: + sprintf(*buf, "SWITCH_ON_ARG_TYPE_END\n"); + break; + case SWITCH_ON_SUB_ARG_TYPE_INSTINIT: + sprintf(*buf, "SWITCH_ON_SUB_ARG_TYPE_INSTINIT\n"); + break; + case SWITCH_ON_SUB_ARG_TYPE_END: + sprintf(*buf, "SWITCH_ON_SUB_ARG_TYPE_END\n"); + break; + case JUMP_IF_VAR_INSTINIT: + sprintf(*buf, "JUMP_IF_VAR_INSTINIT\n"); + break; + case JUMP_IF_VAR_END: + sprintf(*buf, "JUMP_IF_VAR_END\n"); + break; + case JUMP_IF_NONVAR_INSTINIT: + sprintf(*buf, "JUMP_IF_NONVAR_INSTINIT\n"); + break; + case JUMP_IF_NONVAR_END: + sprintf(*buf, "JUMP_IF_NONVAR_END\n"); + break; + case IF_NOT_THEN_INSTINIT: + sprintf(*buf, "IF_NOT_THEN_INSTINIT\n"); + break; + case IF_NOT_THEN_END: + sprintf(*buf, "IF_NOT_THEN_END\n"); + break; + case SWITCH_ON_FUNC_INSTINIT: + sprintf(*buf, "SWITCH_ON_FUNC_INSTINIT\n"); + break; + case SWITCH_ON_FUNC_END: + sprintf(*buf, "SWITCH_ON_FUNC_END\n"); + break; + case SWITCH_ON_CONS_INSTINIT: + sprintf(*buf, "SWITCH_ON_CONS_INSTINIT\n"); + break; + case SWITCH_ON_CONS_END: + sprintf(*buf, "SWITCH_ON_CONS_END\n"); + break; + case GO_ON_FUNC_INSTINIT: + sprintf(*buf, "GO_ON_FUNC_INSTINIT\n"); + break; + case GO_ON_FUNC_END: + sprintf(*buf, "GO_ON_FUNC_END\n"); + break; + case GO_ON_CONS_INSTINIT: + sprintf(*buf, "GO_ON_CONS_INSTINIT\n"); + break; + case GO_ON_CONS_END: + sprintf(*buf, "GO_ON_CONS_END\n"); + break; + case IF_FUNC_INSTINIT: + sprintf(*buf, "IF_FUNC_INSTINIT\n"); + break; + case IF_FUNC_END: + sprintf(*buf, "IF_FUNC_END\n"); + break; + case IF_CONS_INSTINIT: + sprintf(*buf, "IF_CONS_INSTINIT\n"); + break; + case IF_CONS_END: + sprintf(*buf, "IF_CONS_END\n"); + break; + case INDEX_DBREF_INSTINIT: + sprintf(*buf, "INDEX_DBREF_INSTINIT\n"); + break; + case INDEX_DBREF_END: + sprintf(*buf, "INDEX_DBREF_END\n"); + break; + case INDEX_BLOB_INSTINIT: + sprintf(*buf, "INDEX_BLOB_INSTINIT\n"); + break; + case INDEX_BLOB_END: + sprintf(*buf, "INDEX_BLOB_END\n"); + break; + case INDEX_LONG_INSTINIT: + sprintf(*buf, "INDEX_LONG_INSTINIT\n"); + break; + case INDEX_LONG_END: + sprintf(*buf, "INDEX_LONG_END\n"); + break; + case JIT_HANDLER_INSTINIT: + sprintf(*buf, "JIT_HANDLER_INSTINIT\n"); + break; + case P_ATOM_X_INSTINIT: + sprintf(*buf, "P_ATOM_X_INSTINIT\n"); + break; + case P_ATOM_X_ATOM: + sprintf(*buf, "P_ATOM_X_ATOM\n"); + break; + case P_ATOM_X_NOATOM: + sprintf(*buf, "P_ATOM_X_NOATOM\n"); + break; + case P_ATOM_Y_INSTINIT: + sprintf(*buf, "P_ATOM_Y_INSTINIT\n"); + break; + case P_ATOM_Y_IFOK: + sprintf(*buf, "P_ATOM_Y_IFOK\n"); + break; + case P_ATOM_Y_NOIF: + sprintf(*buf, "P_ATOM_Y_NOIF\n"); + break; + case P_ATOM_Y_END: + sprintf(*buf, "P_ATOM_Y_END\n"); + break; + case P_ATOMIC_X_INSTINIT: + sprintf(*buf, "P_ATOMIC_X_INSTINIT\n"); + break; + case P_ATOMIC_X_NONVAR: + sprintf(*buf, "P_ATOMIC_X_NONVAR\n"); + break; + case P_ATOMIC_X_VAR: + sprintf(*buf, "P_ATOMIC_X_VAR\n"); + break; + case P_ATOMIC_X_END: + sprintf(*buf, "P_ATOMIC_X_END\n"); + break; + case P_ATOMIC_Y_INSTINIT: + sprintf(*buf, "P_ATOMIC_Y_INSTINIT\n"); + break; + case P_ATOMIC_Y_NONVAR: + sprintf(*buf, "P_ATOMIC_Y_NONVAR\n"); + break; + case P_ATOMIC_Y_VAR: + sprintf(*buf, "P_ATOMIC_Y_VAR\n"); + break; + case P_ATOMIC_Y_END: + sprintf(*buf, "P_ATOMIC_Y_END\n"); + break; + case P_INTEGER_X_INSTINIT: + sprintf(*buf, "P_INTEGER_X_INSTINIT\n"); + break; + case P_INTEGER_X_INTEGER_X_NVAR_OK: + sprintf(*buf, "P_INTEGER_X_INTEGER_X_NVAR_OK\n"); + break; + case P_INTEGER_X_INTEGER_X_NVAR_NOOK: + sprintf(*buf, "P_INTEGER_X_INTEGER_X_NVAR_NOOK\n"); + break; + case P_INTEGER_X_INTEGER_X_UNK: + sprintf(*buf, "P_INTEGER_X_INTEGER_X_UNK\n"); + break; + case P_INTEGER_Y_INSTINIT: + sprintf(*buf, "P_INTEGER_Y_INSTINIT\n"); + break; + case P_INTEGER_Y_INTEGER_Y_NVAR_OK: + sprintf(*buf, "P_INTEGER_Y_INTEGER_Y_NVAR_OK\n"); + break; + case P_INTEGER_Y_INTEGER_Y_NVAR_NOOK: + sprintf(*buf, "P_INTEGER_Y_INTEGER_Y_NVAR_NOOK\n"); + break; + case P_INTEGER_Y_INTEGER_Y_UNK: + sprintf(*buf, "P_INTEGER_Y_INTEGER_Y_UNK\n"); + break; + case P_NONVAR_X_INSTINIT: + sprintf(*buf, "P_NONVAR_X_INSTINIT\n"); + break; + case P_NONVAR_X_NONVAR: + sprintf(*buf, "P_NONVAR_X_NONVAR\n"); + break; + case P_NONVAR_X_NONONVAR: + sprintf(*buf, "P_NONVAR_X_NONONVAR\n"); + break; + case P_NONVAR_Y_INSTINIT: + sprintf(*buf, "P_NONVAR_Y_INSTINIT\n"); + break; + case P_NONVAR_Y_NONVAR: + sprintf(*buf, "P_NONVAR_Y_NONVAR\n"); + break; + case P_NONVAR_Y_NONONVAR: + sprintf(*buf, "P_NONVAR_Y_NONONVAR\n"); + break; + case P_NUMBER_X_INSTINIT: + sprintf(*buf, "P_NUMBER_X_INSTINIT\n"); + break; + case P_NUMBER_X_INT: + sprintf(*buf, "P_NUMBER_X_INT\n"); + break; + case P_NUMBER_X_FUNCTORINT: + sprintf(*buf, "P_NUMBER_X_FUNCTORINT\n"); + break; + case P_NUMBER_X_FUNCTORDEFAULT: + sprintf(*buf, "P_NUMBER_X_FUNCTORDEFAULT\n"); + break; + case P_NUMBER_X_POST_IF: + sprintf(*buf, "P_NUMBER_X_POST_IF\n"); + break; + case P_NUMBER_X_NUMBER_X_UNK: + sprintf(*buf, "P_NUMBER_X_NUMBER_X_UNK\n"); + break; + case P_NUMBER_Y_INSTINIT: + sprintf(*buf, "P_NUMBER_Y_INSTINIT\n"); + break; + case P_NUMBER_Y_INT: + sprintf(*buf, "P_NUMBER_Y_INT\n"); + break; + case P_NUMBER_Y_FUNCTORINT: + sprintf(*buf, "P_NUMBER_Y_FUNCTORINT\n"); + break; + case P_NUMBER_Y_FUNCTORDEFAULT: + sprintf(*buf, "P_NUMBER_Y_FUNCTORDEFAULT\n"); + break; + case P_NUMBER_Y_POST_IF: + sprintf(*buf, "P_NUMBER_Y_POST_IF\n"); + break; + case P_NUMBER_Y_NUMBER_Y_UNK: + sprintf(*buf, "P_NUMBER_Y_NUMBER_Y_UNK\n"); + break; + case P_VAR_X_INSTINIT: + sprintf(*buf, "P_VAR_X_INSTINIT\n"); + break; + case P_VAR_X_NONVAR: + sprintf(*buf, "P_VAR_X_NONVAR\n"); + break; + case P_VAR_X_VAR: + sprintf(*buf, "P_VAR_X_VAR\n"); + break; + case P_VAR_Y_INSTINIT: + sprintf(*buf, "P_VAR_Y_INSTINIT\n"); + break; + case P_VAR_Y_NONVAR: + sprintf(*buf, "P_VAR_Y_NONVAR\n"); + break; + case P_VAR_Y_VAR: + sprintf(*buf, "P_VAR_Y_VAR\n"); + break; + case P_DB_REF_X_INSTINIT: + sprintf(*buf, "P_DB_REF_X_INSTINIT\n"); + break; + case P_DB_REF_X_DBREF: + sprintf(*buf, "P_DB_REF_X_DBREF\n"); + break; + case P_DB_REF_X_NODBREF: + sprintf(*buf, "P_DB_REF_X_NODBREF\n"); + break; + case P_DB_REF_X_DBREF_X_UNK: + sprintf(*buf, "P_DB_REF_X_DBREF_X_UNK\n"); + break; + case P_DB_REF_Y_INSTINIT: + sprintf(*buf, "P_DB_REF_Y_INSTINIT\n"); + break; + case P_DB_REF_Y_DBREF: + sprintf(*buf, "P_DB_REF_Y_DBREF\n"); + break; + case P_DB_REF_Y_NODBREF: + sprintf(*buf, "P_DB_REF_Y_NODBREF\n"); + break; + case P_DB_REF_Y_DBREF_Y_UNK: + sprintf(*buf, "P_DB_REF_Y_DBREF_Y_UNK\n"); + break; + case P_PRIMITIVE_X_INSTINIT: + sprintf(*buf, "P_PRIMITIVE_X_INSTINIT\n"); + break; + case P_PRIMITIVE_X_PRIMITIVE: + sprintf(*buf, "P_PRIMITIVE_X_PRIMITIVE\n"); + break; + case P_PRIMITIVE_X_NOPRIMITIVE: + sprintf(*buf, "P_PRIMITIVE_X_NOPRIMITIVE\n"); + break; + case P_PRIMITIVE_X_PRIMI_X_UNK: + sprintf(*buf, "P_PRIMITIVE_X_PRIMI_X_UNK\n"); + break; + case P_PRIMITIVE_Y_INSTINIT: + sprintf(*buf, "P_PRIMITIVE_Y_INSTINIT\n"); + break; + case P_PRIMITIVE_Y_PRIMITIVE: + sprintf(*buf, "P_PRIMITIVE_Y_PRIMITIVE\n"); + break; + case P_PRIMITIVE_Y_NOPRIMITIVE: + sprintf(*buf, "P_PRIMITIVE_Y_NOPRIMITIVE\n"); + break; + case P_PRIMITIVE_Y_PRIMI_Y_UNK: + sprintf(*buf, "P_PRIMITIVE_Y_PRIMI_Y_UNK\n"); + break; + case P_COMPOUND_X_INSTINIT: + sprintf(*buf, "P_COMPOUND_X_INSTINIT\n"); + break; + case P_COMPOUND_X_PAIR: + sprintf(*buf, "P_COMPOUND_X_PAIR\n"); + break; + case P_COMPOUND_X_APPL_IFOK: + sprintf(*buf, "P_COMPOUND_X_APPL_IFOK\n"); + break; + case P_COMPOUND_X_APPL: + sprintf(*buf, "P_COMPOUND_X_APPL\n"); + break; + case P_COMPOUND_X_NOAPPL: + sprintf(*buf, "P_COMPOUND_X_NOAPPL\n"); + break; + case P_COMPOUND_X_COMPOUND_X_UNK: + sprintf(*buf, "P_COMPOUND_X_COMPOUND_X_UNK\n"); + break; + case P_COMPOUND_Y_INSTINIT: + sprintf(*buf, "P_COMPOUND_Y_INSTINIT\n"); + break; + case P_COMPOUND_Y_PAIR: + sprintf(*buf, "P_COMPOUND_Y_PAIR\n"); + break; + case P_COMPOUND_Y_APPL_IFOK: + sprintf(*buf, "P_COMPOUND_Y_APPL_IFOK\n"); + break; + case P_COMPOUND_Y_APPL: + sprintf(*buf, "P_COMPOUND_Y_APPL\n"); + break; + case P_COMPOUND_Y_NOAPPL: + sprintf(*buf, "P_COMPOUND_Y_NOAPPL\n"); + break; + case P_COMPOUND_Y_COMPOUND_Y_UNK: + sprintf(*buf, "P_COMPOUND_Y_COMPOUND_Y_UNK\n"); + break; + case P_FLOAT_X_INSTINIT: + sprintf(*buf, "P_FLOAT_X_INSTINIT\n"); + break; + case P_FLOAT_X_FLOAT: + sprintf(*buf, "P_FLOAT_X_FLOAT\n"); + break; + case P_FLOAT_X_POST_IF: + sprintf(*buf, "P_FLOAT_X_POST_IF\n"); + break; + case P_FLOAT_X_FLOAT_X_UNK: + sprintf(*buf, "P_FLOAT_X_FLOAT_X_UNK\n"); + break; + case P_FLOAT_Y_INSTINIT: + sprintf(*buf, "P_FLOAT_Y_INSTINIT\n"); + break; + case P_FLOAT_Y_FLOAT: + sprintf(*buf, "P_FLOAT_Y_FLOAT\n"); + break; + case P_FLOAT_Y_POST_IF: + sprintf(*buf, "P_FLOAT_Y_POST_IF\n"); + break; + case P_FLOAT_Y_FLOAT_Y_UNK: + sprintf(*buf, "P_FLOAT_Y_FLOAT_Y_UNK\n"); + break; + case P_PLUS_VV_INSTINIT: + sprintf(*buf, "P_PLUS_VV_INSTINIT\n"); + break; + case P_PLUS_VV_PLUS_VV_NVAR: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_NVAR\n"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT\n"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT\n"); + break; + case P_PLUS_VV_PLUS_VV_UNK: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_UNK\n"); + break; + case P_PLUS_VV_PLUS_VV_NVAR_UNK: + sprintf(*buf, "P_PLUS_VV_PLUS_VV_NVAR_UNK\n"); + break; + case P_PLUS_VC_INSTINIT: + sprintf(*buf, "P_PLUS_VC_INSTINIT\n"); + break; + case P_PLUS_VC_PLUS_VC_NVAR_INT: + sprintf(*buf, "P_PLUS_VC_PLUS_VC_NVAR_INT\n"); + break; + case P_PLUS_VC_PLUS_VC_NVAR_NOINT: + sprintf(*buf, "P_PLUS_VC_PLUS_VC_NVAR_NOINT\n"); + break; + case P_PLUS_VC_PLUS_VC_UNK: + sprintf(*buf, "P_PLUS_VC_PLUS_VC_UNK\n"); + break; + case P_PLUS_Y_VV_INSTINIT: + sprintf(*buf, "P_PLUS_Y_VV_INSTINIT\n"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR\n"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT\n"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT\n"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_UNK: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_UNK\n"); + break; + case P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK: + sprintf(*buf, "P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK\n"); + break; + case P_PLUS_Y_VC_INSTINIT: + sprintf(*buf, "P_PLUS_Y_VC_INSTINIT\n"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT: + sprintf(*buf, "P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT\n"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT: + sprintf(*buf, "P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT\n"); + break; + case P_PLUS_Y_VC_PLUS_Y_VC_UNK: + sprintf(*buf, "P_PLUS_Y_VC_PLUS_Y_VC_UNK\n"); + break; + case P_MINUS_VV_INSTINIT: + sprintf(*buf, "P_MINUS_VV_INSTINIT\n"); + break; + case P_MINUS_VV_MINUS_VV_NVAR: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_NVAR\n"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT\n"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT\n"); + break; + case P_MINUS_VV_MINUS_VV_UNK: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_UNK\n"); + break; + case P_MINUS_VV_MINUS_VV_NVAR_UNK: + sprintf(*buf, "P_MINUS_VV_MINUS_VV_NVAR_UNK\n"); + break; + case P_MINUS_CV_INSTINIT: + sprintf(*buf, "P_MINUS_CV_INSTINIT\n"); + break; + case P_MINUS_CV_MINUS_CV_NVAR_INT: + sprintf(*buf, "P_MINUS_CV_MINUS_CV_NVAR_INT\n"); + break; + case P_MINUS_CV_MINUS_CV_NVAR_NOINT: + sprintf(*buf, "P_MINUS_CV_MINUS_CV_NVAR_NOINT\n"); + break; + case P_MINUS_CV_MINUS_CV_UNK: + sprintf(*buf, "P_MINUS_CV_MINUS_CV_UNK\n"); + break; + case P_MINUS_Y_VV_INSTINIT: + sprintf(*buf, "P_MINUS_Y_VV_INSTINIT\n"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_NVAR: + sprintf(*buf, "P_MINUS_Y_VV_MINUS_Y_VV_NVAR\n"); + break; + case P_MINUS_Y_VV_INTTERM: + sprintf(*buf, "P_MINUS_Y_VV_INTTERM\n"); + break; + case P_MINUS_Y_VV_NOINTTERM: + sprintf(*buf, "P_MINUS_Y_VV_NOINTTERM\n"); + break; + case P_MINUS_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_MINUS_Y_VV_D0EQUALS0L\n"); + break; + case P_MINUS_Y_VV_NVAR_END: + sprintf(*buf, "P_MINUS_Y_VV_NVAR_END\n"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_UNK: + sprintf(*buf, "P_MINUS_Y_VV_MINUS_Y_VV_UNK\n"); + break; + case P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK: + sprintf(*buf, "P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK\n"); + break; + case P_MINUS_Y_CV_INSTINIT: + sprintf(*buf, "P_MINUS_Y_CV_INSTINIT\n"); + break; + case P_MINUS_Y_CV_MINUS_Y_CV_NVAR: + sprintf(*buf, "P_MINUS_Y_CV_MINUS_Y_CV_NVAR\n"); + break; + case P_MINUS_Y_CV_INTTERM: + sprintf(*buf, "P_MINUS_Y_CV_INTTERM\n"); + break; + case P_MINUS_Y_CV_NOINTTERM: + sprintf(*buf, "P_MINUS_Y_CV_NOINTTERM\n"); + break; + case P_MINUS_Y_CV_D0EQUALS0L: + sprintf(*buf, "P_MINUS_Y_CV_D0EQUALS0L\n"); + break; + case P_MINUS_Y_CV_NVAR_END: + sprintf(*buf, "P_MINUS_Y_CV_NVAR_END\n"); + break; + case P_MINUS_Y_CV_MINUS_Y_CV_UNK: + sprintf(*buf, "P_MINUS_Y_CV_MINUS_Y_CV_UNK\n"); + break; + case P_TIMES_VV_INSTINIT: + sprintf(*buf, "P_TIMES_VV_INSTINIT\n"); + break; + case P_TIMES_VV_TIMES_VV_NVAR: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_NVAR\n"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT\n"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT\n"); + break; + case P_TIMES_VV_TIMES_VV_UNK: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_UNK\n"); + break; + case P_TIMES_VV_TIMES_VV_NVAR_UNK: + sprintf(*buf, "P_TIMES_VV_TIMES_VV_NVAR_UNK\n"); + break; + case P_TIMES_VC_INSTINIT: + sprintf(*buf, "P_TIMES_VC_INSTINIT\n"); + break; + case P_TIMES_VC_TIMES_VC_NVAR_INT: + sprintf(*buf, "P_TIMES_VC_TIMES_VC_NVAR_INT\n"); + break; + case P_TIMES_VC_TIMES_VC_NVAR_NOINT: + sprintf(*buf, "P_TIMES_VC_TIMES_VC_NVAR_NOINT\n"); + break; + case P_TIMES_VC_TIMES_VC_UNK: + sprintf(*buf, "P_TIMES_VC_TIMES_VC_UNK\n"); + break; + case P_TIMES_Y_VV_INSTINIT: + sprintf(*buf, "P_TIMES_Y_VV_INSTINIT\n"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_NVAR: + sprintf(*buf, "P_TIMES_Y_VV_TIMES_Y_VV_NVAR\n"); + break; + case P_TIMES_Y_VV_INTTERM: + sprintf(*buf, "P_TIMES_Y_VV_INTTERM\n"); + break; + case P_TIMES_Y_VV_NOINTTERM: + sprintf(*buf, "P_TIMES_Y_VV_NOINTTERM\n"); + break; + case P_TIMES_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_TIMES_Y_VV_D0EQUALS0L\n"); + break; + case P_TIMES_Y_VV_NVAR_END: + sprintf(*buf, "P_TIMES_Y_VV_NVAR_END\n"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_UNK: + sprintf(*buf, "P_TIMES_Y_VV_TIMES_Y_VV_UNK\n"); + break; + case P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK: + sprintf(*buf, "P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK\n"); + break; + case P_TIMES_Y_VC_INSTINIT: + sprintf(*buf, "P_TIMES_Y_VC_INSTINIT\n"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT: + sprintf(*buf, "P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT\n"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT: + sprintf(*buf, "P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT\n"); + break; + case P_TIMES_Y_VC_NVAR_END: + sprintf(*buf, "P_TIMES_Y_VC_NVAR_END\n"); + break; + case P_TIMES_Y_VC_TIMES_Y_VC_UNK: + sprintf(*buf, "P_TIMES_Y_VC_TIMES_Y_VC_UNK\n"); + break; + case P_DIV_VV_INSTINIT: + sprintf(*buf, "P_DIV_VV_INSTINIT\n"); + break; + case P_DIV_VV_DIV_VV_NVAR: + sprintf(*buf, "P_DIV_VV_DIV_VV_NVAR\n"); + break; + case P_DIV_VV_DIV_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_DIV_VV_DIV_VV_NVAR_NVAR_INT\n"); + break; + case P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT\n"); + break; + case P_DIV_VV_DIV_VV_UNK: + sprintf(*buf, "P_DIV_VV_DIV_VV_UNK\n"); + break; + case P_DIV_VV_DIV_VV_NVAR_UNK: + sprintf(*buf, "P_DIV_VV_DIV_VV_NVAR_UNK\n"); + break; + case P_DIV_VC_INSTINIT: + sprintf(*buf, "P_DIV_VC_INSTINIT\n"); + break; + case P_DIV_VC_DIV_VC_NVAR: + sprintf(*buf, "P_DIV_VC_DIV_VC_NVAR\n"); + break; + case P_DIV_VC_INTTERM: + sprintf(*buf, "P_DIV_VC_INTTERM\n"); + break; + case P_DIV_VC_NOINTTERM: + sprintf(*buf, "P_DIV_VC_NOINTTERM\n"); + break; + case P_DIV_VC_D0EQUALS0L: + sprintf(*buf, "P_DIV_VC_D0EQUALS0L\n"); + break; + case P_DIV_VC_NVAR_END: + sprintf(*buf, "P_DIV_VC_NVAR_END\n"); + break; + case P_DIV_VC_DIV_VC_UNK: + sprintf(*buf, "P_DIV_VC_DIV_VC_UNK\n"); + break; + case P_DIV_CV_INSTINIT: + sprintf(*buf, "P_DIV_CV_INSTINIT\n"); + break; + case P_DIV_CV_DIV_CV_NVAR: + sprintf(*buf, "P_DIV_CV_DIV_CV_NVAR\n"); + break; + case P_DIV_CV_INTTERM_INIT: + sprintf(*buf, "P_DIV_CV_INTTERM_INIT\n"); + break; + case P_DIV_CV_INTTERM_DIVEQUALS0: + sprintf(*buf, "P_DIV_CV_INTTERM_DIVEQUALS0\n"); + break; + case P_DIV_CV_INTTERM_END: + sprintf(*buf, "P_DIV_CV_INTTERM_END\n"); + break; + case P_DIV_CV_NOINTTERM: + sprintf(*buf, "P_DIV_CV_NOINTTERM\n"); + break; + case P_DIV_CV_D0EQUALS0L: + sprintf(*buf, "P_DIV_CV_D0EQUALS0L\n"); + break; + case P_DIV_CV_NVAR_END: + sprintf(*buf, "P_DIV_CV_NVAR_END\n"); + break; + case P_DIV_CV_DIV_CV_UNK: + sprintf(*buf, "P_DIV_CV_DIV_CV_UNK\n"); + break; + case P_DIV_Y_VV_INSTINIT: + sprintf(*buf, "P_DIV_Y_VV_INSTINIT\n"); + break; + case P_DIV_Y_VV_DIV_Y_VV_NVAR: + sprintf(*buf, "P_DIV_Y_VV_DIV_Y_VV_NVAR\n"); + break; + case P_DIV_Y_VV_INTTERM_INIT: + sprintf(*buf, "P_DIV_Y_VV_INTTERM_INIT\n"); + break; + case P_DIV_Y_VV_INTTERM_DIVEQUALS0: + sprintf(*buf, "P_DIV_Y_VV_INTTERM_DIVEQUALS0\n"); + break; + case P_DIV_Y_VV_INTTERM_END: + sprintf(*buf, "P_DIV_Y_VV_INTTERM_END\n"); + break; + case P_DIV_Y_VV_NOINTTERM: + sprintf(*buf, "P_DIV_Y_VV_NOINTTERM\n"); + break; + case P_DIV_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_DIV_Y_VV_D0EQUALS0L\n"); + break; + case P_DIV_Y_VV_NVAR_END: + sprintf(*buf, "P_DIV_Y_VV_NVAR_END\n"); + break; + case P_DIV_Y_VV_DIV_Y_VV_UNK: + sprintf(*buf, "P_DIV_Y_VV_DIV_Y_VV_UNK\n"); + break; + case P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK: + sprintf(*buf, "P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK\n"); + break; + case P_DIV_Y_VC_INSTINIT: + sprintf(*buf, "P_DIV_Y_VC_INSTINIT\n"); + break; + case P_DIV_Y_VC_DIV_Y_VC_NVAR: + sprintf(*buf, "P_DIV_Y_VC_DIV_Y_VC_NVAR\n"); + break; + case P_DIV_Y_VC_INTTERM: + sprintf(*buf, "P_DIV_Y_VC_INTTERM\n"); + break; + case P_DIV_Y_VC_NOINTTERM: + sprintf(*buf, "P_DIV_Y_VC_NOINTTERM\n"); + break; + case P_DIV_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_DIV_Y_VC_D0EQUALS0L\n"); + break; + case P_DIV_Y_VC_NVAR_END: + sprintf(*buf, "P_DIV_Y_VC_NVAR_END\n"); + break; + case P_DIV_Y_VC_DIV_Y_VC_UNK: + sprintf(*buf, "P_DIV_Y_VC_DIV_Y_VC_UNK\n"); + break; + case P_DIV_Y_CV_INSTINIT: + sprintf(*buf, "P_DIV_Y_CV_INSTINIT\n"); + break; + case P_DIV_Y_CV_DIV_Y_CV_NVAR: + sprintf(*buf, "P_DIV_Y_CV_DIV_Y_CV_NVAR\n"); + break; + case P_DIV_Y_CV_INTTERM_INIT: + sprintf(*buf, "P_DIV_Y_CV_INTTERM_INIT\n"); + break; + case P_DIV_Y_CV_INTTERM_DIVEQUALS0: + sprintf(*buf, "P_DIV_Y_CV_INTTERM_DIVEQUALS0\n"); + break; + case P_DIV_Y_CV_INTTERM_END: + sprintf(*buf, "P_DIV_Y_CV_INTTERM_END\n"); + break; + case P_DIV_Y_CV_NOINTTERM: + sprintf(*buf, "P_DIV_Y_CV_NOINTTERM\n"); + break; + case P_DIV_Y_CV_D0EQUALS0L: + sprintf(*buf, "P_DIV_Y_CV_D0EQUALS0L\n"); + break; + case P_DIV_Y_CV_NVAR_END: + sprintf(*buf, "P_DIV_Y_CV_NVAR_END\n"); + break; + case P_DIV_Y_CV_DIV_Y_CV_UNK: + sprintf(*buf, "P_DIV_Y_CV_DIV_Y_CV_UNK\n"); + break; + case P_AND_VV_INSTINIT: + sprintf(*buf, "P_AND_VV_INSTINIT\n"); + break; + case P_AND_VV_AND_VV_NVAR: + sprintf(*buf, "P_AND_VV_AND_VV_NVAR\n"); + break; + case P_AND_VV_AND_VV_NVAR_NVAR_INT: + sprintf(*buf, "P_AND_VV_AND_VV_NVAR_NVAR_INT\n"); + break; + case P_AND_VV_AND_VV_NVAR_NVAR_NOINT: + sprintf(*buf, "P_AND_VV_AND_VV_NVAR_NVAR_NOINT\n"); + break; + case P_AND_VV_AND_VV_UNK: + sprintf(*buf, "P_AND_VV_AND_VV_UNK\n"); + break; + case P_AND_VV_AND_VV_NVAR_UNK: + sprintf(*buf, "P_AND_VV_AND_VV_NVAR_UNK\n"); + break; + case P_AND_VC_INSTINIT: + sprintf(*buf, "P_AND_VC_INSTINIT\n"); + break; + case P_AND_VC_AND_VC_NVAR_INT: + sprintf(*buf, "P_AND_VC_AND_VC_NVAR_INT\n"); + break; + case P_AND_VC_AND_VC_NVAR_NOINT: + sprintf(*buf, "P_AND_VC_AND_VC_NVAR_NOINT\n"); + break; + case P_AND_VC_AND_VC_UNK: + sprintf(*buf, "P_AND_VC_AND_VC_UNK\n"); + break; + case P_AND_Y_VV_INSTINIT: + sprintf(*buf, "P_AND_Y_VV_INSTINIT\n"); + break; + case P_AND_Y_VV_AND_Y_VV_NVAR: + sprintf(*buf, "P_AND_Y_VV_AND_Y_VV_NVAR\n"); + break; + case P_AND_Y_VV_INTTERM: + sprintf(*buf, "P_AND_Y_VV_INTTERM\n"); + break; + case P_AND_Y_VV_NOINTTERM: + sprintf(*buf, "P_AND_Y_VV_NOINTTERM\n"); + break; + case P_AND_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_AND_Y_VV_D0EQUALS0L\n"); + break; + case P_AND_Y_VV_NVAR_END: + sprintf(*buf, "P_AND_Y_VV_NVAR_END\n"); + break; + case P_AND_Y_VV_AND_Y_VV_UNK: + sprintf(*buf, "P_AND_Y_VV_AND_Y_VV_UNK\n"); + break; + case P_AND_Y_VV_AND_Y_VV_NVAR_UNK: + sprintf(*buf, "P_AND_Y_VV_AND_Y_VV_NVAR_UNK\n"); + break; + case P_AND_Y_VC_INSTINIT: + sprintf(*buf, "P_AND_Y_VC_INSTINIT\n"); + break; + case P_AND_Y_VC_AND_Y_VC_NVAR: + sprintf(*buf, "P_AND_Y_VC_AND_Y_VC_NVAR\n"); + break; + case P_AND_Y_VC_INTTERM: + sprintf(*buf, "P_AND_Y_VC_INTTERM\n"); + break; + case P_AND_Y_VC_NOINTTERM: + sprintf(*buf, "P_AND_Y_VC_NOINTTERM\n"); + break; + case P_AND_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_AND_Y_VC_D0EQUALS0L\n"); + break; + case P_AND_Y_VC_NVAR_END: + sprintf(*buf, "P_AND_Y_VC_NVAR_END\n"); + break; + case P_AND_Y_VC_AND_Y_VC_UNK: + sprintf(*buf, "P_AND_Y_VC_AND_Y_VC_UNK\n"); + break; + case P_OR_VV_INSTINIT: + sprintf(*buf, "P_OR_VV_INSTINIT\n"); + break; + case P_OR_VV_OR_VV_NVAR: + sprintf(*buf, "P_OR_VV_OR_VV_NVAR\n"); + break; + case P_OR_VV_INTTERM: + sprintf(*buf, "P_OR_VV_INTTERM\n"); + break; + case P_OR_VV_NOINTTERM: + sprintf(*buf, "P_OR_VV_NOINTTERM\n"); + break; + case P_OR_VV_D0EQUALS0L: + sprintf(*buf, "P_OR_VV_D0EQUALS0L\n"); + break; + case P_OR_VV_NVAR_END: + sprintf(*buf, "P_OR_VV_NVAR_END\n"); + break; + case P_OR_VV_OR_VV_UNK: + sprintf(*buf, "P_OR_VV_OR_VV_UNK\n"); + break; + case P_OR_VV_OR_VV_NVAR_UNK: + sprintf(*buf, "P_OR_VV_OR_VV_NVAR_UNK\n"); + break; + case P_OR_VC_INSTINIT: + sprintf(*buf, "P_OR_VC_INSTINIT\n"); + break; + case P_OR_VC_OR_VC_NVAR: + sprintf(*buf, "P_OR_VC_OR_VC_NVAR\n"); + break; + case P_OR_VC_INTTERM: + sprintf(*buf, "P_OR_VC_INTTERM\n"); + break; + case P_OR_VC_NOINTTERM: + sprintf(*buf, "P_OR_VC_NOINTTERM\n"); + break; + case P_OR_VC_D0EQUALS0L: + sprintf(*buf, "P_OR_VC_D0EQUALS0L\n"); + break; + case P_OR_VC_NVAR_END: + sprintf(*buf, "P_OR_VC_NVAR_END\n"); + break; + case P_OR_VC_OR_VC_UNK: + sprintf(*buf, "P_OR_VC_OR_VC_UNK\n"); + break; + case P_OR_Y_VV_INSTINIT: + sprintf(*buf, "P_OR_Y_VV_INSTINIT\n"); + break; + case P_OR_Y_VV_OR_Y_VV_NVAR: + sprintf(*buf, "P_OR_Y_VV_OR_Y_VV_NVAR\n"); + break; + case P_OR_Y_VV_INTTERM: + sprintf(*buf, "P_OR_Y_VV_INTTERM\n"); + break; + case P_OR_Y_VV_NOINTTERM: + sprintf(*buf, "P_OR_Y_VV_NOINTTERM\n"); + break; + case P_OR_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_OR_Y_VV_D0EQUALS0L\n"); + break; + case P_OR_Y_VV_NVAR_END: + sprintf(*buf, "P_OR_Y_VV_NVAR_END\n"); + break; + case P_OR_Y_VV_OR_Y_VV_UNK: + sprintf(*buf, "P_OR_Y_VV_OR_Y_VV_UNK\n"); + break; + case P_OR_Y_VV_OR_Y_VV_NVAR_UNK: + sprintf(*buf, "P_OR_Y_VV_OR_Y_VV_NVAR_UNK\n"); + break; + case P_OR_Y_VC_INSTINIT: + sprintf(*buf, "P_OR_Y_VC_INSTINIT\n"); + break; + case P_OR_Y_VC_OR_Y_VC_NVAR: + sprintf(*buf, "P_OR_Y_VC_OR_Y_VC_NVAR\n"); + break; + case P_OR_Y_VC_INTTERM: + sprintf(*buf, "P_OR_Y_VC_INTTERM\n"); + break; + case P_OR_Y_VC_NOINTTERM: + sprintf(*buf, "P_OR_Y_VC_NOINTTERM\n"); + break; + case P_OR_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_OR_Y_VC_D0EQUALS0L\n"); + break; + case P_OR_Y_VC_NVAR_END: + sprintf(*buf, "P_OR_Y_VC_NVAR_END\n"); + break; + case P_OR_Y_VC_OR_Y_VC_UNK: + sprintf(*buf, "P_OR_Y_VC_OR_Y_VC_UNK\n"); + break; + case P_SLL_VV_INSTINIT: + sprintf(*buf, "P_SLL_VV_INSTINIT\n"); + break; + case P_SLL_VV_SLL_VV_NVAR: + sprintf(*buf, "P_SLL_VV_SLL_VV_NVAR\n"); + break; + case P_SLL_VV_INTTERM_INIT: + sprintf(*buf, "P_SLL_VV_INTTERM_INIT\n"); + break; + case P_SLL_VV_INTTERM_LESS: + sprintf(*buf, "P_SLL_VV_INTTERM_LESS\n"); + break; + case P_SLL_VV_INTTERM_GREATER: + sprintf(*buf, "P_SLL_VV_INTTERM_GREATER\n"); + break; + case P_SLL_VV_NOINTTERM: + sprintf(*buf, "P_SLL_VV_NOINTTERM\n"); + break; + case P_SLL_VV_D0EQUALS0L: + sprintf(*buf, "P_SLL_VV_D0EQUALS0L\n"); + break; + case P_SLL_VV_NVAR_END: + sprintf(*buf, "P_SLL_VV_NVAR_END\n"); + break; + case P_SLL_VV_SLL_VV_UNK: + sprintf(*buf, "P_SLL_VV_SLL_VV_UNK\n"); + break; + case P_SLL_VV_SLL_VV_NVAR_UNK: + sprintf(*buf, "P_SLL_VV_SLL_VV_NVAR_UNK\n"); + break; + case P_SLL_VC_INSTINIT: + sprintf(*buf, "P_SLL_VC_INSTINIT\n"); + break; + case P_SLL_VC_SLL_VC_NVAR: + sprintf(*buf, "P_SLL_VC_SLL_VC_NVAR\n"); + break; + case P_SLL_VC_INTTERM: + sprintf(*buf, "P_SLL_VC_INTTERM\n"); + break; + case P_SLL_VC_NOINTTERM: + sprintf(*buf, "P_SLL_VC_NOINTTERM\n"); + break; + case P_SLL_VC_D0EQUALS0L: + sprintf(*buf, "P_SLL_VC_D0EQUALS0L\n"); + break; + case P_SLL_VC_NVAR_END: + sprintf(*buf, "P_SLL_VC_NVAR_END\n"); + break; + case P_SLL_VC_SLL_VC_UNK: + sprintf(*buf, "P_SLL_VC_SLL_VC_UNK\n"); + break; + case P_SLL_CV_INSTINIT: + sprintf(*buf, "P_SLL_CV_INSTINIT\n"); + break; + case P_SLL_CV_SLL_CV_NVAR_INT: + sprintf(*buf, "P_SLL_CV_SLL_CV_NVAR_INT\n"); + break; + case P_SLL_CV_SLL_CV_NVAR_NOINT: + sprintf(*buf, "P_SLL_CV_SLL_CV_NVAR_NOINT\n"); + break; + case P_SLL_CV_SLL_CV_UNK: + sprintf(*buf, "P_SLL_CV_SLL_CV_UNK\n"); + break; + case P_SLL_Y_VV_INSTINIT: + sprintf(*buf, "P_SLL_Y_VV_INSTINIT\n"); + break; + case P_SLL_Y_VV_SLL_Y_VV_NVAR: + sprintf(*buf, "P_SLL_Y_VV_SLL_Y_VV_NVAR\n"); + break; + case P_SLL_Y_VV_INTTERM_INIT: + sprintf(*buf, "P_SLL_Y_VV_INTTERM_INIT\n"); + break; + case P_SLL_Y_VV_INTERM_LESS: + sprintf(*buf, "P_SLL_Y_VV_INTERM_LESS\n"); + break; + case P_SLL_Y_VV_INTTERM_GREATER: + sprintf(*buf, "P_SLL_Y_VV_INTTERM_GREATER\n"); + break; + case P_SLL_Y_VV_NOINTTERM: + sprintf(*buf, "P_SLL_Y_VV_NOINTTERM\n"); + break; + case P_SLL_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_SLL_Y_VV_D0EQUALS0L\n"); + break; + case P_SLL_Y_VV_NVAR_END: + sprintf(*buf, "P_SLL_Y_VV_NVAR_END\n"); + break; + case P_SLL_Y_VV_SLL_Y_VV_UNK: + sprintf(*buf, "P_SLL_Y_VV_SLL_Y_VV_UNK\n"); + break; + case P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK: + sprintf(*buf, "P_SLL_Y_VV_SLL_Y_VV_NVAR_UNK\n"); + break; + case P_SLL_Y_VC_INSTINIT: + sprintf(*buf, "P_SLL_Y_VC_INSTINIT\n"); + break; + case P_SLL_Y_VC_SLL_Y_VC_NVAR: + sprintf(*buf, "P_SLL_Y_VC_SLL_Y_VC_NVAR\n"); + break; + case P_SLL_Y_VC_INTTERM: + sprintf(*buf, "P_SLL_Y_VC_INTTERM\n"); + break; + case P_SLL_Y_VC_NOINTTERM: + sprintf(*buf, "P_SLL_Y_VC_NOINTTERM\n"); + break; + case P_SLL_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_SLL_Y_VC_D0EQUALS0L\n"); + break; + case P_SLL_Y_VC_NVAR_END: + sprintf(*buf, "P_SLL_Y_VC_NVAR_END\n"); + break; + case P_SLL_Y_VC_SLL_Y_VC_UNK: + sprintf(*buf, "P_SLL_Y_VC_SLL_Y_VC_UNK\n"); + break; + case P_SLL_Y_CV_INSTINIT: + sprintf(*buf, "P_SLL_Y_CV_INSTINIT\n"); + break; + case P_SLL_Y_CV_SLL_Y_CV_NVAR: + sprintf(*buf, "P_SLL_Y_CV_SLL_Y_CV_NVAR\n"); + break; + case P_SLL_Y_CV_INTTERM_INIT: + sprintf(*buf, "P_SLL_Y_CV_INTTERM_INIT\n"); + break; + case P_SLL_Y_CV_INTTERM_LESS: + sprintf(*buf, "P_SLL_Y_CV_INTTERM_LESS\n"); + break; + case P_SLL_Y_CV_INTTERM_GREATER: + sprintf(*buf, "P_SLL_Y_CV_INTTERM_GREATER\n"); + break; + case P_SLL_Y_CV_NOINTTERM: + sprintf(*buf, "P_SLL_Y_CV_NOINTTERM\n"); + break; + case P_SLL_Y_CV_D0EQUALS0L: + sprintf(*buf, "P_SLL_Y_CV_D0EQUALS0L\n"); + break; + case P_SLL_Y_CV_NVAR_END: + sprintf(*buf, "P_SLL_Y_CV_NVAR_END\n"); + break; + case P_SLL_Y_CV_SLL_Y_CV_UNK: + sprintf(*buf, "P_SLL_Y_CV_SLL_Y_CV_UNK\n"); + break; + case P_SLR_VV_INSTINIT: + sprintf(*buf, "P_SLR_VV_INSTINIT\n"); + break; + case P_SLR_VV_SLR_VV_NVAR: + sprintf(*buf, "P_SLR_VV_SLR_VV_NVAR\n"); + break; + case P_SLR_VV_INTTERM_INIT: + sprintf(*buf, "P_SLR_VV_INTTERM_INIT\n"); + break; + case P_SLR_VV_INTTERM_LESS: + sprintf(*buf, "P_SLR_VV_INTTERM_LESS\n"); + break; + case P_SLR_VV_INTTERM_GREATER: + sprintf(*buf, "P_SLR_VV_INTTERM_GREATER\n"); + break; + case P_SLR_VV_NOINTTERM: + sprintf(*buf, "P_SLR_VV_NOINTTERM\n"); + break; + case P_SLR_VV_D0EQUALS0L: + sprintf(*buf, "P_SLR_VV_D0EQUALS0L\n"); + break; + case P_SLR_VV_NVAR_END: + sprintf(*buf, "P_SLR_VV_NVAR_END\n"); + break; + case P_SLR_VV_SRL_VV_UNK: + sprintf(*buf, "P_SLR_VV_SRL_VV_UNK\n"); + break; + case P_SLR_VV_SRL_VV_NVAR_UNK: + sprintf(*buf, "P_SLR_VV_SRL_VV_NVAR_UNK\n"); + break; + case P_SLR_VC_INSTINIT: + sprintf(*buf, "P_SLR_VC_INSTINIT\n"); + break; + case P_SLR_VC_SLR_VC_NVAR_INT: + sprintf(*buf, "P_SLR_VC_SLR_VC_NVAR_INT\n"); + break; + case P_SLR_VC_SLR_VC_NVAR_NOINT: + sprintf(*buf, "P_SLR_VC_SLR_VC_NVAR_NOINT\n"); + break; + case P_SLR_VC_SRL_VC_UNK: + sprintf(*buf, "P_SLR_VC_SRL_VC_UNK\n"); + break; + case P_SLR_CV_INSTINIT: + sprintf(*buf, "P_SLR_CV_INSTINIT\n"); + break; + case P_SLR_CV_SLR_CV_NVAR: + sprintf(*buf, "P_SLR_CV_SLR_CV_NVAR\n"); + break; + case P_SLR_CV_INTTERM_INIT: + sprintf(*buf, "P_SLR_CV_INTTERM_INIT\n"); + break; + case P_SLR_CV_INTTERM_LESS: + sprintf(*buf, "P_SLR_CV_INTTERM_LESS\n"); + break; + case P_SLR_CV_INTTERM_GREATER: + sprintf(*buf, "P_SLR_CV_INTTERM_GREATER\n"); + break; + case P_SLR_CV_NOINTTERM: + sprintf(*buf, "P_SLR_CV_NOINTTERM\n"); + break; + case P_SLR_CV_D0EQUALS0L: + sprintf(*buf, "P_SLR_CV_D0EQUALS0L\n"); + break; + case P_SLR_CV_NVAR_END: + sprintf(*buf, "P_SLR_CV_NVAR_END\n"); + break; + case P_SLR_CV_SLR_CV_UNK: + sprintf(*buf, "P_SLR_CV_SLR_CV_UNK\n"); + break; + case P_SLR_Y_VV_INSTINIT: + sprintf(*buf, "P_SLR_Y_VV_INSTINIT\n"); + break; + case P_SLR_Y_VV_SLR_Y_VV_NVAR: + sprintf(*buf, "P_SLR_Y_VV_SLR_Y_VV_NVAR\n"); + break; + case P_SLR_Y_VV_INTTERM_INIT: + sprintf(*buf, "P_SLR_Y_VV_INTTERM_INIT\n"); + break; + case P_SLR_Y_VV_INTTERM_LESS: + sprintf(*buf, "P_SLR_Y_VV_INTTERM_LESS\n"); + break; + case P_SLR_Y_VV_INTTERM_GREATER: + sprintf(*buf, "P_SLR_Y_VV_INTTERM_GREATER\n"); + break; + case P_SLR_Y_VV_NOINTTERM: + sprintf(*buf, "P_SLR_Y_VV_NOINTTERM\n"); + break; + case P_SLR_Y_VV_D0EQUALS0L: + sprintf(*buf, "P_SLR_Y_VV_D0EQUALS0L\n"); + break; + case P_SLR_Y_VV_NVAR_END: + sprintf(*buf, "P_SLR_Y_VV_NVAR_END\n"); + break; + case P_SLR_Y_VV_SLR_Y_VV_UNK: + sprintf(*buf, "P_SLR_Y_VV_SLR_Y_VV_UNK\n"); + break; + case P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK: + sprintf(*buf, "P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK\n"); + break; + case P_SLR_Y_VC_INSTINIT: + sprintf(*buf, "P_SLR_Y_VC_INSTINIT\n"); + break; + case P_SLR_Y_VC_SLR_Y_VC_NVAR: + sprintf(*buf, "P_SLR_Y_VC_SLR_Y_VC_NVAR\n"); + break; + case P_SLR_Y_VC_INTTERM: + sprintf(*buf, "P_SLR_Y_VC_INTTERM\n"); + break; + case P_SLR_Y_VC_NOINTTERM: + sprintf(*buf, "P_SLR_Y_VC_NOINTTERM\n"); + break; + case P_SLR_Y_VC_D0EQUALS0L: + sprintf(*buf, "P_SLR_Y_VC_D0EQUALS0L\n"); + break; + case P_SLR_Y_VC_NVAR_END: + sprintf(*buf, "P_SLR_Y_VC_NVAR_END\n"); + break; + case P_SLR_Y_VC_SLR_Y_VC_UNK: + sprintf(*buf, "P_SLR_Y_VC_SLR_Y_VC_UNK\n"); + break; + case P_SLR_Y_CV_INSTINIT: + sprintf(*buf, "P_SLR_Y_CV_INSTINIT\n"); + break; + case P_SLR_Y_CV_SLR_Y_CV_NVAR: + sprintf(*buf, "P_SLR_Y_CV_SLR_Y_CV_NVAR\n"); + break; + case P_SLR_Y_CV_INTTERM_INIT: + sprintf(*buf, "P_SLR_Y_CV_INTTERM_INIT\n"); + break; + case P_SLR_Y_CV_INTTERM_LESS: + sprintf(*buf, "P_SLR_Y_CV_INTTERM_LESS\n"); + break; + case P_SLR_Y_CV_INTTERM_GREATER: + sprintf(*buf, "P_SLR_Y_CV_INTTERM_GREATER\n"); + break; + case P_SLR_Y_CV_NOINTTERM: + sprintf(*buf, "P_SLR_Y_CV_NOINTTERM\n"); + break; + case P_SLR_Y_CV_D0EQUALS0L: + sprintf(*buf, "P_SLR_Y_CV_D0EQUALS0L\n"); + break; + case P_SLR_Y_CV_NVAR_END: + sprintf(*buf, "P_SLR_Y_CV_NVAR_END\n"); + break; + case P_SLR_Y_CV_SLR_Y_CV_UNK: + sprintf(*buf, "P_SLR_Y_CV_SLR_Y_CV_UNK\n"); + break; + case CALL_BFUNC_XX_INSTINIT: + sprintf(*buf, "CALL_BFUNC_XX_INSTINIT\n"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR: + sprintf(*buf, "CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR\n"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT: + sprintf(*buf, "CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT\n"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT: + sprintf(*buf, "CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT\n"); + break; + case CALL_BFUNC_XX_CALL_BFUNC_XX_UNK: + sprintf(*buf, "CALL_BFUNC_XX_CALL_BFUNC_XX_UNK\n"); + break; + case CALL_BFUNC_YX_INSTINIT: + sprintf(*buf, "CALL_BFUNC_YX_INSTINIT\n"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT: + sprintf(*buf, "CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT\n"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT: + sprintf(*buf, "CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT\n"); + break; + case CALL_BFUNC_YX_CALL_BFUNC_YX_UNK: + sprintf(*buf, "CALL_BFUNC_YX_CALL_BFUNC_YX_UNK\n"); + break; + case CALL_BFUNC_XY_INSTINIT: + sprintf(*buf, "CALL_BFUNC_XY_INSTINIT\n"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT: + sprintf(*buf, "CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT\n"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT: + sprintf(*buf, "CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT\n"); + break; + case CALL_BFUNC_XY_CALL_BFUNC_XY_UNK: + sprintf(*buf, "CALL_BFUNC_XY_CALL_BFUNC_XY_UNK\n"); + break; + case CALL_BFUNC_YY_INSTINIT: + sprintf(*buf, "CALL_BFUNC_YY_INSTINIT\n"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT: + sprintf(*buf, "CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT\n"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT: + sprintf(*buf, "CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT\n"); + break; + case CALL_BFUNC_YY_CALL_BFUNC_YY_UNK: + sprintf(*buf, "CALL_BFUNC_YY_CALL_BFUNC_YY_UNK\n"); + break; + case P_EQUAL_INSTINIT: + sprintf(*buf, "P_EQUAL_INSTINIT\n"); + break; + case P_EQUAL_END: + sprintf(*buf, "P_EQUAL_END\n"); + break; + case P_DIF_INSTINIT: + sprintf(*buf, "P_DIF_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_DIF_LOW_LEVEL_TRACER: + sprintf(*buf, "P_DIF_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_DIF_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "P_DIF_POST_LOW_LEVEL_TRACER\n"); + break; + case P_DIF_DIF_NVAR1: + sprintf(*buf, "P_DIF_DIF_NVAR1\n"); + break; + case P_DIF_DIF_NVAR1_NVAR2: + sprintf(*buf, "P_DIF_DIF_NVAR1_NVAR2\n"); + break; + break; + case P_DIF_DIF_UNK1: + sprintf(*buf, "P_DIF_DIF_UNK1\n"); + break; + case P_DIF_DIF_NVAR1_UNK2: + sprintf(*buf, "P_DIF_DIF_NVAR1_UNK2\n"); + break; + case P_EQ_INSTINIT: + sprintf(*buf, "P_EQ_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_EQ_LOW_LEVEL_TRACER: + sprintf(*buf, "P_EQ_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_EQ_POST_LOW_LEVEL_TRACER: + sprintf(*buf, "P_EQ_POST_LOW_LEVEL_TRACER\n"); + break; + case P_EQ_P_EQ_NVAR1: + sprintf(*buf, "P_EQ_P_EQ_NVAR1\n"); + break; + case P_EQ_P_EQ_NVAR1_NVAR2: + sprintf(*buf, "P_EQ_P_EQ_NVAR1_NVAR2\n"); + break; + case P_EQ_P_EQ_NVAR1_UNK2: + sprintf(*buf, "P_EQ_P_EQ_NVAR1_UNK2\n"); + break; + case P_EQ_P_EQ_UNK1: + sprintf(*buf, "P_EQ_P_EQ_UNK1\n"); + break; + case P_EQ_P_EQ_VAR1_NVAR2: + sprintf(*buf, "P_EQ_P_EQ_VAR1_NVAR2\n"); + break; + case P_EQ_P_EQ_VAR1_UNK2_END: + sprintf(*buf, "P_EQ_P_EQ_VAR1_UNK2_END\n"); + break; + case P_ARG_VV_INSTINIT: + sprintf(*buf, "P_ARG_VV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_VV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_ARG_VV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_ARG_VV_TEST_D0: + sprintf(*buf, "P_ARG_VV_TEST_D0\n"); + break; + case P_ARG_VV_ARG_ARG1_NVAR: + sprintf(*buf, "P_ARG_VV_ARG_ARG1_NVAR\n"); + break; + case P_ARG_VV_TEST_D1: + sprintf(*buf, "P_ARG_VV_TEST_D1\n"); + break; + case P_ARG_VV_ARG_ARG2_NVAR: + sprintf(*buf, "P_ARG_VV_ARG_ARG2_NVAR\n"); + break; + case P_ARG_VV_ARG_ARG2_UNK: + sprintf(*buf, "P_ARG_VV_ARG_ARG2_UNK\n"); + break; + case P_ARG_VV_ARG_ARG1_UNK: + sprintf(*buf, "P_ARG_VV_ARG_ARG1_UNK\n"); + break; + case P_ARG_CV_INSTINIT: + sprintf(*buf, "P_ARG_CV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_CV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_ARG_CV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_ARG_CV_TEST_D1: + sprintf(*buf, "P_ARG_CV_TEST_D1\n"); + break; + case P_ARG_CV_ARG_ARG2_VC_NVAR: + sprintf(*buf, "P_ARG_CV_ARG_ARG2_VC_NVAR\n"); + break; + case P_ARG_CV_ARG_ARG2_VC_UNK: + sprintf(*buf, "P_ARG_CV_ARG_ARG2_VC_UNK\n"); + break; + case P_ARG_Y_VV_INSTINIT: + sprintf(*buf, "P_ARG_Y_VV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_Y_VV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_ARG_Y_VV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_ARG_Y_VV_TEST_D0: + sprintf(*buf, "P_ARG_Y_VV_TEST_D0\n"); + break; + case P_ARG_Y_VV_ARG_Y_ARG1_NVAR: + sprintf(*buf, "P_ARG_Y_VV_ARG_Y_ARG1_NVAR\n"); + break; + case P_ARG_Y_VV_TEST_D1: + sprintf(*buf, "P_ARG_Y_VV_TEST_D1\n"); + break; + case P_ARG_Y_VV_ARG_Y_ARG2_NVAR: + sprintf(*buf, "P_ARG_Y_VV_ARG_Y_ARG2_NVAR\n"); + break; + case P_ARG_Y_VV_ARG_Y_ARG2_UNK: + sprintf(*buf, "P_ARG_Y_VV_ARG_Y_ARG2_UNK\n"); + break; + case P_ARG_Y_VV_ARG_Y_ARG1_UNK: + sprintf(*buf, "P_ARG_Y_VV_ARG_Y_ARG1_UNK\n"); + break; + case P_ARG_Y_CV_INSTINIT: + sprintf(*buf, "P_ARG_Y_CV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_ARG_Y_CV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_ARG_Y_CV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_ARG_Y_CV_TEST_D1: + sprintf(*buf, "P_ARG_Y_CV_TEST_D1\n"); + break; + case P_ARG_Y_CV_D1APPL_INIT: + sprintf(*buf, "P_ARG_Y_CV_D1APPL_INIT\n"); + break; + case P_ARG_Y_CV_D1APPL_END: + sprintf(*buf, "P_ARG_Y_CV_D1APPL_END\n"); + break; + case P_ARG_Y_CV_D1PAIR_INIT: + sprintf(*buf, "P_ARG_Y_CV_D1PAIR_INIT\n"); + break; + case P_ARG_Y_CV_D1PAIR_LESS0: + sprintf(*buf, "P_ARG_Y_CV_D1PAIR_LESS0\n"); + break; + case P_ARG_Y_CV_D1PAIR_END: + sprintf(*buf, "P_ARG_Y_CV_D1PAIR_END\n"); + break; + case P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK: + sprintf(*buf, "P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK\n"); + break; + case P_FUNCTOR_INSTINIT: + sprintf(*buf, "P_FUNCTOR_INSTINIT\n"); + break; + case P_FUNCTOR_END: + sprintf(*buf, "P_FUNCTOR_END\n"); + break; + case P_FUNC2S_VV_INSTINIT: + sprintf(*buf, "P_FUNC2S_VV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_VV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_VV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_TEST_D0: + sprintf(*buf, "P_FUNC2S_TEST_D0\n"); + break; + case P_FUNC2S_VV_TEST_D1: + sprintf(*buf, "P_FUNC2S_VV_TEST_D1\n"); + break; + case P_FUNC2S_VV_D1INT: + sprintf(*buf, "P_FUNC2S_VV_D1INT\n"); + break; + case P_FUNC2S_VV_D1NOTINT: + sprintf(*buf, "P_FUNC2S_VV_D1NOTINT\n"); + break; + case P_FUNC2S_VV_D1BIGINT: + sprintf(*buf, "P_FUNC2S_VV_D1BIGINT\n"); + break; + case P_FUNC2S_VV_D1NOTBIGINT: + sprintf(*buf, "P_FUNC2S_VV_D1NOTBIGINT\n"); + break; + case P_FUNC2S_VV_D1NOTINT_END: + sprintf(*buf, "P_FUNC2S_VV_D1NOTINT_END\n"); + break; + case P_FUNC2S_VV_D0NOTATOMIC: + sprintf(*buf, "P_FUNC2S_VV_D0NOTATOMIC\n"); + break; + case P_FUNC2S_VV_FIRSTIFOK: + sprintf(*buf, "P_FUNC2S_VV_FIRSTIFOK\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_D0NOTATOM: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_D0NOTATOM\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_D0ATOM: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_D0ATOM\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE\n"); + break; + case P_FUNC2S_VV_SECONDIFOK_END: + sprintf(*buf, "P_FUNC2S_VV_SECONDIFOK_END\n"); + break; + case P_FUNC2S_VV_THIRDIFOK: + sprintf(*buf, "P_FUNC2S_VV_THIRDIFOK\n"); + break; + case P_FUNC2S_VV_ELSE: + sprintf(*buf, "P_FUNC2S_VV_ELSE\n"); + break; + case P_FUNC2S_VV_FUNC2S_UNK2: + sprintf(*buf, "P_FUNC2S_VV_FUNC2S_UNK2\n"); + break; + case P_FUNC2S_VV_FUNC2S_UNK: + sprintf(*buf, "P_FUNC2S_VV_FUNC2S_UNK\n"); + break; + case P_FUNC2S_CV_INSTINIT: + sprintf(*buf, "P_FUNC2S_CV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_CV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_CV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_CV_TEST_D1: + sprintf(*buf, "P_FUNC2S_CV_TEST_D1\n"); + break; + case P_FUNC2S_CV_D1INT: + sprintf(*buf, "P_FUNC2S_CV_D1INT\n"); + break; + case P_FUNC2S_CV_D1NOTINT: + sprintf(*buf, "P_FUNC2S_CV_D1NOTINT\n"); + break; + case P_FUNC2S_CV_D1NOINT_D1BIGINT: + sprintf(*buf, "P_FUNC2S_CV_D1NOINT_D1BIGINT\n"); + break; + case P_FUNC2S_CV_D1NOTBIGINT: + sprintf(*buf, "P_FUNC2S_CV_D1NOTBIGINT\n"); + break; + case P_FUNC2S_CV_POST_IF: + sprintf(*buf, "P_FUNC2S_CV_POST_IF\n"); + break; + case P_FUNC2S_CV_FIRSTIFOK: + sprintf(*buf, "P_FUNC2S_CV_FIRSTIFOK\n"); + break; + case P_FUNC2S_CV_D1GREATER_D0NOTATOM: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_D0NOTATOM\n"); + break; + case P_FUNC2S_CV_D1GREATER_D0ATOM: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_D0ATOM\n"); + break; + case P_FUNC2S_CV_D1GREATER_POST_IF: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_POST_IF\n"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_IFOK_INIT\n"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_IFOK_IFOK\n"); + break; + case P_FUNC2S_CV_D1GREATER_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_IFOK_NOIF\n"); + break; + case P_FUNC2S_CV_D1GREATER_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_INSIDEWHILE\n"); + break; + case P_FUNC2S_CV_D1GREATER_END: + sprintf(*buf, "P_FUNC2S_CV_D1GREATER_END\n"); + break; + case P_FUNC2S_CV_D1ISZERO: + sprintf(*buf, "P_FUNC2S_CV_D1ISZERO\n"); + break; + case P_FUNC2S_CV_ELSE: + sprintf(*buf, "P_FUNC2S_CV_ELSE\n"); + break; + case P_FUNC2S_CV_END: + sprintf(*buf, "P_FUNC2S_CV_END\n"); + break; + case P_FUNC2S_VC_INSTINIT: + sprintf(*buf, "P_FUNC2S_VC_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_VC_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_VC_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_VC_TEST_D0: + sprintf(*buf, "P_FUNC2S_VC_TEST_D0\n"); + break; + case P_FUNC2S_VC_FUNC2S_NVAR_VC: + sprintf(*buf, "P_FUNC2S_VC_FUNC2S_NVAR_VC\n"); + break; + case P_FUNC2S_VC_D0NOATOMIC: + sprintf(*buf, "P_FUNC2S_VC_D0NOATOMIC\n"); + break; + case P_FUNC2S_VC_EQUALS: + sprintf(*buf, "P_FUNC2S_VC_EQUALS\n"); + break; + case P_FUNC2S_VC_D1ISZERO: + sprintf(*buf, "P_FUNC2S_VC_D1ISZERO\n"); + break; + case P_FUNC2S_VC_D0NOATOM: + sprintf(*buf, "P_FUNC2S_VC_D0NOATOM\n"); + break; + case P_FUNC2S_VC_D0ATOM: + sprintf(*buf, "P_FUNC2S_VC_D0ATOM\n"); + break; + case P_FUNC2S_VC_POST_ELSE: + sprintf(*buf, "P_FUNC2S_VC_POST_ELSE\n"); + break; + case P_FUNC2S_VC_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_VC_IFOK_INIT\n"); + break; + case P_FUNC2S_VC_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_VC_IFOK_IFOK\n"); + break; + case P_FUNC2S_VC_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_VC_IFOK_NOIF\n"); + break; + case P_FUNC2S_VC_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_VC_INSIDEWHILE\n"); + break; + case P_FUNC2S_VC_END1: + sprintf(*buf, "P_FUNC2S_VC_END1\n"); + break; + case P_FUNC2S_VC_END2: + sprintf(*buf, "P_FUNC2S_VC_END2\n"); + break; + case P_FUNC2S_Y_VV_INSTINIT: + sprintf(*buf, "P_FUNC2S_Y_VV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_VV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_Y_VV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_Y_VV_TEST_D0: + sprintf(*buf, "P_FUNC2S_Y_VV_TEST_D0\n"); + break; + case P_FUNC2S_Y_VV_TEST_D1: + sprintf(*buf, "P_FUNC2S_Y_VV_TEST_D1\n"); + break; + case P_FUNC2S_Y_VV_D1INT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1INT\n"); + break; + case P_FUNC2S_Y_VV_D1NOTINT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1NOTINT\n"); + break; + case P_FUNC2S_Y_VV_D1BIGINT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1BIGINT\n"); + break; + case P_FUNC2S_Y_VV_D1NOTBIGINT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1NOTBIGINT\n"); + break; + case P_FUNC2S_Y_VV_POST_IF: + sprintf(*buf, "P_FUNC2S_Y_VV_POST_IF\n"); + break; + case P_FUNC2S_Y_VV_D0NOATOMIC: + sprintf(*buf, "P_FUNC2S_Y_VV_D0NOATOMIC\n"); + break; + case P_FUNC2S_Y_VV_EQUALS: + sprintf(*buf, "P_FUNC2S_Y_VV_EQUALS\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_D0NOATOM: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_D0NOATOM\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_D0ATOM: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_D0ATOM\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_POST_ELSE: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_POST_ELSE\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE\n"); + break; + case P_FUNC2S_Y_VV_D1GREATER_END: + sprintf(*buf, "P_FUNC2S_Y_VV_D1GREATER_END\n"); + break; + case P_FUNC2S_Y_VV_D1ISZERO: + sprintf(*buf, "P_FUNC2S_Y_VV_D1ISZERO\n"); + break; + case P_FUNC2S_Y_VV_ELSE: + sprintf(*buf, "P_FUNC2S_Y_VV_ELSE\n"); + break; + case P_FUNC2S_Y_VV_END1: + sprintf(*buf, "P_FUNC2S_Y_VV_END1\n"); + break; + case P_FUNC2S_Y_VV_END2: + sprintf(*buf, "P_FUNC2S_Y_VV_END2\n"); + break; + case P_FUNC2S_Y_CV_INSTINIT: + sprintf(*buf, "P_FUNC2S_Y_CV_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_CV_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_Y_CV_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_Y_CV_TEST_D1: + sprintf(*buf, "P_FUNC2S_Y_CV_TEST_D1\n"); + break; + case P_FUNC2S_Y_CV_D1INT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1INT\n"); + break; + case P_FUNC2S_Y_CV_D1NOTINT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1NOTINT\n"); + break; + case P_FUNC2S_Y_CV_D1BIGINT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1BIGINT\n"); + break; + case P_FUNC2S_Y_CV_D1NOTBIGINT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1NOTBIGINT\n"); + break; + case P_FUNC2S_Y_CV_POST_IF: + sprintf(*buf, "P_FUNC2S_Y_CV_POST_IF\n"); + break; + case P_FUNC2S_Y_CV_EQUALS: + sprintf(*buf, "P_FUNC2S_Y_CV_EQUALS\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_D0NOATOM: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_D0NOATOM\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_D0ATOM: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_D0ATOM\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_POST_ELSE: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_POST_ELSE\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE\n"); + break; + case P_FUNC2S_Y_CV_D1GREATER_END: + sprintf(*buf, "P_FUNC2S_Y_CV_D1GREATER_END\n"); + break; + case P_FUNC2S_Y_CV_D1ISZERO: + sprintf(*buf, "P_FUNC2S_Y_CV_D1ISZERO\n"); + break; + case P_FUNC2S_Y_CV_ELSE: + sprintf(*buf, "P_FUNC2S_Y_CV_ELSE\n"); + break; + case P_FUNC2S_Y_CV_END: + sprintf(*buf, "P_FUNC2S_Y_CV_END\n"); + break; + case P_FUNC2S_Y_VC_INSTINIT: + sprintf(*buf, "P_FUNC2S_Y_VC_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2S_Y_VC_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2S_Y_VC_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2S_Y_VC_TEST_D0: + sprintf(*buf, "P_FUNC2S_Y_VC_TEST_D0\n"); + break; + case P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC: + sprintf(*buf, "P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC\n"); + break; + case P_FUNC2S_Y_VC_D0NOATOMIC: + sprintf(*buf, "P_FUNC2S_Y_VC_D0NOATOMIC\n"); + break; + case P_FUNC2S_Y_VC_EQUALS: + sprintf(*buf, "P_FUNC2S_Y_VC_EQUALS\n"); + break; + case P_FUNC2S_Y_VC_D1ISZERO: + sprintf(*buf, "P_FUNC2S_Y_VC_D1ISZERO\n"); + break; + case P_FUNC2S_Y_VC_D0NOATOM1: + sprintf(*buf, "P_FUNC2S_Y_VC_D0NOATOM1\n"); + break; + case P_FUNC2S_Y_VC_D0NOATOM2: + sprintf(*buf, "P_FUNC2S_Y_VC_D0NOATOM2\n"); + break; + case P_FUNC2S_Y_VC_D0ATOM: + sprintf(*buf, "P_FUNC2S_Y_VC_D0ATOM\n"); + break; + case P_FUNC2S_Y_VC_POST_ELSE: + sprintf(*buf, "P_FUNC2S_Y_VC_POST_ELSE\n"); + break; + case P_FUNC2S_Y_VC_IFOK_INIT: + sprintf(*buf, "P_FUNC2S_Y_VC_IFOK_INIT\n"); + break; + case P_FUNC2S_Y_VC_IFOK_IFOK: + sprintf(*buf, "P_FUNC2S_Y_VC_IFOK_IFOK\n"); + break; + case P_FUNC2S_Y_VC_IFOK_NOIF: + sprintf(*buf, "P_FUNC2S_Y_VC_IFOK_NOIF\n"); + break; + case P_FUNC2S_Y_VC_INSIDEWHILE: + sprintf(*buf, "P_FUNC2S_Y_VC_INSIDEWHILE\n"); + break; + case P_FUNC2S_Y_VC_END1: + sprintf(*buf, "P_FUNC2S_Y_VC_END1\n"); + break; + case P_FUNC2S_Y_VC_END2: + sprintf(*buf, "P_FUNC2S_Y_VC_END2\n"); + break; + case P_FUNC2F_XX_INSTINIT: + sprintf(*buf, "P_FUNC2F_XX_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_XX_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2F_XX_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2F_XX_TEST_D0: + sprintf(*buf, "P_FUNC2F_XX_TEST_D0\n"); + break; + case P_FUNC2F_XX_D0APPL: + sprintf(*buf, "P_FUNC2F_XX_D0APPL\n"); + break; + case P_FUNC2F_XX_D0APPL_D1EXTFUNC: + sprintf(*buf, "P_FUNC2F_XX_D0APPL_D1EXTFUNC\n"); + break; + case P_FUNC2F_XX_D0APPL_END: + sprintf(*buf, "P_FUNC2F_XX_D0APPL_END\n"); + break; + case P_FUNC2F_XX_D0PAIR: + sprintf(*buf, "P_FUNC2F_XX_D0PAIR\n"); + break; + case P_FUNC2F_XX_D0NOCOMPOUND: + sprintf(*buf, "P_FUNC2F_XX_D0NOCOMPOUND\n"); + break; + case P_FUNC2F_XX_END: + sprintf(*buf, "P_FUNC2F_XX_END\n"); + break; + case P_FUNC2F_XY_INSTINIT: + sprintf(*buf, "P_FUNC2F_XY_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_XY_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2F_XY_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2F_XY_TEST_D0: + sprintf(*buf, "P_FUNC2F_XY_TEST_D0\n"); + break; + case P_FUNC2F_XY_D0APPL: + sprintf(*buf, "P_FUNC2F_XY_D0APPL\n"); + break; + case P_FUNC2F_XY_D0APPL_D1EXTFUNC: + sprintf(*buf, "P_FUNC2F_XY_D0APPL_D1EXTFUNC\n"); + break; + case P_FUNC2F_XY_D0APPL_END: + sprintf(*buf, "P_FUNC2F_XY_D0APPL_END\n"); + break; + case P_FUNC2F_XY_D0PAIR: + sprintf(*buf, "P_FUNC2F_XY_D0PAIR\n"); + break; + case P_FUNC2F_XY_D0NOCOMPOUND: + sprintf(*buf, "P_FUNC2F_XY_D0NOCOMPOUND\n"); + break; + case P_FUNC2F_XY_END: + sprintf(*buf, "P_FUNC2F_XY_END\n"); + break; + case P_FUNC2F_YX_INSTINIT: + sprintf(*buf, "P_FUNC2F_YX_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_YX_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2F_YX_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2F_YX_TEST_D0: + sprintf(*buf, "P_FUNC2F_YX_TEST_D0\n"); + break; + case P_FUNC2F_YX_D0APPL: + sprintf(*buf, "P_FUNC2F_YX_D0APPL\n"); + break; + case P_FUNC2F_YX_D0APPL_D1EXTFUNC: + sprintf(*buf, "P_FUNC2F_YX_D0APPL_D1EXTFUNC\n"); + break; + case P_FUNC2F_YX_D0APPL_END: + sprintf(*buf, "P_FUNC2F_YX_D0APPL_END\n"); + break; + case P_FUNC2F_YX_D0PAIR: + sprintf(*buf, "P_FUNC2F_YX_D0PAIR\n"); + break; + case P_FUNC2F_YX_D0NOCOMPOUND: + sprintf(*buf, "P_FUNC2F_YX_D0NOCOMPOUND\n"); + break; + case P_FUNC2F_YX_END: + sprintf(*buf, "P_FUNC2F_YX_END\n"); + break; + case P_FUNC2F_YY_INSTINIT: + sprintf(*buf, "P_FUNC2F_YY_INSTINIT\n"); + break; +#ifdef LOW_LEVEL_TRACER + case P_FUNC2F_YY_LOW_LEVEL_TRACER: + sprintf(*buf, "P_FUNC2F_YY_LOW_LEVEL_TRACER\n"); + break; +#endif + case P_FUNC2F_YY_TEST_D0: + sprintf(*buf, "P_FUNC2F_YY_TEST_D0\n"); + break; + case P_FUNC2F_YY_D0APPL: + sprintf(*buf, "P_FUNC2F_YY_D0APPL\n"); + break; + case P_FUNC2F_YY_D0APPL_D1EXTFUNC: + sprintf(*buf, "P_FUNC2F_YY_D0APPL_D1EXTFUNC\n"); + break; + case P_FUNC2F_YY_D0APPL_END: + sprintf(*buf, "P_FUNC2F_YY_D0APPL_END\n"); + break; + case P_FUNC2F_YY_D0PAIR: + sprintf(*buf, "P_FUNC2F_YY_D0PAIR\n"); + break; + case P_FUNC2F_YY_D0NOCOMPOUND: + sprintf(*buf, "P_FUNC2F_YY_D0NOCOMPOUND\n"); + break; + case P_FUNC2F_YY_END: + sprintf(*buf, "P_FUNC2F_YY_END\n"); + break; + } +} diff --git a/JIT/HPP/traced_absmi_insts.i b/JIT/HPP/traced_absmi_insts.i new file mode 100644 index 000000000..533bd2b0e --- /dev/null +++ b/JIT/HPP/traced_absmi_insts.i @@ -0,0 +1,14985 @@ +/***************************************************************** +* TRACED INSTRUCTIONS * +*****************************************************************/ + + BOp(traced_Ystop, l); + goto Ystop; + ENDBOp(); + + BOp(traced_Nstop, e); + goto Nstop; + ENDBOp(); + +/***************************************************************** +* Plain try - retry - trust instructions * +*****************************************************************/ + /* try_me Label,NArgs */ + Op(traced_try_me, Otapl); + /* check if enough space between trail and codespace */ + EMIT_ENTRY_BLOCK(PREG,TRY_ME_INSTINIT); + check_trail(TR); + /* I use YREG =to go through the choicepoint. Usually YREG =is in a + * register, but sometimes (X86) not. In this case, have a + * new register to point at YREG =*/ + CACHE_Y(YREG); + /* store arguments for procedure */ + store_at_least_one_arg(PREG->u.Otapl.s); + /* store abstract machine registers */ + store_yaam_regs(PREG->u.Otapl.d, 0); + /* On a try_me, set cut to point at previous choicepoint, + * that is, to the B before the cut. + */ + set_cut(S_YREG, B); + /* now, install the new YREG =*/ + B = B_YREG; +#ifdef YAPOR + EMIT_SIMPLE_BLOCK_TEST(TRY_ME_YAPOR); + SCH_set_load(B_YREG); +#endif /* YAPOR */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(TRY_ME_END); + PREG = NEXTOP(PREG, Otapl); + SET_BB(B_YREG); + ENDCACHE_Y(); + GONext(); + ENDOp(); + + /* retry_me Label,NArgs */ + Op(traced_retry_me, Otapl); + EMIT_ENTRY_BLOCK(PREG,RETRY_ME_INSTINIT); + CACHE_Y(B); + /* After retry, cut should be pointing at the parent + * choicepoint for the current B */ + restore_yaam_regs(PREG->u.Otapl.d); + restore_at_least_one_arg(PREG->u.Otapl.s); +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK_TEST(RETRY_ME_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + EMIT_SIMPLE_BLOCK_TEST(RETRY_ME_NOFROZEN); + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK_TEST(RETRY_ME_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + PREG = NEXTOP(PREG, Otapl); + GONext(); + ENDOp(); + + /* trust_me UnusedLabel,NArgs */ + Op(traced_trust_me, Otapl); + EMIT_ENTRY_BLOCK(PREG,TRUST_ME_INSTINIT); + CACHE_Y(B); + EMIT_SIMPLE_BLOCK_TEST(TRUST_ME_IF); +#ifdef YAPOR + if (SCH_top_shared_cp(B)) { + SCH_last_alternative(PREG, B_YREG); + restore_at_least_one_arg(PREG->u.Otapl.s); +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B->cp_b); + } + else +#endif /* YAPOR */ + { + pop_yaam_regs(); + pop_at_least_one_arg(PREG->u.Otapl.s); + /* After trust, cut should be pointing at the new top + * choicepoint */ +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B); + } + EMIT_SIMPLE_BLOCK_TEST(TRUST_ME_END); + PREG = NEXTOP(PREG, Otapl); + SET_BB(B_YREG); + ENDCACHE_Y(); + GONext(); + ENDOp(); + +/***************************************************************** +* Profiled try - retry - trust instructions * +*****************************************************************/ + + /* profiled_enter_me Pred */ + Op(traced_enter_profiling, p); + EMIT_ENTRY_BLOCK(PREG,ENTER_PROFILING_INSTINIT); + LOCK(PREG->u.p.p->StatisticsForPred.lock); + PREG->u.p.p->StatisticsForPred.NOfEntries++; + UNLOCK(PREG->u.p.p->StatisticsForPred.lock); + PREG = NEXTOP(PREG, p); + GONext(); + ENDOp(); + + /* profiled_retry Label,NArgs */ + Op(traced_retry_profiled, p); + EMIT_ENTRY_BLOCK(PREG,RETRY_PROFILED_INSTINIT); + LOCK(PREG->u.p.p->StatisticsForPred.lock); + PREG->u.p.p->StatisticsForPred.NOfRetries++; + UNLOCK(PREG->u.p.p->StatisticsForPred.lock); + PREG = NEXTOP(PREG, p); + GONext(); + ENDOp(); + + /* profiled_retry_me Label,NArgs */ + Op(traced_profiled_retry_me, Otapl); + EMIT_ENTRY_BLOCK(PREG,PROFILED_RETRY_ME_INSTINIT); + CACHE_Y(B); + /* After retry, cut should be pointing at the parent + * choicepoint for the current B */ + LOCK(PREG->u.Otapl.p->StatisticsForPred.lock); + PREG->u.Otapl.p->StatisticsForPred.NOfRetries++; + UNLOCK(PREG->u.Otapl.p->StatisticsForPred.lock); + restore_yaam_regs(PREG->u.Otapl.d); + restore_args(PREG->u.Otapl.s); +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK(PROFILED_RETRY_ME_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + EMIT_SIMPLE_BLOCK(PROFILED_RETRY_ME_NOFROZEN); + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK(PROFILED_RETRY_ME_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + PREG = NEXTOP(PREG, Otapl); + GONext(); + ENDOp(); + + /* profiled_trust_me UnusedLabel,NArgs */ + Op(traced_profiled_trust_me, Otapl); + EMIT_ENTRY_BLOCK(PREG,PROFILED_TRUST_ME_INSTINIT); + CACHE_Y(B); + EMIT_SIMPLE_BLOCK(PROFILED_TRUST_ME_IF); +#ifdef YAPOR + if (SCH_top_shared_cp(B)) { + SCH_last_alternative(PREG, B_YREG); + restore_args(PREG->u.Otapl.s); +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B->cp_b); + } + else +#endif /* YAPOR */ + { + pop_yaam_regs(); + pop_args(PREG->u.Otapl.s); + /* After trust, cut should be pointing at the new top + * choicepoint */ +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B); + } + EMIT_SIMPLE_BLOCK(PROFILED_TRUST_ME_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + LOCK(PREG->u.Otapl.p->StatisticsForPred.lock); + PREG->u.Otapl.p->StatisticsForPred.NOfRetries++; + UNLOCK(PREG->u.Otapl.p->StatisticsForPred.lock); + PREG = NEXTOP(PREG, Otapl); + GONext(); + ENDOp(); + + BOp(traced_profiled_retry_logical, OtaLl); + EMIT_ENTRY_BLOCK(PREG,PROFILED_RETRY_LOGICAL_INSTINIT); + check_trail(TR); + { + UInt timestamp; + CACHE_Y(B); + + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[PREG->u.OtaLl.s]); + if (!VALID_TIMESTAMP(timestamp, PREG->u.OtaLl.d)) { + /* jump to next instruction */ + PREG=PREG->u.OtaLl.n; + JMPNext(); + } + restore_yaam_regs(PREG->u.OtaLl.n); + restore_args(PREG->u.OtaLl.s); + LOCK(PREG->u.OtaLl.d->ClPred->StatisticsForPred.lock); + PREG->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; + UNLOCK(PREG->u.OtaLl.d->ClPred->StatisticsForPred.lock); +#ifdef THREADS + EMIT_SIMPLE_BLOCK(PROFILED_RETRY_LOGICAL_THREADS); + PP = PREG->u.OtaLl.d->ClPred; +#endif + EMIT_SIMPLE_BLOCK(PROFILED_RETRY_LOGICAL_POST_THREADS); + PREG = PREG->u.OtaLl.d->ClCode; +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK(PROFILED_RETRY_LOGICAL_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + EMIT_SIMPLE_BLOCK(PROFILED_RETRY_LOGICAL_NOFROZEN); + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK(PROFILED_RETRY_LOGICAL_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + } + JMPNext(); + ENDBOp(); + + BOp(traced_profiled_trust_logical, OtILl); + EMIT_ENTRY_BLOCK(PREG,PROFILED_TRUST_LOGICAL_INSTINIT); + EMIT_SIMPLE_BLOCK(PROFILED_TRUST_LOGICAL_END); + CACHE_Y(B); + { + LogUpdIndex *cl = PREG->u.OtILl.block; + PredEntry *ap = cl->ClPred; + LogUpdClause *lcl = PREG->u.OtILl.d; + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); + + if (!VALID_TIMESTAMP(timestamp, lcl)) { + /* jump to next alternative */ + PREG = FAILCODE; + } else { + LOCK(ap->StatisticsForPred.lock); + ap->StatisticsForPred.NOfRetries++; + UNLOCK(ap->StatisticsForPred.lock); + PREG = lcl->ClCode; + } + /* HREY, leave indexing block alone!! */ + /* check if we are the ones using this code */ +#if MULTIPLE_STACKS + PELOCK(1, ap); + PP = ap; + DEC_CLREF_COUNT(cl); + /* clear the entry from the trail */ + B->cp_tr--; + TR = B->cp_tr; + /* actually get rid of the code */ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { + if (PREG != FAILCODE) { + /* I am the last one using this clause, hence I don't need a lock + to dispose of it + */ + if (lcl->ClRefCount == 1) { + /* make sure the clause isn't destroyed */ + /* always add an extra reference */ + INC_CLREF_COUNT(lcl); + TRAIL_CLREF(lcl); + } + } + if (cl->ClFlags & ErasedMask) { + saveregs(); + Yap_ErLogUpdIndex(cl); + setregs(); + } else { + saveregs(); + Yap_CleanUpIndex(cl); + setregs(); + } + save_pc(); + } +#else + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && + B->cp_tr != B->cp_b->cp_tr) { + cl->ClFlags &= ~InUseMask; + --B->cp_tr; +#if FROZEN_STACKS + if (B->cp_tr > TR_FZ) +#endif + { + TR = B->cp_tr; + } + /* next, recover space for the indexing code if it was erased */ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { + if (PREG != FAILCODE) { + /* make sure we don't erase the clause we are jumping too */ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { + lcl->ClFlags |= InUseMask; + TRAIL_CLREF(lcl); + } + } + if (cl->ClFlags & ErasedMask) { + saveregs(); + Yap_ErLogUpdIndex(cl); + setregs(); + } else { + saveregs(); + Yap_CleanUpIndex(cl); + setregs(); + } + save_pc(); + } + } +#endif +#ifdef YAPOR + if (SCH_top_shared_cp(B)) { + SCH_last_alternative(PREG, B_YREG); + restore_args(ap->ArityOfPE); +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#else + S_YREG++; +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B->cp_b); + } else +#endif /* YAPOR */ + { + pop_yaam_regs(); + pop_args(ap->ArityOfPE); + S_YREG--; +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B); + } + SET_BB(B_YREG); + ENDCACHE_Y(); + JMPNext(); + } + ENDBOp(); + +/***************************************************************** +* Call count instructions * +*****************************************************************/ + + /* count_enter_me Label,NArgs */ + Op(traced_count_call, p); + EMIT_ENTRY_BLOCK(PREG,COUNT_CALL_INSTINIT); + LOCK(PREG->u.p.p->StatisticsForPred.lock); + PREG->u.p.p->StatisticsForPred.NOfEntries++; + UNLOCK(PREG->u.p.p->StatisticsForPred.lock); + LOCAL_ReductionsCounter--; + EMIT_SIMPLE_BLOCK(COUNT_CALL_MIDDLE); + if (LOCAL_ReductionsCounter == 0 && LOCAL_ReductionsCounterOn) { + saveregs(); + Yap_NilError(CALL_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + LOCAL_PredEntriesCounter--; + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { + saveregs(); + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + EMIT_SIMPLE_BLOCK(COUNT_CALL_END); + PREG = NEXTOP(PREG, p); + GONext(); + ENDOp(); + + /* count_retry Label,NArgs */ + Op(traced_count_retry, p); + EMIT_ENTRY_BLOCK(PREG,COUNT_RETRY_INSTINIT); + LOCK(PREG->u.p.p->StatisticsForPred.lock); + PREG->u.p.p->StatisticsForPred.NOfRetries++; + UNLOCK(PREG->u.p.p->StatisticsForPred.lock); + LOCAL_RetriesCounter--; + EMIT_SIMPLE_BLOCK(COUNT_RETRY_MIDDLE); + if (LOCAL_RetriesCounter == 0 && LOCAL_RetriesCounterOn) { + /* act as if we had backtracked */ + ENV = B->cp_env; + saveregs(); + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + LOCAL_PredEntriesCounter--; + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { + ENV = B->cp_env; + saveregs(); + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + EMIT_SIMPLE_BLOCK(COUNT_RETRY_END); + PREG = NEXTOP(PREG, p); + GONext(); + ENDOp(); + + /* count_retry_me Label,NArgs */ + Op(traced_count_retry_me, Otapl); + EMIT_ENTRY_BLOCK(PREG,COUNT_RETRY_ME_INSTINIT); + CACHE_Y(B); + restore_yaam_regs(PREG->u.Otapl.d); + restore_args(PREG->u.Otapl.s); + /* After retry, cut should be pointing at the parent + * choicepoint for the current B */ + EMIT_SIMPLE_BLOCK(COUNT_RETRY_ME_MIDDLE); +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + SET_BB(B_YREG); + ENDCACHE_Y(); + LOCK(((PredEntry *)(PREG->u.Otapl.p))->StatisticsForPred.lock); + ((PredEntry *)(PREG->u.Otapl.p))->StatisticsForPred.NOfRetries++; + UNLOCK(((PredEntry *)(PREG->u.Otapl.p))->StatisticsForPred.lock); + LOCAL_RetriesCounter--; + if (LOCAL_RetriesCounter == 0 && LOCAL_RetriesCounterOn) { + saveregs(); + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + LOCAL_PredEntriesCounter--; + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { + saveregs(); + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + EMIT_SIMPLE_BLOCK(COUNT_RETRY_ME_END); + PREG = NEXTOP(PREG, Otapl); + GONext(); + ENDOp(); + + /* count_trust_me UnusedLabel,NArgs */ + Op(traced_count_trust_me, Otapl); + EMIT_ENTRY_BLOCK(PREG,COUNT_TRUST_ME_INSTINIT); + CACHE_Y(B); + EMIT_SIMPLE_BLOCK(COUNT_TRUST_ME_MIDDLE); +#ifdef YAPOR + if (SCH_top_shared_cp(B)) { + SCH_last_alternative(PREG, B_YREG); + restore_args(PREG->u.Otapl.s); +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B->cp_b); + } + else +#endif /* YAPOR */ + { + pop_yaam_regs(); + pop_args(PREG->u.Otapl.s); + /* After trust, cut should be pointing at the new top + * choicepoint */ +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B); + } + SET_BB(B_YREG); + ENDCACHE_Y(); + LOCAL_RetriesCounter--; + if (LOCAL_RetriesCounter == 0) { + saveregs(); + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + LOCAL_PredEntriesCounter--; + if (LOCAL_PredEntriesCounter == 0) { + saveregs(); + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + EMIT_SIMPLE_BLOCK(COUNT_TRUST_ME_END); + LOCK(((PredEntry *)(PREG->u.Otapl.p))->StatisticsForPred.lock); + ((PredEntry *)(PREG->u.Otapl.p))->StatisticsForPred.NOfRetries++; + UNLOCK(((PredEntry *)(PREG->u.Otapl.p))->StatisticsForPred.lock); + PREG = NEXTOP(PREG, Otapl); + GONext(); + ENDOp(); + + BOp(traced_count_retry_logical, OtaLl); + EMIT_ENTRY_BLOCK(PREG,COUNT_RETRY_LOGICAL_INSTINIT); + EMIT_SIMPLE_BLOCK(COUNT_RETRY_LOGICAL_END); + check_trail(TR); + { + UInt timestamp; + CACHE_Y(B); + + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[PREG->u.OtaLl.s]); + if (!VALID_TIMESTAMP(timestamp, PREG->u.OtaLl.d)) { + /* jump to next instruction */ + PREG=PREG->u.OtaLl.n; + JMPNext(); + } + restore_yaam_regs(PREG->u.OtaLl.n); + restore_args(PREG->u.OtaLl.s); + LOCAL_RetriesCounter--; + if (LOCAL_RetriesCounter == 0) { + saveregs(); + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + LOCAL_PredEntriesCounter--; + if (LOCAL_PredEntriesCounter == 0) { + saveregs(); + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + LOCK(PREG->u.OtaLl.d->ClPred->StatisticsForPred.lock); + PREG->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; + UNLOCK(PREG->u.OtaLl.d->ClPred->StatisticsForPred.lock); +#ifdef THREADS + PP = PREG->u.OtaLl.d->ClPred; +#endif + PREG = PREG->u.OtaLl.d->ClCode; +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + SET_BB(B_YREG); + ENDCACHE_Y(); + } + JMPNext(); + ENDBOp(); + + BOp(traced_count_trust_logical, OtILl); + EMIT_ENTRY_BLOCK(PREG,COUNT_TRUST_LOGICAL_INSTINIT); + EMIT_SIMPLE_BLOCK(COUNT_TRUST_LOGICAL_END); + CACHE_Y(B); + { + LogUpdIndex *cl = PREG->u.OtILl.block; + PredEntry *ap = cl->ClPred; + LogUpdClause *lcl = PREG->u.OtILl.d; + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); + + if (!VALID_TIMESTAMP(timestamp, lcl)) { + /* jump to next alternative */ + PREG = FAILCODE; + } else { + LOCAL_RetriesCounter--; + if (LOCAL_RetriesCounter == 0) { + saveregs(); + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + LOCAL_PredEntriesCounter--; + if (LOCAL_PredEntriesCounter == 0) { + saveregs(); + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + LOCK(ap->StatisticsForPred.lock); + ap->StatisticsForPred.NOfRetries++; + UNLOCK(ap->StatisticsForPred.lock); + PREG = lcl->ClCode; + } + /* HREY, leave indexing block alone!! */ + /* check if we are the ones using this code */ +#if MULTIPLE_STACKS + PELOCK(2, ap); + PP = ap; + DEC_CLREF_COUNT(cl); + /* clear the entry from the trail */ + --B->cp_tr; + TR = B->cp_tr; + /* actually get rid of the code */ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { + if (PREG != FAILCODE) { + /* I am the last one using this clause, hence I don't need a lock + to dispose of it + */ + if (lcl->ClRefCount == 1) { + /* make sure the clause isn't destroyed */ + /* always add an extra reference */ + INC_CLREF_COUNT(lcl); + TRAIL_CLREF(lcl); + } + } + if (cl->ClFlags & ErasedMask) { + saveregs(); + Yap_ErLogUpdIndex(cl); + setregs(); + } else { + saveregs(); + Yap_CleanUpIndex(cl); + setregs(); + } + save_pc(); + } +#else + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && + B->cp_tr != B->cp_b->cp_tr) { + cl->ClFlags &= ~InUseMask; + --B->cp_tr; +#if FROZEN_STACKS + if (B->cp_tr > TR_FZ) +#endif + { + TR = B->cp_tr; + } + /* next, recover space for the indexing code if it was erased */ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { + if (PREG != FAILCODE) { + /* make sure we don't erase the clause we are jumping too */ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { + lcl->ClFlags |= InUseMask; + TRAIL_CLREF(lcl); + } + } + if (cl->ClFlags & ErasedMask) { + saveregs(); + Yap_ErLogUpdIndex(cl); + setregs(); + } else { + saveregs(); + Yap_CleanUpIndex(cl); + setregs(); + } + save_pc(); + } + } +#endif +#ifdef YAPOR + if (SCH_top_shared_cp(B)) { + SCH_last_alternative(PREG, B_YREG); + restore_args(ap->ArityOfPE); +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#else + S_YREG++; +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B->cp_b); + } else +#endif /* YAPOR */ + { + pop_yaam_regs(); + pop_args(ap->ArityOfPE); + S_YREG--; +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B); + } + SET_BB(B_YREG); + ENDCACHE_Y(); + JMPNext(); + } + ENDBOp(); + + + +/***************************************************************** +* enter a logical semantics dynamic predicate * +*****************************************************************/ + + /* only meaningful with THREADS on! */ + /* lock logical updates predicate. */ + Op(traced_lock_lu, p); + EMIT_SIMPLE_BLOCK(LOCK_LU_INSTINIT); + EMIT_SIMPLE_BLOCK(LOCK_LU_END); +#if PARALLEL_YAP + if (PP) { + GONext(); + } + PP = PREG->u.p.p; + PELOCK(3, PP); +#endif + PREG = NEXTOP(PREG, p); + GONext(); + ENDOp(); + + /* only meaningful with THREADS on! */ + /* lock logical updates predicate. */ + Op(traced_unlock_lu, e); + EMIT_SIMPLE_BLOCK(UNLOCK_LU_INSTINIT); +#if defined(YAPOR) || defined(THREADS) + EMIT_SIMPLE_BLOCK(UNLOCK_LU_YAPOR_THREADS); + UNLOCKPE(1,PP); + PP = NULL; +#endif + EMIT_SIMPLE_BLOCK(UNLOCK_LU_END); + PREG = NEXTOP(PREG, e); + GONext(); + ENDOp(); + + + /* enter logical pred */ + BOp(traced_alloc_for_logical_pred, L); + EMIT_ENTRY_BLOCK(PREG,ALLOC_FOR_LOGICAL_PRED_INSTINIT); + EMIT_SIMPLE_BLOCK(YAAM_CHECK_TRAIL_TR); + check_trail(TR); + /* say that an environment is using this clause */ + /* we have our own copy for the clause */ +#if MULTIPLE_STACKS + { + EMIT_SIMPLE_BLOCK(ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS); + LogUpdClause *cl = PREG->u.L.ClBase; +#if PARALLEL_YAP + EMIT_SIMPLE_BLOCK(ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL); + PredEntry *ap = cl->ClPred; +#endif + EMIT_SIMPLE_BLOCK(ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END); + /* always add an extra reference */ + INC_CLREF_COUNT(cl); + TRAIL_CLREF(cl); + UNLOCKPE(2,ap); + PP = NULL; + } +#else + { + EMIT_SIMPLE_BLOCK(ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT); + LogUpdClause *cl = (LogUpdClause *)PREG->u.L.ClBase; + EMIT_SIMPLE_BLOCK(ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF); + if (!(cl->ClFlags & InUseMask)) { + cl->ClFlags |= InUseMask; + TRAIL_CLREF(cl); + } + } +#endif + EMIT_SIMPLE_BLOCK(ALLOC_FOR_LOGICAL_PRED_END); + PREG = NEXTOP(PREG, L); + JMPNext(); + ENDBOp(); + + /* copy database term */ + BOp(traced_copy_idb_term, e); + EMIT_ENTRY_BLOCK(PREG,COPY_IDB_TERM_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(COPY_IDB_TERM_END); + { + LogUpdClause *cl = ClauseCodeToLogUpdClause(PREG); + Term t; + + SET_ASP(YREG, E_CB*sizeof(CELL)); + saveregs(); + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { + if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { + LOCAL_Error_TYPE = YAP_NO_ERROR; + if (!Yap_growglobal(NULL)) { + UNLOCKPE(3,PP); +#if defined(YAPOR) || defined(THREADS) + PP = NULL; +#endif + Yap_NilError(OUT_OF_ATTVARS_ERROR, LOCAL_ErrorMessage); + TRACED_FAIL(); + } + } else { + LOCAL_Error_TYPE = YAP_NO_ERROR; + if (!Yap_gc(3, ENV, CP)) { + UNLOCKPE(4,PP); +#if defined(YAPOR) || defined(THREADS) + PP = NULL; +#endif + Yap_NilError(OUT_OF_STACK_ERROR, LOCAL_ErrorMessage); + TRACED_FAIL(); + } + } + } + if (!Yap_IUnify(ARG2, t)) { + setregs(); + UNLOCKPE(5,PP); +#if defined(YAPOR) || defined(THREADS) + PP = NULL; +#endif + TRACED_FAIL(); + } + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { + setregs(); + UNLOCKPE(6,PP); +#if defined(YAPOR) || defined(THREADS) + PP = NULL; +#endif + TRACED_FAIL(); + } + setregs(); + +#if MULTIPLE_STACKS + /* always add an extra reference */ + INC_CLREF_COUNT(cl); + TRAIL_CLREF(cl); + UNLOCKPE(7,PP); + PP = NULL; +#else + if (!(cl->ClFlags & InUseMask)) { + /* Clause *cl = (Clause *)PREG->u.EC.ClBase; + + PREG->u.EC.ClTrail = TR-(tr_fr_ptr)LOCAL_TrailBase; + PREG->u.EC.ClENV = LCL0-YREG;*/ + cl->ClFlags |= InUseMask; + TRAIL_CLREF(cl); + } +#endif + } + PREG = CPREG; + YREG = ENV; +#ifdef DEPTH_LIMIT + DEPTH = YREG[E_DEPTH]; +#endif + JMPNext(); + ENDBOp(); + + + /* unify with database term */ + BOp(traced_unify_idb_term, e); + EMIT_ENTRY_BLOCK(PREG,UNIFY_IDB_TERM_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_IDB_TERM_END); + { + LogUpdClause *cl = ClauseCodeToLogUpdClause(PREG); + + saveregs(); + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { + setregs(); + UNLOCKPE(8,PP); +#if defined(YAPOR) || defined(THREADS) + PP = NULL; +#endif + TRACED_FAIL(); + } + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { + setregs(); + UNLOCKPE(9,PP); +#if defined(YAPOR) || defined(THREADS) + PP = NULL; +#endif + TRACED_FAIL(); + } + setregs(); + + /* say that an environment is using this clause */ + /* we have our own copy for the clause */ +#if MULTIPLE_STACKS + /* always add an extra reference */ + INC_CLREF_COUNT(cl); + TRAIL_CLREF(cl); + UNLOCKPE(10,PP); + PP = NULL; +#else + if (!(cl->ClFlags & InUseMask)) { + /* Clause *cl = (Clause *)PREG->u.EC.ClBase; + + PREG->u.EC.ClTrail = TR-(tr_fr_ptr)LOCAL_TrailBase; + PREG->u.EC.ClENV = LCL0-YREG;*/ + cl->ClFlags |= InUseMask; + TRAIL_CLREF(cl); + } +#endif + } + PREG = CPREG; + YREG = ENV; +#ifdef DEPTH_LIMIT + DEPTH = YREG[E_DEPTH]; +#endif + JMPNext(); + ENDBOp(); + + +/***************************************************************** +* check for enough room * +*****************************************************************/ + + /* ensure_space */ + BOp(traced_ensure_space, Osbpa); + EMIT_ENTRY_BLOCK(PREG,ENSURE_SPACE_INSTINIT); + EMIT_SIMPLE_BLOCK(ENSURE_SPACE_END); + { + Int sz = PREG->u.Osbpa.i; + UInt arity = PREG->u.Osbpa.p->ArityOfPE; + if (Unsigned(HR) + sz > Unsigned(YREG)-CreepFlag) { + YENV[E_CP] = (CELL) CPREG; + YENV[E_E] = (CELL) ENV; +#ifdef DEPTH_LIMIT + YENV[E_DEPTH] = DEPTH; +#endif /* DEPTH_LIMIT */ + SET_ASP(YREG, PREG->u.Osbpa.s); + PREG = NEXTOP(PREG,Osbpa); + saveregs(); + if (!Yap_gcl(sz, arity, YENV, PREG)) { + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } else { + setregs(); + } + } else { + PREG = NEXTOP(PREG,Osbpa); + } + } + JMPNext(); + ENDBOp(); + +/***************************************************************** +* try and retry of dynamic predicates * +*****************************************************************/ + + /* spy_or_trymark */ + BOp(traced_spy_or_trymark, Otapl); + EMIT_ENTRY_BLOCK(PREG,SPY_OR_TRYMARK_INSTINIT); + PELOCK(5, ((PredEntry *)(PREG->u.Otapl.p))); + PREG = (yamop *)(&(((PredEntry *)(PREG->u.Otapl.p))->OpcodeOfPred)); + UNLOCKPE(11,(PredEntry *)(PREG->u.Otapl.p)); + goto traced_dospy; + ENDBOp(); + + /* try_and_mark Label,NArgs */ + BOp(traced_try_and_mark, Otapl); + EMIT_ENTRY_BLOCK(PREG,TRY_AND_MARK_INSTINIT); + check_trail(TR); +#if defined(YAPOR) || defined(THREADS) +#ifdef YAPOR + /* The flags I check here should never change during execution */ + EMIT_SIMPLE_BLOCK(TRY_AND_MARK_YAPOR_THREADS_YAPOR); + CUT_wait_leftmost(); +#endif /* YAPOR */ + EMIT_SIMPLE_BLOCK(TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF); + if (PREG->u.Otapl.p->PredFlags & LogUpdatePredFlag) { + PELOCK(6,PREG->u.Otapl.p); + PP = PREG->u.Otapl.p; + } + if (PREG->u.Otapl.p->CodeOfPred != PREG) { + /* oops, someone changed the procedure under our feet, + fortunately this is no big deal because we haven't done + anything yet */ + PP = NULL; + PREG = PREG->u.Otapl.p->CodeOfPred; + UNLOCKPE(12,PREG->u.Otapl.p); + /* for profiler */ + save_pc(); + JMPNext(); + } +#endif + EMIT_SIMPLE_BLOCK(TRY_AND_MARK_NOYAPOR_NOTHREADS); + CACHE_Y(YREG); + PREG = PREG->u.Otapl.d; + /* + I've got a read lock on the DB, so I don't need to care... + niaaahh.... niahhhh... + */ + LOCK(DynamicLock(PREG)); + /* one can now mess around with the predicate */ + UNLOCKPE(13,((PredEntry *)(PREG->u.Otapl.p))); + BEGD(d1); + d1 = PREG->u.Otapl.s; + store_args(d1); + store_yaam_regs(PREG, 0); + ENDD(d1); + set_cut(S_YREG, B); + B = B_YREG; +#ifdef YAPOR + EMIT_SIMPLE_BLOCK(TRY_AND_MARK_SET_LOAD); + SCH_set_load(B_YREG); +#endif /* YAPOR */ + EMIT_SIMPLE_BLOCK(TRY_AND_MARK_POST_SET_LOAD); + SET_BB(B_YREG); + ENDCACHE_Y(); +#if MULTIPLE_STACKS + EMIT_SIMPLE_BLOCK(TRY_AND_MARK_MULTIPLE_STACKS); + INC_CLREF_COUNT(ClauseCodeToDynamicClause(PREG)); + UNLOCK(DynamicLock(PREG)); + TRAIL_CLREF(ClauseCodeToDynamicClause(PREG)); +#else + EMIT_SIMPLE_BLOCK(TRY_AND_MARK_NOMULTIPLE_STACKS_IF); + if (FlagOff(InUseMask, DynamicFlags(PREG))) { + SetFlag(InUseMask, DynamicFlags(PREG)); + TRAIL_CLREF(ClauseCodeToDynamicClause(PREG)); + } +#endif + EMIT_SIMPLE_BLOCK(TRY_AND_MARK_END); + PREG = NEXTOP(PREG,Otapl); + JMPNext(); + + ENDBOp(); + + BOp(traced_count_retry_and_mark, Otapl); + EMIT_ENTRY_BLOCK(PREG,COUNT_RETRY_AND_MARK_INSTINIT); + LOCAL_RetriesCounter--; + if (LOCAL_RetriesCounter == 0) { + saveregs(); + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + LOCAL_PredEntriesCounter--; + if (LOCAL_PredEntriesCounter == 0) { + saveregs(); + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + /* enter a retry dynamic */ + ENDBOp(); + + BOp(traced_profiled_retry_and_mark, Otapl); + EMIT_ENTRY_BLOCK(PREG,PROFILED_RETRY_AND_MARK_INSTINIT); + LOCK(((PredEntry *)(PREG->u.Otapl.p))->StatisticsForPred.lock); + ((PredEntry *)(PREG->u.Otapl.p))->StatisticsForPred.NOfRetries++; + UNLOCK(((PredEntry *)(PREG->u.Otapl.p))->StatisticsForPred.lock); + /* enter a retry dynamic */ + ENDBOp(); + + /* retry_and_mark Label,NArgs */ + BOp(traced_retry_and_mark, Otapl); + EMIT_ENTRY_BLOCK(PREG,RETRY_AND_MARK_INSTINIT); +#ifdef YAPOR + EMIT_SIMPLE_BLOCK(RETRY_AND_MARK_YAPOR); + CUT_wait_leftmost(); +#endif /* YAPOR */ + /* need to make the DB stable until I get the new clause */ + EMIT_SIMPLE_BLOCK(RETRY_AND_MARK_POST_YAPOR); + PELOCK(7,PREG->u.Otapl.p); + CACHE_Y(B); + PREG = PREG->u.Otapl.d; + LOCK(DynamicLock(PREG)); + UNLOCK(PREG->u.Otapl.p->PELock); + restore_yaam_regs(PREG); + restore_args(PREG->u.Otapl.s); +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK(RETRY_AND_MARK_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + EMIT_SIMPLE_BLOCK(RETRY_AND_MARK_NOFROZEN); + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK(RETRY_AND_MARK_POST_FROZEN); + SET_BB(B_YREG); + ENDCACHE_Y(); +#if MULTIPLE_STACKS + EMIT_SIMPLE_BLOCK(RETRY_AND_MARK_MULTIPLE_STACKS); + INC_CLREF_COUNT(ClauseCodeToDynamicClause(PREG)); + TRAIL_CLREF(ClauseCodeToDynamicClause(PREG)); + UNLOCK(DynamicLock(PREG)); +#else + EMIT_SIMPLE_BLOCK(RETRY_AND_MARK_NOMULTIPLE_STACKS_IF); + if (FlagOff(InUseMask, DynamicFlags(PREG))) { + SetFlag(InUseMask, DynamicFlags(PREG)); + TRAIL_CLREF(ClauseCodeToDynamicClause(PREG)); + } +#endif + EMIT_SIMPLE_BLOCK(RETRY_AND_MARK_END); + PREG = NEXTOP(PREG, Otapl); + JMPNext(); + + ENDBOp(); + +/***************************************************************** +* Failure * +*****************************************************************/ + + /* trust_fail */ + BOp(traced_trust_fail, e); + EMIT_ENTRY_BLOCK(PREG,TRUST_FAIL_INSTINIT); +#ifdef CUT_C + { + EMIT_SIMPLE_BLOCK(TRUST_FAIL_CUT_C); + while (POP_CHOICE_POINT(B->cp_b)) + { + POP_EXECUTE(); + } + } +#endif /* CUT_C */ +#ifdef YAPOR + { + EMIT_SIMPLE_BLOCK(TRUST_FAIL_YAPOR); + choiceptr cut_pt; + cut_pt = B->cp_b; + CUT_prune_to(cut_pt); + B = cut_pt; + } +#else + EMIT_SIMPLE_BLOCK(TRUST_FAIL_NOYAPOR); + B = B->cp_b; +#endif /* YAPOR */ + goto traced_fail; + ENDBOp(); + +#ifdef YAPOR + traced_shared_fail: + EMIT_SIMPLE_BLOCK(LBL_SHARED_FAIL); + B = Get_LOCAL_top_cp(); + SET_BB(PROTECT_FROZEN_B(B)); + goto traced_fail; +#endif /* YAPOR */ + + /* traced_fail */ + PBOp(traced_op_fail, e); + EMIT_ENTRY_BLOCK(PREG,OP_FAIL_INSTINIT); + if (PP) { + UNLOCK(PP->PELock); + PP = NULL; + } +#ifdef COROUTINING + CACHE_Y_AS_ENV(YREG); + EMIT_SIMPLE_BLOCK_TEST(NoStackFail_Exception); + check_stack(NoStackFail, HR); + ENDCACHE_Y_AS_ENV(); +#endif + + traced_fail: + { + EMIT_ENTRY_BLOCK(PREG,LBL_FAIL_INSTINIT); + register tr_fr_ptr pt0 = TR; +#if defined(YAPOR) || defined(THREADS) + if (PP) { + UNLOCK(PP->PELock); + PP = NULL; + } +#endif + PREG = B->cp_ap; + save_pc(); + CACHE_TR(B->cp_tr); + PREFETCH_OP(PREG); + traced_failloop: + if (pt0 == S_TR) { + SP = SP0; +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + int go_on = TRUE; + yamop *ipc = PREG; + + while (go_on) { + op_numbers opnum = Yap_op_from_opcode(ipc->opc); + + go_on = FALSE; + switch (opnum) { +#ifdef TABLING + case _table_load_answer: + { + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); + break; + } + case _table_try_answer: + case _table_retry_me: + case _table_trust_me: + case _table_retry: + case _table_trust: + case _table_completion: +#ifdef THREADS_CONSUMER_SHARING + case _table_answer_resolution_completion: +#endif /* THREADS_CONSUMER_SHARING */ +#ifdef DETERMINISTIC_TABLING + if (IS_DET_GEN_CP(B)) { + low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry, NULL); + } else +#endif /* DETERMINISTIC_TABLING */ + { + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); + } + break; + case _table_answer_resolution: + { + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); + break; + } + case _trie_trust_var: + case _trie_retry_var: + case _trie_trust_var_in_pair: + case _trie_retry_var_in_pair: + case _trie_trust_val: + case _trie_retry_val: + case _trie_trust_val_in_pair: + case _trie_retry_val_in_pair: + case _trie_trust_atom: + case _trie_retry_atom: + case _trie_trust_atom_in_pair: + case _trie_retry_atom_in_pair: + case _trie_trust_null: + case _trie_retry_null: + case _trie_trust_null_in_pair: + case _trie_retry_null_in_pair: + case _trie_trust_pair: + case _trie_retry_pair: + case _trie_trust_appl: + case _trie_retry_appl: + case _trie_trust_appl_in_pair: + case _trie_retry_appl_in_pair: + case _trie_trust_extension: + case _trie_retry_extension: + case _trie_trust_double: + case _trie_retry_double: + case _trie_trust_longint: + case _trie_retry_longint: + case _trie_trust_gterm: + case _trie_retry_gterm: + { + low_level_trace(retry_table_loader, UndefCode, NULL); + break; + } +#endif /* TABLING */ + case _or_else: + case _or_last: + { + low_level_trace(retry_or, (PredEntry *)ipc, &(B->cp_a1)); + break; + } + case _retry2: + case _retry3: + case _retry4: + { + ipc = NEXTOP(traced_ipc,l); + go_on = TRUE; + break; + } + case _jump: + { + ipc = ipc->u.l.l; + go_on = TRUE; + break; + } + case _retry_c: + case _retry_userc: + { + low_level_trace(retry_pred, ipc->u.OtapFs.p, B->cp_args); + break; + } + case _retry_profiled: + case _count_retry: + { + ipc = NEXTOP(traced_ipc,p); + go_on = TRUE; + break; + } + case _retry_me: + case _trust_me: + case _count_retry_me: + case _count_trust_me: + case _profiled_retry_me: + case _profiled_trust_me: + case _retry_and_mark: + case _profiled_retry_and_mark: + case _retry: + case _trust: + { + low_level_trace(retry_pred, ipc->u.Otapl.p, B->cp_args); + break; + } + case _try_logical: + case _retry_logical: + case _profiled_retry_logical: + case _count_retry_logical: + case _trust_logical: + case _profiled_trust_logical: + case _count_trust_logical: + { + low_level_trace(retry_pred, ipc->u.OtILl.d->ClPred, B->cp_args); + break; + } + case _Nstop: + case _Ystop: + { + low_level_trace(retry_pred, NULL, B->cp_args); + break; + } + default: + break; + } + } + } +#endif /* LOW_LEVEL_TRACER */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA + if (pt0 < TR_FZ || pt0 > (ADDR)CurrentTrailTop+MinTrailGap) +#else + if (pt0 < TR_FZ) +#endif /* YAPOR_SBA */ + { + TR = TR_FZ; + TRAIL_LINK(pt0); + } else +#endif /* FROZEN_STACKS */ + { + RESTORE_TR(); + } + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(LBL_FAIL_END); + GONext(); + } + BEGD(d1); + d1 = TrailTerm(pt0-1); + pt0--; + if (IsVarTerm(d1)) { +#if defined(YAPOR_SBA) && defined(YAPOR) + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { + RESET_VARIABLE(STACK_TO_SBA(d1)); + } else +#endif + { + /* normal variable */ + RESET_VARIABLE(d1); + } + goto traced_failloop; + } + /* pointer to code space */ + /* or updatable variable */ +#if defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || defined(MULTI_ASSIGNMENT_VARIABLES) + if (IsPairTerm(d1)) +#endif /* TERM_EXTENSIONS || FROZEN_STACKS || MULTI_ASSIGNMENT_VARIABLES */ + { + register CELL flags; + CELL *pt1 = RepPair(d1); +#ifdef LIMIT_TABLING + if ((ADDR) pt1 == LOCAL_TrailBase) { + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); + SgFr_state(sg_fr)--; /* complete_in_use --> complete : compiled_in_use --> compiled */ + insert_into_global_sg_fr_list(sg_fr); + goto traced_failloop; + } +#endif /* LIMIT_TABLING */ +#ifdef FROZEN_STACKS /* TRAIL */ + if ( +#ifdef YAPOR_SBA + (ADDR) pt1 >= HeapTop +#else + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop+MinTrailGap) +#endif /* YAPOR_SBA */ + ) + { + pt0 = (tr_fr_ptr) pt1; + goto traced_failloop; + } else +#endif /* FROZEN_STACKS */ + if (IN_BETWEEN(H0,pt1,H)) { + if (IsAttVar(pt1)) { + goto traced_failloop; + } else if (*pt1 == (CELL)FunctorBigInt) { + Yap_CleanOpaqueVariable(pt1); + } + } +#ifdef FROZEN_STACKS /* TRAIL */ + if (pt0 < TR_FZ) { + goto traced_failloop; + } +#endif + flags = *pt1; +#if MULTIPLE_STACKS + if (FlagOn(DBClMask, flags)) { + DBRef dbr = DBStructFlagsToDBStruct(pt1); + int erase; + + LOCK(dbr->lock); + DEC_DBREF_COUNT(dbr); + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); + UNLOCK(dbr->lock); + if (erase) { + saveregs(); + Yap_ErDBE(dbr); + setregs(); + } + } else { + if (flags & LogUpdMask) { + if (flags & IndexMask) { + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); + int erase; +#if PARALLEL_YAP + PredEntry *ap = cl->ClPred; +#endif + PELOCK(8,ap); + DEC_CLREF_COUNT(cl); + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); + if (erase) { + saveregs(); + Yap_ErLogUpdIndex(cl); + setregs(); + } else if (cl->ClFlags & DirtyMask) { + saveregs(); + Yap_CleanUpIndex(cl); + setregs(); + } + UNLOCK(ap->PELock); + } else { + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); + int erase; +#if PARALLEL_YAP + PredEntry *ap = cl->ClPred; +#endif + PELOCK(9,ap); + DEC_CLREF_COUNT(cl); + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); + if (erase) { + saveregs(); + Yap_ErLogUpdCl(cl); + setregs(); + } + UNLOCK(ap->PELock); + } + } else { + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); + int erase; + + LOCK(cl->ClLock); + DEC_CLREF_COUNT(cl); + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); + UNLOCK(cl->ClLock); + if (erase) { + saveregs(); + Yap_ErCl(cl); + setregs(); + } + } + } +#else + ResetFlag(InUseMask, flags); + *pt1 = flags; + if (FlagOn((ErasedMask|DirtyMask), flags)) { + if (FlagOn(DBClMask, flags)) { + saveregs(); + Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); + setregs(); + } else { + saveregs(); + if (flags & LogUpdMask) { + if (flags & IndexMask) { + if (FlagOn(ErasedMask, flags)) { + Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); + } else { + Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); + } + } else { + Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1)); + } + } else { + Yap_ErCl(ClauseFlagsToDynamicClause(pt1)); + } + setregs(); + } + } +#endif + goto traced_failloop; + } +#ifdef MULTI_ASSIGNMENT_VARIABLES + else /* if (IsApplTerm(d1)) */ { + CELL *pt = RepAppl(d1); +#ifdef FROZEN_STACKS + --pt0; + pt[0] = TrailVal(pt0); +#else + pt[0] = TrailTerm(pt0-1); + pt0 -= 2; +#endif /* FROZEN_STACKS */ + goto traced_failloop; + } +#endif + ENDD(d1); + ENDCACHE_TR(); + } + ENDPBOp(); + + + +/************************************************************************\ +* Cut & Commit Instructions * +\************************************************************************/ + + /* cut */ + Op(traced_cut, s); + EMIT_ENTRY_BLOCK(PREG,CUT_INSTINIT); +#ifdef COROUTINING + EMIT_SIMPLE_BLOCK_TEST(CUT_COROUTINING); + if (FALSE) { + CACHE_Y_AS_ENV(YREG); + EMIT_SIMPLE_BLOCK_TEST(NoStackCut_Exception); + check_stack(NoStackCut, HR); + ENDCACHE_Y_AS_ENV(); + } +#endif + EMIT_SIMPLE_BLOCK_TEST(CUT_NOCOROUTINING); + SET_ASP(YREG, PREG->u.s.s); + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, s),Osbpp),l); + /* assume cut is always in stack */ + saveregs(); + prune((choiceptr)YREG[E_CB]); + setregs(); + GONext(); + ENDOp(); + + /* cut_t */ + /* cut_t does the same as cut */ + Op(traced_cut_t, s); + EMIT_ENTRY_BLOCK(PREG,CUT_T_INSTINIT); +#ifdef COROUTINING + EMIT_SIMPLE_BLOCK_TEST(CUT_T_COROUTINING); + if (FALSE) { + CACHE_Y_AS_ENV(YREG); + EMIT_SIMPLE_BLOCK_TEST(NoStackCutT_Exception); + check_stack(NoStackCutT, HR); + ENDCACHE_Y_AS_ENV(); + } +#endif + EMIT_SIMPLE_BLOCK_TEST(CUT_T_NOCOROUTINING); + SET_ASP(YREG, PREG->u.s.s); + /* assume cut is always in stack */ + saveregs(); + prune((choiceptr)YREG[E_CB]); + setregs(); + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, s),Osbpp),l); + GONext(); + ENDOp(); + + /* cut_e */ + Op(traced_cut_e, s); + EMIT_ENTRY_BLOCK(PREG,CUT_E_INSTINIT); +#ifdef COROUTINING + EMIT_SIMPLE_BLOCK_TEST(CUT_E_COROUTINING); + if (FALSE) { + CACHE_Y_AS_ENV(YREG); + EMIT_SIMPLE_BLOCK_TEST(NoStackCutE_Exception); + check_stack(NoStackCutE, HR); + ENDCACHE_Y_AS_ENV(); + } +#endif + EMIT_SIMPLE_BLOCK_TEST(CUT_E_NOCOROUTINING); + SET_ASP(YREG, PREG->u.s.s); + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, s),Osbpp),l); + saveregs(); + prune((choiceptr)SREG[E_CB]); + setregs(); + GONext(); + ENDOp(); + + /* save_b_x Xi */ + Op(traced_save_b_x, x); + EMIT_ENTRY_BLOCK(PREG,SAVE_B_X_INSTINIT); + BEGD(d0); + d0 = PREG->u.x.x; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + EMIT_SIMPLE_BLOCK_TEST(SAVE_B_X_YSBA_FROZEN); + XREG(d0) = MkIntegerTerm((Int)B); +#else + EMIT_SIMPLE_BLOCK_TEST(SAVE_B_X_NOYSBA_NOFROZEN); + XREG(d0) = MkIntegerTerm(LCL0-(CELL *) (B)); +#endif /* YAPOR_SBA && FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK_TEST(SAVE_B_X_END); + PREG = NEXTOP(PREG, x); + ENDD(d0); + GONext(); + ENDOp(); + + /* save_b_y Yi */ + Op(traced_save_b_y, y); + EMIT_ENTRY_BLOCK(PREG,SAVE_B_Y_INSTINIT); +#if defined(YAPOR_SBA) + EMIT_SIMPLE_BLOCK_TEST(SAVE_B_Y_YSBA); + INITIALIZE_PERMVAR(YREG+PREG->u.y.y,MkIntegerTerm((Int)B)); +#else + EMIT_SIMPLE_BLOCK_TEST(SAVE_B_Y_NOYSBA); + INITIALIZE_PERMVAR(YREG+PREG->u.y.y,MkIntegerTerm(LCL0-(CELL *)(B))); +#endif /* YAPOR_SBA*/ + EMIT_SIMPLE_BLOCK_TEST(SAVE_B_Y_END); + PREG = NEXTOP(PREG, y); + GONext(); + ENDOp(); + + /* commit_b_x Xi */ + Op(traced_commit_b_x, xps); + EMIT_ENTRY_BLOCK(PREG,COMMIT_B_X_INSTINIT); +#ifdef COROUTINING + CACHE_Y_AS_ENV(YREG); + EMIT_SIMPLE_BLOCK_TEST(NoStackCommitX_Exception); + check_stack(NoStackCommitX, HR); + ENDCACHE_Y_AS_ENV(); +#endif + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_X_DO_COMMIT_B_X); + BEGD(d0); + d0 = XREG(PREG->u.xps.x); + profiled_deref_head_TEST(d0, traced_commit_b_x_unk); + traced_commit_b_x_nvar: + /* skip a void call and a label */ + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_X_COMMIT_B_X_NVAR); + SET_ASP(YREG, PREG->u.xps.s); + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xps),Osbpp),l); + { + choiceptr pt0; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_X_YSBA_FROZEN); + pt0 = (choiceptr)IntegerOfTerm(d0); +#else + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_X_NOYSBA_NOFROZEN); + pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0)); +#endif /* YAPOR_SBA && FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_X_POST_YSBA_FROZEN); + saveregs(); + prune(pt0); + setregs(); + } + GONext(); + + BEGP(pt1); + profiled_deref_body(d0, pt1, traced_commit_b_x_unk, traced_commit_b_x_nvar); + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_X_END); + ENDP(pt1); + /* never cut to a variable */ + /* Abort */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + /* commit_b_y Yi */ + Op(traced_commit_b_y, yps); + EMIT_ENTRY_BLOCK(PREG,COMMIT_B_Y_INSTINIT); +#ifdef COROUTINING + CACHE_Y_AS_ENV(YREG); + EMIT_SIMPLE_BLOCK_TEST(NoStackCommitY_Exception); + check_stack(NoStackCommitY, HR); + ENDCACHE_Y_AS_ENV(); +#endif + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_Y_DO_COMMIT_B_Y); + BEGD(d0); + d0 = YREG[PREG->u.yps.y]; + profiled_deref_head_TEST(d0, traced_commit_b_y_unk); + traced_commit_b_y_nvar: + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_Y_COMMIT_B_Y_NVAR); + SET_ASP(YREG, PREG->u.yps.s); + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yps),Osbpp),l); + { + choiceptr pt0; +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_Y_YSBA_FROZEN); + pt0 = (choiceptr)IntegerOfTerm(d0); +#else + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_Y_NOYSBA_NOFROZEN); + pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0)); +#endif + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_Y_POST_YSBA_FROZEN); + saveregs(); + prune(pt0); + setregs(); + } + GONext(); + + BEGP(pt1); + profiled_deref_body(d0, pt1, traced_commit_b_y_unk, traced_commit_b_y_nvar); + EMIT_SIMPLE_BLOCK_TEST(COMMIT_B_Y_END); + ENDP(pt1); + /* never cut to a variable */ + /* Abort */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + +/************************************************************************* +* Call / Proceed instructions * +*************************************************************************/ + +/* Macros for stack trimming */ + + /* execute Label */ + BOp(traced_execute, pp); + { + EMIT_ENTRY_BLOCK(PREG,EXECUTE_INSTINIT); + PredEntry *pt0; + CACHE_Y_AS_ENV(YREG); + pt0 = PREG->u.pp.p; +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_LOW_LEVEL_TRACER); + low_level_trace(enter_pred,pt0,XREGS+1); + } +#endif /* LOW_LEVEL_TRACE */ + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_POST_LOW_LEVEL_TRACER); + CACHE_A1(); + ALWAYS_LOOKAHEAD(pt0->OpcodeOfPred); + BEGD(d0); + d0 = (CELL)B; +#ifndef NO_CHECKING + EMIT_SIMPLE_BLOCK_TEST(NoStackExecute_Exception); + check_stack(NoStackExecute, HR); +#endif + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_POST_NOCHECKING); + PREG = pt0->CodeOfPred; + /* for profiler */ + save_pc(); + ENV_YREG[E_CB] = d0; + ENDD(d0); +#ifdef DEPTH_LIMIT + if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is prolog */ + EMIT_CONDITIONAL_SUCCESS("DEPTH <= MkIntTerm(1)"); + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_DEPTH_MINOR); + if (pt0->ModuleOfPred) { + if (DEPTH == MkIntTerm(0)) { + TRACED_FAIL(); + } + else { + DEPTH = RESET_DEPTH(); + } + } + } else if (pt0->ModuleOfPred) { + EMIT_CONDITIONAL_FAIL("DEPTH <= MkIntTerm(1)"); + EMIT_CONDITIONAL_SUCCESS("pt0->ModuleOfPred"); + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_DEPTH_MOFPRED); + DEPTH -= MkIntConstant(2); + } + else { + EMIT_CONDITIONAL_FAIL("DEPTH <= MkIntTerm(1)"); + EMIT_CONDITIONAL_FAIL("pt0->ModuleOfPred"); + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_DEPTH_END); + } +#endif /* DEPTH_LIMIT */ + /* this is the equivalent to setting up the stack */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(EXECUTE_END_END); + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + ENDCACHE_Y_AS_ENV(); + } + ENDBOp(); + + /*NoStackExecute: + CHECK_ALARM(JMPNext()); + SREG = (CELL *) PREG->u.pp.p; + PP = PREG->u.pp.p0; + if (LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) { + SET_ASP(YREG, E_CB*sizeof(CELL)); + SREG = YENV; + goto noheapleft; + } + if (LOCAL_ActiveSignals) + goto creep; + else + goto NoStackExec;*/ + + /* dexecute Label */ + /* joint deallocate and execute */ + BOp(traced_dexecute, pp); + EMIT_ENTRY_BLOCK(PREG,DEXECUTE_INSTINIT); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(DEXECUTE_LOW_LEVEL_TRACER); + low_level_trace(enter_pred,PREG->u.pp.p,XREGS+1); + } +#endif /* LOW_LEVEL_TRACER */ + EMIT_SIMPLE_BLOCK_TEST(DEXECUTE_POST_LOW_LEVEL_TRACER); + CACHE_Y_AS_ENV(YREG); + { + PredEntry *pt0; + + CACHE_A1(); + pt0 = PREG->u.pp.p; +#ifndef NO_CHECKING + /* check stacks */ + EMIT_SIMPLE_BLOCK_TEST(NoStackDExecute_Exception); + check_stack(NoStackDExecute, HR); +#endif +#ifdef DEPTH_LIMIT + if (DEPTH <= MkIntTerm(1)) { /* I assume Module==0 is primitives */ + EMIT_CONDITIONAL_SUCCESS("DEPTH <= MkIntTerm(1)"); + EMIT_SIMPLE_BLOCK_TEST(DEXECUTE_DEPTH_MINOR); + if (pt0->ModuleOfPred) { + if (DEPTH == MkIntTerm(0)) { + TRACED_FAIL(); + } + else { + DEPTH = RESET_DEPTH(); + } + } + } else if (pt0->ModuleOfPred) { + EMIT_CONDITIONAL_FAIL("DEPTH <= MkIntTerm(1)"); + EMIT_CONDITIONAL_SUCCESS("pt0->ModuleOfPred"); + EMIT_SIMPLE_BLOCK_TEST(DEXECUTE_DEPTH_MOFPRED); + DEPTH -= MkIntConstant(2); + } + else { + EMIT_CONDITIONAL_FAIL("DEPTH <= MkIntTerm(1)"); + EMIT_CONDITIONAL_FAIL("pt0->ModuleOfPred"); + EMIT_SIMPLE_BLOCK_TEST(DEXECUTE_DEPTH_END); + } +#endif /* DEPTH_LIMIT */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(DEXECUTE_END_END); + PREG = pt0->CodeOfPred; + /* for profiler */ + save_pc(); + ALWAYS_LOOKAHEAD(pt0->OpcodeOfPred); + /* do deallocate */ + CPREG = (yamop *) ENV_YREG[E_CP]; + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; +#ifdef FROZEN_STACKS + { + choiceptr top_b = PROTECT_FROZEN_B(B); +#ifdef YAPOR_SBA + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { + ENV_YREG = (CELL *) top_b; + } +#else + if (ENV_YREG > (CELL *) top_b) { + ENV_YREG = (CELL *) top_b; + } +#endif /* YAPOR_SBA */ + else { + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size(CPREG)); + } + } +#else + if (ENV_YREG > (CELL *)B) { + ENV_YREG = (CELL *)B; + } + else { + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size(CPREG)); + } +#endif /* FROZEN_STACKS */ + WRITEBACK_Y_AS_ENV(); + /* setup GB */ + ENV_YREG[E_CB] = (CELL) B; + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + } + ENDCACHE_Y_AS_ENV(); + ENDBOp(); + + BOp(traced_fcall, Osbpp); + CACHE_Y_AS_ENV(YREG); + ENV_YREG[E_CP] = (CELL) CPREG; + ENV_YREG[E_E] = (CELL) ENV; +#ifdef DEPTH_LIMIT + ENV_YREG[E_DEPTH] = DEPTH; +#endif /* DEPTH_LIMIT */ + ENDCACHE_Y_AS_ENV(); + ENDBOp(); + + BOp(traced_call, Osbpp); + EMIT_ENTRY_BLOCK(PREG,CALL_INSTINIT); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(CALL_LOW_LEVEL_TRACER); + low_level_trace(enter_pred,PREG->u.Osbpp.p,XREGS+1); + } +#endif /* LOW_LEVEL_TRACER */ + EMIT_SIMPLE_BLOCK_TEST(CALL_POST_LOW_LEVEL_TRACER); + CACHE_Y_AS_ENV(YREG); + { + PredEntry *pt; + pt = PREG->u.Osbpp.p; + CACHE_A1(); +#ifndef NO_CHECKING + EMIT_SIMPLE_BLOCK_TEST(NoStackCall_Exception); + check_stack(NoStackCall, HR); +#endif + EMIT_SIMPLE_BLOCK_TEST(CALL_POST_NO_CHECKING); + ENV = ENV_YREG; + /* Try to preserve the environment */ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + PREG->u.Osbpp.s); + CPREG = NEXTOP(PREG, Osbpp); + ALWAYS_LOOKAHEAD(pt->OpcodeOfPred); + PREG = pt->CodeOfPred; + /* for profiler */ + save_pc(); +#ifdef DEPTH_LIMIT + if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is primitives */ + EMIT_CONDITIONAL_SUCCESS("DEPTH <= MkIntTerm(1)"); + EMIT_SIMPLE_BLOCK_TEST(CALL_DEPTH_MINOR); + if (pt->ModuleOfPred) { + if (DEPTH == MkIntTerm(0)){ + TRACED_FAIL(); + } else { + DEPTH = RESET_DEPTH(); + } + } + } else if (pt->ModuleOfPred) { + EMIT_CONDITIONAL_FAIL("DEPTH <= MkIntTerm(1)"); + EMIT_CONDITIONAL_SUCCESS("pt->ModuleOfPred"); + EMIT_SIMPLE_BLOCK_TEST(CALL_DEPTH_MOFPRED); + DEPTH -= MkIntConstant(2); + } + else { + EMIT_CONDITIONAL_FAIL("DEPTH <= MkIntTerm(1)"); + EMIT_CONDITIONAL_FAIL("pt->ModuleOfPred"); + EMIT_SIMPLE_BLOCK_TEST(CALL_DEPTH_END); + } +#endif /* DEPTH_LIMIT */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_END_END); +#ifdef FROZEN_STACKS + { + choiceptr top_b = PROTECT_FROZEN_B(B); +#ifdef YAPOR_SBA + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { + ENV_YREG = (CELL *) top_b; + } +#else + if (ENV_YREG > (CELL *) top_b) { + ENV_YREG = (CELL *) top_b; + } +#endif /* YAPOR_SBA */ + } +#else + if (ENV_YREG > (CELL *) B) { + ENV_YREG = (CELL *) B; + } +#endif /* FROZEN_STACKS */ + WRITEBACK_Y_AS_ENV(); + /* setup GB */ + ENV_YREG[E_CB] = (CELL) B; +#ifdef YAPOR + SCH_check_requests(); +#endif /* YAPOR */ + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + } + ENDCACHE_Y_AS_ENV(); + ENDBOp(); + + BOp(traced_procceed, p); + EMIT_ENTRY_BLOCK(PREG,PROCCEED_INSTINIT); + CACHE_Y_AS_ENV(YREG); + ALWAYS_LOOKAHEAD(CPREG->opc); + PREG = CPREG; + /* for profiler */ + save_pc(); + ENV_YREG = ENV; +#ifdef DEPTH_LIMIT + EMIT_SIMPLE_BLOCK_TEST(PROCCEED_DEPTH); + DEPTH = ENV_YREG[E_DEPTH]; +#endif + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(PROCCEED_END); + WRITEBACK_Y_AS_ENV(); + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + ENDCACHE_Y_AS_ENV(); + ENDBOp(); + + Op(traced_allocate, e); + EMIT_ENTRY_BLOCK(PREG,ALLOCATE_INSTINIT); + CACHE_Y_AS_ENV(YREG); + PREG = NEXTOP(PREG, e); + ENV_YREG[E_CP] = (CELL) CPREG; + ENV_YREG[E_E] = (CELL) ENV; +#ifdef DEPTH_LIMIT + EMIT_SIMPLE_BLOCK_TEST(ALLOCATE_DEPTH); + ENV_YREG[E_DEPTH] = DEPTH; +#endif /* DEPTH_LIMIT */ + EMIT_SIMPLE_BLOCK_TEST(ALLOCATE_END); + ENV = ENV_YREG; + ENDCACHE_Y_AS_ENV(); + GONext(); + ENDOp(); + + Op(traced_deallocate, p); + EMIT_ENTRY_BLOCK(PREG,DEALLOCATE_INSTINIT); + EMIT_SIMPLE_BLOCK_TEST(YAAM_CHECK_TRAIL_TR); + check_trail(TR); + EMIT_SIMPLE_BLOCK_TEST(DEALLOCATE_POST_CHECK); + CACHE_Y_AS_ENV(YREG); + PREG = NEXTOP(PREG, p); + /* other instructions do depend on S being set by deallocate + :-( */ + SREG = YREG; + CPREG = (yamop *) ENV_YREG[E_CP]; + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; +#ifdef DEPTH_LIMIT + EMIT_SIMPLE_BLOCK_TEST(DEALLOCATE_DEPTH); + DEPTH = ENV_YREG[E_DEPTH]; +#endif /* DEPTH_LIMIT */ + EMIT_SIMPLE_BLOCK_TEST(DEALLOCATE_FROZEN); +#ifdef FROZEN_STACKS + { + choiceptr top_b = PROTECT_FROZEN_B(B); +#ifdef YAPOR_SBA + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) + ENV_YREG = (CELL *) top_b; +#else + if (ENV_YREG > (CELL *) top_b) + ENV_YREG = (CELL *) top_b; +#endif /* YAPOR_SBA */ + else + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size(CPREG)); + } +#else + if (ENV_YREG > (CELL *) B) + ENV_YREG = (CELL *) B; + else + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size(CPREG)); +#endif /* FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK_TEST(DEALLOCATE_POST_FROZEN); + WRITEBACK_Y_AS_ENV(); +#ifndef NO_CHECKING + /* check stacks */ + EMIT_SIMPLE_BLOCK_TEST(NoStackDeallocate_Exception); + check_stack(NoStackDeallocate, HR); +#endif + EMIT_SIMPLE_BLOCK_TEST(DEALLOCATE_END); + ENDCACHE_Y_AS_ENV(); + GONext(); + ENDOp(); + +/********************************************** +* OPTYap instructions * +**********************************************/ + +#ifdef YAPOR + traced_getwork_first_time: + traced_getwork: + traced_getwork_seq: + traced_sync: +#endif /* YAPOR */ +#ifdef TABLING +#ifdef TABLING_INNER_CUTS + traced_clause_with_cut: +#endif + traced_table_load_answer: + traced_table_try_answer: + traced_table_try_single: + traced_table_try_me: + traced_table_try: + traced_table_retry_me: + traced_table_retry: + traced_table_trust_me: + traced_table_trust: + traced_table_new_answer: + traced_table_answer_resolution: + traced_table_completion: +#ifdef THREADS_CONSUMER_SHARING + traced_table_answer_resolution_completion: +#endif + traced_trie_do_var: + traced_trie_trust_var: + traced_trie_try_var: + traced_trie_retry_var: + traced_trie_do_var_in_pair: + traced_trie_trust_var_in_pair: + traced_trie_try_var_in_pair: + traced_trie_retry_var_in_pair: + traced_trie_do_val: + traced_trie_trust_val: + traced_trie_try_val: + traced_trie_retry_val: + traced_trie_do_val_in_pair: + traced_trie_trust_val_in_pair: + traced_trie_try_val_in_pair: + traced_trie_retry_val_in_pair: + traced_trie_do_atom: + traced_trie_trust_atom: + traced_trie_try_atom: + traced_trie_retry_atom: + traced_trie_do_atom_in_pair: + traced_trie_trust_atom_in_pair: + traced_trie_try_atom_in_pair: + traced_trie_retry_atom_in_pair: + traced_trie_do_null: + traced_trie_trust_null: + traced_trie_try_null: + traced_trie_retry_null: + traced_trie_do_null_in_pair: + traced_trie_trust_null_in_pair: + traced_trie_try_null_in_pair: + traced_trie_retry_null_in_pair: + traced_trie_do_pair: + traced_trie_trust_pair: + traced_trie_try_pair: + traced_trie_retry_pair: + traced_trie_do_appl: + traced_trie_trust_appl: + traced_trie_try_appl: + traced_trie_retry_appl: + traced_trie_do_appl_in_pair: + traced_trie_trust_appl_in_pair: + traced_trie_try_appl_in_pair: + traced_trie_retry_appl_in_pair: + traced_trie_do_extension: + traced_trie_trust_extension: + traced_trie_try_extension: + traced_trie_retry_extension: + traced_trie_do_double: + traced_trie_trust_double: + traced_trie_try_double: + traced_trie_retry_double: + traced_trie_do_longint: + traced_trie_trust_longint: + traced_trie_try_longint: + traced_trie_retry_longint: + traced_trie_do_gterm: + traced_trie_trust_gterm: + traced_trie_try_gterm: + traced_trie_retry_gterm: + { printf("Não era pra chegar aqui!!\n"); exit(1); } +#endif /* TABLING */ + + + +#ifdef BEAM + extern int eam_am(PredEntry *); + + Op(traced_retry_eam, e); + goto retry_eam; + ENDOp(); + + Op(traced_run_eam, os); + goto run_eam; + ENDOp(); +#endif + +/************************************************************************\ +* Get Instructions * +\************************************************************************/ + + Op(traced_get_x_var, xx); + EMIT_ENTRY_BLOCK(PREG,GET_X_VAR_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xx.xr); + XREG(PREG->u.xx.xl) = d0; + PREG = NEXTOP(PREG, xx); + ENDD(d0); + GONext(); + ENDOp(); + + Op(traced_get_y_var, yx); + EMIT_ENTRY_BLOCK(PREG,GET_Y_VAR_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yx.y; + d0 = XREG(PREG->u.yx.x); + PREG = NEXTOP(PREG, yx); + INITIALIZE_PERMVAR(pt0,d0); + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_get_yy_var, yyxx); + EMIT_ENTRY_BLOCK(PREG,GET_YY_VAR_INSTINIT); + CACHE_Y(YREG); + BEGD(d0); + BEGP(pt0); + pt0 = S_YREG + PREG->u.yyxx.y1; + d0 = XREG(PREG->u.yyxx.x1); + BEGD(d1); + BEGP(pt1); + pt1 = S_YREG + PREG->u.yyx.y2; + d1 = XREG(PREG->u.yyxx.x2); + PREG = NEXTOP(PREG, yyxx); + INITIALIZE_PERMVAR(pt0,d0); + INITIALIZE_PERMVAR(pt1,d1); + ENDP(pt1); + ENDD(d1); + GONext(); + ENDP(pt0); + ENDD(d0); + ENDCACHE_Y(); + ENDOp(); + + /* The code for get_x_val is hard to follow because I use a + * lot of jumps. The convention is that in the label + * gval_X_YREG X refers to the state of the first argument, and + * YREG to the state of the second argument */ + Op(traced_get_x_val, xx); + EMIT_ENTRY_BLOCK(PREG,GET_X_VAL_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xx.xl); + profiled_deref_head_TEST(d0, traced_gvalx_unk); + + /* d0 will keep the first argument */ + traced_gvalx_nonvar: + /* first argument is bound */ + EMIT_SIMPLE_BLOCK_TEST(GET_X_VAL_GVALX_NONVAR); + BEGD(d1); + d1 = XREG(PREG->u.xx.xr); + profiled_deref_head_TEST(d1, traced_gvalx_nonvar_unk); + + traced_gvalx_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_X_VAL_GVALX_NONVAR_NONVAR); + PREG = NEXTOP(PREG, xx); + traced_UnifyBound(d0, d1); + + BEGP(pt0); + /* deref second argument */ + profiled_deref_body(d1, pt0, traced_gvalx_nonvar_unk, traced_gvalx_nonvar_nonvar); + /* first argument bound, second unbound */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_X_VAL_GVALX_NONVAR_UNK); + PREG = NEXTOP(PREG, xx); + Bind(pt0, d0); + GONext(); + + ENDP(pt0); + ENDD(d1); + + BEGP(pt0); + /* first argument may be unbound */ + profiled_deref_body(d0, pt0, traced_gvalx_unk, traced_gvalx_nonvar); + /* first argument is unbound and in pt0 and in d0 */ + EMIT_SIMPLE_BLOCK_TEST(GET_X_VAL_GVALX_UNK); + BEGD(d1); + d1 = XREG(PREG->u.xx.xr); + profiled_deref_head_TEST(d1, traced_gvalx_var_unk); + + traced_gvalx_var_nonvar: + /* first unbound, second bound */ + EMIT_SIMPLE_BLOCK_TEST(GET_X_VAL_GVALX_VAR_NONVAR); + PREG = NEXTOP(PREG, xx); + Bind(pt0, d1); + GONext(); + + BEGP(pt1); + profiled_deref_body(d1, pt1, traced_gvalx_var_unk, traced_gvalx_var_nonvar); + /* both arguments are unbound */ + EMIT_SIMPLE_BLOCK_TEST(GET_X_VAL_GVALX_VAR_UNK); + PREG = NEXTOP(PREG, xx); + UnifyCells(pt0, pt1); + GONext(); + ENDP(pt1); + ENDD(d1); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + /* The code for get_y_val mostly uses the code for get_x_val + */ + + Op(traced_get_y_val, yx); + EMIT_ENTRY_BLOCK(PREG,GET_Y_VAL_INSTINIT); + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = YREG + PREG->u.yx.y; + d0 = *pt0; + + /* From now on, it's just a copy of the code for get_x_val */ + profiled_deref_head_TEST(d0, traced_gvaly_unk); + traced_gvaly_nonvar: + + /* first argument is bound */ + EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_NONVAR); + d1 = XREG(PREG->u.yx.x); + profiled_deref_head_TEST(d1, traced_gvaly_nonvar_unk); + + traced_gvaly_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_Y_VAL_GVALY_NONVAR_NONVAR); + PREG = NEXTOP(PREG, yx); + traced_UnifyBound(d0, d1); + + BEGP(pt1); + /* deref second argument */ + profiled_deref_body(d1, pt1, traced_gvaly_nonvar_unk, traced_gvaly_nonvar_nonvar); + /* first argument bound, second unbound */ + EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_NONVAR_UNK); + PREG = NEXTOP(PREG, yx); + Bind(pt1, d0); + GONext(); + ENDP(pt1); + + /* first argument may be unbound */ + profiled_derefa_body(d0, pt0, traced_gvaly_unk, traced_gvaly_nonvar); + /* first argument is unbound */ + EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_UNK); + d1 = XREG(PREG->u.yx.x); + profiled_deref_head_TEST(d1, traced_gvaly_var_unk); + traced_gvaly_var_nonvar: + /* first unbound, second bound */ + EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_VAR_NONVAR); + PREG = NEXTOP(PREG, yx); + Bind(pt0, d1); + GONext(); + + BEGP(pt1); + profiled_deref_body(d1, pt1, traced_gvaly_var_unk, traced_gvaly_var_nonvar); + /* both arguments are unbound */ + EMIT_SIMPLE_BLOCK_TEST(GET_Y_VAL_GVALY_VAR_UNK); + PREG = NEXTOP(PREG, yx); + UnifyCells(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_get_atom, xc); + EMIT_ENTRY_BLOCK(PREG,GET_ATOM_INSTINIT); + BEGD(d0); + BEGD(d1); + /* fetch arguments */ + d0 = XREG(PREG->u.xc.x); + d1 = PREG->u.xc.c; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_unk); + /* argument is nonvar */ + traced_gatom_nonvar: + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_ATOM_GATOM_NONVAR); + if (d0 == d1) { + PREG = NEXTOP(PREG, xc); + GONext(); + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_unk, traced_gatom_nonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_ATOM_GATOM_UNK); + PREG = NEXTOP(PREG, xc); + Bind(pt0, d1); + GONext(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_get_2atoms, cc); + EMIT_ENTRY_BLOCK(PREG,GET_2ATOMS_INSTINIT); + BEGD(d0); + BEGD(d1); + /* fetch arguments */ + d0 = ARG1; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_2unk); + /* argument is nonvar */ + traced_gatom_2nonvar: + if (d0 == PREG->u.cc.c1) { + goto traced_gatom_2b; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_2unk, traced_gatom_2nonvar); + EMIT_SIMPLE_BLOCK_TEST(GET_2ATOMS_GATOM_2UNK); + Bind(pt0, PREG->u.cc.c1); + ENDP(pt0); + traced_gatom_2b: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_2ATOMS_GATOM_2B); + d0 = ARG2; + d1 = PREG->u.cc.c2; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_2bunk); + /* argument is nonvar */ + traced_gatom_2bnonvar: + EMIT_SIMPLE_BLOCK_TEST(GET_2ATOMS_GATOM_2BNONVAR); + if (d0 == d1) { + PREG = NEXTOP(PREG, cc); + GONext(); + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_2bunk, traced_gatom_2bnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_2ATOMS_GATOM_2BUNK); + PREG = NEXTOP(PREG, cc); + Bind(pt0, d1); + GONext(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_get_3atoms, ccc); + EMIT_ENTRY_BLOCK(PREG,GET_3ATOMS_INSTINIT); + BEGD(d0); + BEGD(d1); + /* fetch arguments */ + d0 = ARG1; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_3unk); + /* argument is nonvar */ + traced_gatom_3nonvar: + if (d0 == PREG->u.ccc.c1) { + goto traced_gatom_3b; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_3unk, traced_gatom_3nonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3UNK); + Bind(pt0, PREG->u.ccc.c1); + ENDP(pt0); + traced_gatom_3b: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3B); + d0 = ARG2; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_3bunk); + /* argument is nonvar */ + traced_gatom_3bnonvar: + if (d0 == PREG->u.ccc.c2) { + goto traced_gatom_3c; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_3bunk, traced_gatom_3bnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3BUNK); + Bind(pt0, PREG->u.ccc.c2); + ENDP(pt0); + traced_gatom_3c: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3C); + d0 = ARG3; + d1 = PREG->u.ccc.c3; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_3cunk); + /* argument is nonvar */ + traced_gatom_3cnonvar: + EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3CNONVAR); + if (d0 == d1) { + PREG = NEXTOP(PREG, ccc); + GONext(); + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_3cunk, traced_gatom_3cnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_3ATOMS_GATOM_3CUNK); + PREG = NEXTOP(PREG, ccc); + Bind(pt0, d1); + GONext(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_get_4atoms, cccc); + EMIT_ENTRY_BLOCK(PREG,GET_4ATOMS_INSTINIT); + BEGD(d0); + BEGD(d1); + /* fetch arguments */ + d0 = ARG1; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_4unk); + /* argument is nonvar */ + traced_gatom_4nonvar: + if (d0 == PREG->u.cccc.c1) { + goto traced_gatom_4b; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_4unk, traced_gatom_4nonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4UNK); + Bind(pt0, PREG->u.cccc.c1); + ENDP(pt0); + traced_gatom_4b: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4B); + d0 = ARG2; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_4bunk); + /* argument is nonvar */ + traced_gatom_4bnonvar: + if (d0 == PREG->u.cccc.c2) { + goto traced_gatom_4c; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_4bunk, traced_gatom_4bnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4BUNK); + Bind(pt0, PREG->u.cccc.c2); + ENDP(pt0); + traced_gatom_4c: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4C); + d0 = ARG3; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_4cunk); + /* argument is nonvar */ + traced_gatom_4cnonvar: + if (d0 == PREG->u.cccc.c3) { + goto traced_gatom_4d; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_4cunk, traced_gatom_4cnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4CUNK); + Bind(pt0, PREG->u.cccc.c3); + ENDP(pt0); + traced_gatom_4d: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4D); + d0 = ARG4; + d1 = PREG->u.cccc.c4; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_4dunk); + /* argument is nonvar */ + traced_gatom_4dnonvar: + EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4DNONVAR); + if (d0 == d1) { + PREG = NEXTOP(PREG, cccc); + GONext(); + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_4dunk, traced_gatom_4dnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_4ATOMS_GATOM_4DUNK); + PREG = NEXTOP(PREG, cccc); + Bind(pt0, d1); + GONext(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_get_5atoms, ccccc); + EMIT_ENTRY_BLOCK(PREG,GET_5ATOMS_INSTINIT); + BEGD(d0); + BEGD(d1); + /* fetch arguments */ + d0 = ARG1; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_5unk); + /* argument is nonvar */ + traced_gatom_5nonvar: + if (d0 == PREG->u.ccccc.c1) { + goto traced_gatom_5b; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_5unk, traced_gatom_5nonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5UNK); + Bind(pt0, PREG->u.ccccc.c1); + ENDP(pt0); + traced_gatom_5b: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5B); + d0 = ARG2; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_5bunk); + /* argument is nonvar */ + traced_gatom_5bnonvar: + if (d0 == PREG->u.ccccc.c2) { + goto traced_gatom_5c; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_5bunk, traced_gatom_5bnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5BUNK); + Bind(pt0, PREG->u.ccccc.c2); + ENDP(pt0); + traced_gatom_5c: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5C); + d0 = ARG3; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_5cunk); + /* argument is nonvar */ + traced_gatom_5cnonvar: + if (d0 == PREG->u.ccccc.c3) { + goto traced_gatom_5d; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_5cunk, traced_gatom_5cnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5CUNK); + Bind(pt0, PREG->u.ccccc.c3); + ENDP(pt0); + traced_gatom_5d: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5D); + d0 = ARG4; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_5dunk); + /* argument is nonvar */ + traced_gatom_5dnonvar: + if (d0 == PREG->u.ccccc.c4) { + goto traced_gatom_5e; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_5dunk, traced_gatom_5dnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5DUNK); + Bind(pt0, PREG->u.ccccc.c4); + ENDP(pt0); + traced_gatom_5e: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5E); + d0 = ARG5; + d1 = PREG->u.ccccc.c5; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_5eunk); + /* argument is nonvar */ + traced_gatom_5enonvar: + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5ENONVAR); + if (d0 == d1) { + PREG = NEXTOP(PREG, ccccc); + GONext(); + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_5eunk, traced_gatom_5enonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_5ATOMS_GATOM_5EUNK); + PREG = NEXTOP(PREG, ccccc); + Bind(pt0, d1); + GONext(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_get_6atoms, cccccc); + EMIT_ENTRY_BLOCK(PREG,GET_6ATOMS_INSTINIT); + BEGD(d0); + BEGD(d1); + /* fetch arguments */ + d0 = ARG1; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_6unk); + /* argument is nonvar */ + traced_gatom_6nonvar: + if (d0 == PREG->u.cccccc.c1) { + goto traced_gatom_6b; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_6unk, traced_gatom_6nonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6UNK); + Bind(pt0, PREG->u.cccccc.c1); + ENDP(pt0); + traced_gatom_6b: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6B); + d0 = ARG2; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_6bunk); + /* argument is nonvar */ + traced_gatom_6bnonvar: + if (d0 == PREG->u.cccccc.c2) { + goto traced_gatom_6c; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_6bunk, traced_gatom_6bnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6BUNK); + Bind(pt0, PREG->u.cccccc.c2); + ENDP(pt0); + traced_gatom_6c: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6C); + d0 = ARG3; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_6cunk); + /* argument is nonvar */ + traced_gatom_6cnonvar: + if (d0 == PREG->u.cccccc.c3) { + goto traced_gatom_6d; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_6cunk, traced_gatom_6cnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6CUNK); + Bind(pt0, PREG->u.cccccc.c3); + ENDP(pt0); + traced_gatom_6d: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6D); + d0 = ARG4; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_6dunk); + /* argument is nonvar */ + traced_gatom_6dnonvar: + if (d0 == PREG->u.cccccc.c4) { + goto traced_gatom_6e; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_6dunk, traced_gatom_6dnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6DUNK); + Bind(pt0, PREG->u.cccccc.c4); + ENDP(pt0); + traced_gatom_6e: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6E); + d0 = ARG5; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_6eunk); + /* argument is nonvar */ + traced_gatom_6enonvar: + if (d0 == PREG->u.cccccc.c5) { + goto traced_gatom_6f; + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_6eunk, traced_gatom_6enonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6EUNK); + Bind(pt0, PREG->u.cccccc.c5); + ENDP(pt0); + traced_gatom_6f: + /* fetch arguments */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6F); + d0 = ARG6; + d1 = PREG->u.cccccc.c6; + + BEGP(pt0); + profiled_deref_head_TEST(d0, traced_gatom_6funk); + /* argument is nonvar */ + traced_gatom_6fnonvar: + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6FNONVAR); + if (d0 == d1) { + PREG = NEXTOP(PREG, cccccc); + GONext(); + } + else { + TRACED_FAIL(); + } + + profiled_deref_body(d0, pt0, traced_gatom_6funk, traced_gatom_6fnonvar); + /* argument is a variable */ + EMIT_SIMPLE_BLOCK_TEST(GET_6ATOMS_GATOM_6FUNK); + PREG = NEXTOP(PREG, cccccc); + Bind(pt0, d1); + GONext(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + /* The next instructions can lead to either the READ stream + * or the write stream */ + + OpRW(traced_get_list, x); + EMIT_ENTRY_BLOCK(PREG,GET_LIST_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.x.x); + profiled_deref_head_TEST(d0, traced_glist_unk); + + traced_glist_nonvar: + /* did we find a list? */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_LIST_GLIST_NONVAR); + if (!IsPairTerm(d0)) { + TRACED_FAIL(); + } + START_PREFETCH(x); + PREG = NEXTOP(PREG, x); + /* enter read mode */ + SREG = RepPair(d0); + GONext(); + END_PREFETCH(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_glist_unk, traced_glist_nonvar); + /* glist var */ + /* enter write mode */ + EMIT_SIMPLE_BLOCK_TEST(GET_LIST_GLIST_UNK); + CACHE_S(); + S_SREG = HR; + START_PREFETCH_W(x); + PREG = NEXTOP(PREG, x); + BEGD(d0); + d0 = AbsPair(S_SREG); + Bind(pt0, d0); + S_SREG = HR; + /* don't put an ENDD just after a label */ + HR = S_SREG + 2; + ENDD(d0); + WRITEBACK_S(S_SREG); + GONextW(); + + + END_PREFETCH_W(); + ENDCACHE_S(); + ENDP(pt0); + + ENDD(d0); + ENDOpRW(); + + OpRW(traced_get_struct, xfa); + EMIT_ENTRY_BLOCK(PREG,GET_STRUCT_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xfa.x); + profiled_deref_head_TEST(d0, traced_gstruct_unk); + + traced_gstruct_nonvar: + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_STRUCT_GSTRUCT_NONVAR); + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } + /* we have met a compound term */ + START_PREFETCH(xfa); + CACHE_S(); + S_SREG = RepAppl(d0); + /* check functor */ + d0 = (CELL) (PREG->u.xfa.f); + if (*S_SREG != d0) { + TRACED_FAIL(); + } + WRITEBACK_S(S_SREG+1); + ENDCACHE_S(); + PREG = NEXTOP(PREG, xfa); + /* enter read mode */ + GONext(); + END_PREFETCH(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_gstruct_unk, traced_gstruct_nonvar); + /* Enter Write mode */ + /* set d1 to be the new structure we are going to create */ + EMIT_SIMPLE_BLOCK_TEST(GET_STRUCT_GSTRUCT_UNK); + START_PREFETCH_W(xfa); + BEGD(d1); + d1 = AbsAppl(HR); + Bind(pt0, d1); + /* now, set pt0 to point to the heap where we are going to + * build our term */ + pt0 = HR; + ENDD(d1); + /* first, put the functor */ + d0 = (CELL) (PREG->u.xfa.f); + *pt0++ = d0; + HR = pt0 + PREG->u.xfa.a; + PREG = NEXTOP(PREG, xfa); + /* set SREG */ + SREG = pt0; + /* update HR */ + GONextW(); + END_PREFETCH_W(); + ENDP(pt0); + + ENDD(d0); + ENDOpRW(); + + Op(traced_get_float, xd); + EMIT_ENTRY_BLOCK(PREG,GET_FLOAT_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xd.x); + profiled_deref_head_TEST(d0, traced_gfloat_unk); + + traced_gfloat_nonvar: + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_FLOAT_GFLOAT_NONVAR); + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } + /* we have met a preexisting float */ + START_PREFETCH(xd); + BEGP(pt0); + pt0 = RepAppl(d0); + /* check functor */ + if (*pt0 != (CELL)FunctorDouble) { + TRACED_FAIL(); + } + BEGP(pt1); + pt1 = PREG->u.xd.d; + PREG = NEXTOP(PREG, xd); + if ( + pt1[1] != pt0[1] +#if SIZEOF_DOUBLE == 2*SIZEOF_INT_P + || pt1[2] != pt0[2] +#endif + ) { + TRACED_FAIL(); + } + ENDP(pt1); + ENDP(pt0); + /* enter read mode */ + GONext(); + END_PREFETCH(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_gfloat_unk, traced_gfloat_nonvar); + /* Enter Write mode */ + /* set d1 to be the new structure we are going to create */ + EMIT_SIMPLE_BLOCK_TEST(GET_FLOAT_GFLOAT_UNK); + START_PREFETCH(xc); + BEGD(d1); + d1 = AbsAppl(PREG->u.xd.d); + PREG = NEXTOP(PREG, xd); + Bind(pt0, d1); + GONext(); + ENDD(d1); + END_PREFETCH(); + ENDP(pt0); + + ENDD(d0); + ENDOp(); + + Op(traced_get_longint, xi); + EMIT_ENTRY_BLOCK(PREG,GET_LONGINT_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xi.x); + profiled_deref_head_TEST(d0, traced_glongint_unk); + + traced_glongint_nonvar: + EMIT_SIMPLE_BLOCK_TEST(GET_LONGINT_GLONGINT_NONVAR); + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } + /* we have met a preexisting longint */ + START_PREFETCH(xi); + BEGP(pt0); + pt0 = RepAppl(d0); + /* check functor */ + if (*pt0 != (CELL)FunctorLongInt) { + TRACED_FAIL(); + } + if (PREG->u.xi.i[1] != (CELL)pt0[1]) { + TRACED_FAIL(); + } + ENDP(pt0); + PREG = NEXTOP(PREG, xi); + /* enter read mode */ + GONext(); + END_PREFETCH(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_glongint_unk, traced_glongint_nonvar); + /* Enter Write mode */ + /* set d1 to be the new structure we are going to create */ + EMIT_SIMPLE_BLOCK_TEST(GET_LONGINT_GLONGINT_UNK); + START_PREFETCH(xi); + BEGD(d1); + d1 = AbsAppl(PREG->u.xi.i); + PREG = NEXTOP(PREG, xi); + Bind(pt0, d1); + GONext(); + ENDD(d1); + END_PREFETCH(); + ENDP(pt0); + + ENDD(d0); + ENDOp(); + + Op(traced_get_bigint, xN); +#ifdef USE_GMP + EMIT_ENTRY_BLOCK(PREG,GET_BIGINT_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xN.x); + profiled_deref_head_TEST(d0, traced_gbigint_unk); + + traced_gbigint_nonvar: + EMIT_SIMPLE_BLOCK_TEST(GET_BIGINT_GBIGINT_NONVAR); + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } + /* we have met a preexisting bigint */ + START_PREFETCH(xN); + BEGP(pt0); + pt0 = RepAppl(d0); + /* check functor */ + if (*pt0 != (CELL)FunctorBigInt) + { + TRACED_FAIL(); + } + if (Yap_gmp_tcmp_big_big(d0,PREG->u.xN.b)) { + TRACED_FAIL(); + } + PREG = NEXTOP(PREG, xN); + ENDP(pt0); + /* enter read mode */ + GONext(); + END_PREFETCH(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_gbigint_unk, traced_gbigint_nonvar); + /* Enter Write mode */ + /* set d1 to be the new structure we are going to create */ + EMIT_SIMPLE_BLOCK_TEST(GET_BIGINT_GBIGINT_UNK); + START_PREFETCH(xN); + BEGD(d1); + d1 = PREG->u.xN.b; + PREG = NEXTOP(PREG, xN); + Bind(pt0, d1); + GONext(); + ENDD(d1); + END_PREFETCH(); + ENDP(pt0); + + ENDD(d0); +#else + TRACED_FAIL(); +#endif + ENDOp(); + + + Op(traced_get_dbterm, xD); + EMIT_ENTRY_BLOCK(PREG,GET_DBTERM_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xD.x); + profiled_deref_head_TEST(d0, traced_gdbterm_unk); + + traced_gdbterm_nonvar: + BEGD(d1); + /* we have met a preexisting dbterm */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GET_DBTERM_GDBTERM_NONVAR); + d1 = PREG->u.xD.D; + PREG = NEXTOP(PREG, xD); + traced_UnifyBound(d0,d1); + ENDD(d1); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_gdbterm_unk, traced_gdbterm_nonvar); + /* Enter Write mode */ + /* set d1 to be the new structure we are going to create */ + EMIT_SIMPLE_BLOCK_TEST(GET_DBTERM_GDBTERM_UNK); + START_PREFETCH(xD); + BEGD(d1); + d1 = PREG->u.xD.D; + PREG = NEXTOP(PREG, xD); + Bind(pt0, d1); + GONext(); + ENDD(d1); + END_PREFETCH(); + ENDP(pt0); + + ENDD(d0); + ENDOp(); + +/************************************************************************\ +* Optimised Get List Instructions * +\************************************************************************/ + OpRW(traced_glist_valx, xx); + EMIT_ENTRY_BLOCK(PREG,GLIST_VALX_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xx.xl); + profiled_deref_head_TEST(d0, traced_glist_valx_write); + traced_glist_valx_read: + BEGP(pt0); + /* did we find a list? */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GLIST_VALX_GLIST_VALX_READ); + if (!IsPairTerm(d0)) { + TRACED_FAIL(); + } + /* enter read mode */ + START_PREFETCH(xx); + pt0 = RepPair(d0); + SREG = pt0 + 1; + /* start unification with first argument */ + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_glist_valx_unk); + + /* first argument is in d0 */ + traced_glist_valx_nonvar: + /* first argument is bound */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_NONVAR); + BEGD(d1); + d1 = XREG(PREG->u.xx.xr); + profiled_deref_head_TEST(d1, traced_glist_valx_nonvar_unk); + + traced_glist_valx_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GLIST_VALX_GLIST_VALX_NONVAR_NONVAR); + PREG = NEXTOP(PREG, xx); + traced_UnifyBound(d0, d1); + + BEGP(pt1); + /* deref second argument */ + profiled_deref_body(d1, pt1, traced_glist_valx_nonvar_unk, traced_glist_valx_nonvar_nonvar); + /* head bound, argument unbound */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_NONVAR_UNK); + PREG = NEXTOP(PREG, xx); + Bind(pt1, d0); + GONext(); + ENDP(pt1); + + + ENDD(d1); + + /* head may be unbound */ + profiled_derefa_body(d0, pt0, traced_glist_valx_unk, traced_glist_valx_nonvar); + /* head is unbound, pt0 has the value */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_UNK); + d0 = XREG(PREG->u.xx.xr); + profiled_deref_head_TEST(d0, traced_glist_valx_var_unk); + + traced_glist_valx_var_nonvar: + /* head is unbound, second arg bound */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_VAR_NONVAR); + PREG = NEXTOP(PREG, xx); + Bind_Global(pt0, d0); + GONext(); + + BEGP(pt1); + profiled_deref_body(d0, pt1, traced_glist_valx_var_unk, traced_glist_valx_var_nonvar); + /* head and second argument are unbound */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_VAR_UNK); + PREG = NEXTOP(PREG, xx); + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + END_PREFETCH(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_glist_valx_write, traced_glist_valx_read); + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALX_GLIST_VALX_WRITE); + CACHE_S(); + /* enter write mode */ + S_SREG = HR; + BEGD(d1); + d1 = XREG(PREG->u.xx.xr); + d0 = AbsPair(S_SREG); + S_SREG[0] = d1; + ENDD(d1); + ALWAYS_START_PREFETCH_W(xx); + PREG = NEXTOP(PREG, xx); + HR = S_SREG + 2; + WRITEBACK_S(S_SREG+1); + Bind(pt0, d0); + ALWAYS_GONextW(); + ALWAYS_END_PREFETCH_W(); + ENDCACHE_S(); + ENDP(pt0); + + ENDD(d0); + ENDOpRW(); + + OpRW(traced_glist_valy, yx); + EMIT_ENTRY_BLOCK(PREG,GLIST_VALY_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.yx.x); + profiled_deref_head_TEST(d0, traced_glist_valy_write); + traced_glist_valy_read: + BEGP(pt0); + /* did we find a list? */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_READ); + if (!IsPairTerm(d0)) { + TRACED_FAIL(); + } + START_PREFETCH(yx); + /* enter read mode */ + pt0 = RepPair(d0); + SREG = pt0 + 1; + /* start unification with first argument */ + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_glist_valy_unk); + + traced_glist_valy_nonvar: + /* first argument is bound */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_NONVAR); + BEGD(d1); + BEGP(pt1); + pt1 = YREG + PREG->u.yx.y; + d1 = *pt1; + PREG = NEXTOP(PREG, yx); + profiled_deref_head_TEST(d1, traced_glist_valy_nonvar_unk); + + traced_glist_valy_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GLIST_VALY_GLIST_VALY_NONVAR_NONVAR); + SREG = pt0 + 1; + traced_UnifyBound(d0, d1); + + /* deref second argument */ + profiled_derefa_body(d1, pt1, traced_glist_valy_nonvar_unk, traced_glist_valy_nonvar_nonvar); + /* first argument bound, second unbound */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_NONVAR_UNK); + Bind(pt1, d0); + GONext(); + + ENDP(pt1); + /* first argument may be unbound */ + profiled_derefa_body(d0, pt0, traced_glist_valy_unk, traced_glist_valy_nonvar); + /* first argument is unbound */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_UNK); + BEGP(pt1); + pt1 = YREG+PREG->u.yx.y; + d1 = *pt1; + profiled_deref_head_TEST(d1, traced_glist_valy_var_unk); + traced_glist_valy_var_nonvar: + /* first unbound, second bound */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_VAR_NONVAR); + PREG = NEXTOP(PREG, yx); + Bind_Global(pt0, d1); + GONext(); + + profiled_derefa_body(d1, pt1, traced_glist_valy_var_unk, traced_glist_valy_var_nonvar); + /* both arguments are unbound */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_VAR_UNK); + PREG = NEXTOP(PREG, yx); + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDD(d1); + + END_PREFETCH(); + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_glist_valy_write, traced_glist_valy_read); + /* enter write mode */ + EMIT_SIMPLE_BLOCK_TEST(GLIST_VALY_GLIST_VALY_WRITE); + START_PREFETCH_W(yx); + BEGP(pt1); + pt1 = HR; + d0 = AbsPair(pt1); + Bind(pt0, d0); + BEGD(d0); + /* include XREG on it */ + d0 = YREG[PREG->u.yx.y]; + pt1[0] = d0; + ENDD(d0); + HR = pt1 + 2; + SREG = pt1 + 1; + ENDP(pt1); + PREG = NEXTOP(PREG, yx); + GONextW(); + END_PREFETCH_W(); + ENDP(pt0); + + ENDD(d0); + ENDOpRW(); + + Op(traced_gl_void_varx, xx); + EMIT_ENTRY_BLOCK(PREG,GL_VOID_VARX_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xx.xl); + profiled_deref_head_TEST(d0, traced_glist_void_varx_write); + traced_glist_void_varx_read: + /* did we find a list? */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GL_VOID_VARX_GLIST_VOID_VARX_READ); + if (!IsPairTerm(d0)) { + TRACED_FAIL(); + } + ALWAYS_START_PREFETCH(xx); + /* enter read mode */ + BEGP(pt0); + pt0 = RepPair(d0); + d0 = pt0[1]; + XREG(PREG->u.xx.xr) = d0; + PREG = NEXTOP(PREG, xx); + ALWAYS_GONext(); + ENDP(pt0); + ALWAYS_END_PREFETCH(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_glist_void_varx_write, traced_glist_void_varx_read); + EMIT_SIMPLE_BLOCK_TEST(GL_VOID_VARX_GLIST_VOID_VAR_WRITE); + /* enter write mode */ + BEGP(pt1); + pt1 = HR; + /* include XREG on it */ + XREG(PREG->u.xx.xr) = + Unsigned(pt1 + 1); + RESET_VARIABLE(pt1); + RESET_VARIABLE(pt1+1); + HR = pt1 + 2; + BEGD(d0); + d0 = AbsPair(pt1); + Bind(pt0, d0); + PREG = NEXTOP(PREG, xx); + ENDD(d0); + ENDP(pt1); + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_gl_void_vary, yx); + EMIT_ENTRY_BLOCK(PREG,GL_VOID_VARY_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.yx.x); + profiled_deref_head_TEST(d0, traced_glist_void_vary_write); + traced_glist_void_vary_read: + /* did we find a list? */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GL_VOID_VARY_GLIST_VOID_VARY_READ); + if (!IsPairTerm(d0)) { + TRACED_FAIL(); + } + /* enter read mode */ + BEGP(pt0); + pt0 = RepPair(d0); + d0 = pt0[1]; + ENDP(pt0); + INITIALIZE_PERMVAR(YREG+PREG->u.yx.y,d0); + PREG = NEXTOP(PREG, yx); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_glist_void_vary_write, traced_glist_void_vary_read); + /* enter write mode */ + EMIT_SIMPLE_BLOCK_TEST(GL_VOID_VARY_GLIST_VOID_VARY_WRITE); + BEGP(pt1); + pt1 = HR; + /* include XREG on it */ + INITIALIZE_PERMVAR(YREG+PREG->u.yx.y,Unsigned(pt1 + 1)); + PREG = NEXTOP(PREG, yx); + RESET_VARIABLE(pt1); + RESET_VARIABLE(pt1+1); + d0 = AbsPair(pt1); + HR = pt1 + 2; + Bind(pt0, d0); + GONext(); + ENDP(pt1); + ENDP(pt0); + + ENDD(d0); + ENDOp(); + + Op(traced_gl_void_valx, xx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,GL_VOID_VALX_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xx.xl); + deref_head(d0, traced_glist_void_valx_write); + traced_glist_void_valx_read: + BEGP(pt0); + /* did we find a list? */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_READ); +///#endif + if (!IsPairTerm(d0)) { + TRACED_FAIL(); + } + /* enter read mode */ + pt0 = RepPair(d0)+1; + /* start unification with first argument */ + d0 = *pt0; + deref_head(d0, traced_glist_void_valx_unk); + + traced_glist_void_valx_nonvar: + /* first argument is bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_NONVAR); +//#endif + BEGD(d1); + d1 = XREG(PREG->u.xx.xr); + deref_head(d1, traced_glist_void_valx_nonvar_unk); + + traced_glist_void_valx_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, xx); + traced_UnifyBound(d0, d1); + + /* deref second argument */ + BEGP(pt1); + deref_body(d1, pt1, traced_glist_void_valx_nonvar_unk, traced_glist_void_valx_nonvar_nonvar); + /* first argument bound, second unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK); +///#endif + PREG = NEXTOP(PREG, xx); + Bind(pt1, d0); + GONext(); + ENDP(pt1); + ENDD(d1); + + /* first argument may be unbound */ + derefa_body(d0, pt0, traced_glist_void_valx_unk, traced_glist_void_valx_nonvar); + /* first argument is unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_UNK); +///#endif + BEGD(d1); + d1 = XREG(PREG->u.xx.xr); + deref_head(d1, traced_glist_void_valx_var_unk); + + traced_glist_void_valx_var_nonvar: + /* first unbound, second bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, xx); + Bind_Global(pt0, d1); + GONext(); + + BEGP(pt1); + deref_body(d1, pt1, traced_glist_void_valx_var_unk, traced_glist_void_valx_var_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK); +///#endif + /* both arguments are unbound */ + PREG = NEXTOP(PREG, xx); + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDD(d1); + ENDP(pt0); + + BEGP(pt0); + deref_body(d0, pt0, traced_glist_void_valx_write, traced_glist_void_valx_read); + /* enter write mode */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALX_GLIST_VOID_VALX_WRITE); +///#endif + BEGP(pt1); + pt1 = HR; + d0 = AbsPair(pt1); + Bind(pt0, d0); + pt1 = HR; + BEGD(d0); + /* include XREG on it */ + d0 = XREG(PREG->u.xx.xr); + RESET_VARIABLE(pt1); + pt1[1] = d0; + HR = pt1 + 2; + ENDD(d0); + ENDP(pt1); + PREG = NEXTOP(PREG, xx); + GONext(); + ENDP(pt0); + + ENDD(d0); + ENDOp(); + + Op(traced_gl_void_valy, yx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,GL_VOID_VALY_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yx.x); + deref_head(d0, traced_glist_void_valy_write); + traced_glist_void_valy_read: +///#ifdef PROFILED_ABSMI +///#endif + BEGP(pt0); + /* did we find a list? */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_READ); +///#endif + if (!IsPairTerm(d0)) { + TRACED_FAIL(); + } + /* enter read mode */ + pt0 = RepPair(d0)+1; + /* start unification with first argument */ + d0 = *pt0; + deref_head(d0, traced_glist_void_valy_unk); + + traced_glist_void_valy_nonvar: + /* first argument is bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_NONVAR); +///#endif + BEGD(d1); + BEGP(pt1); + pt1 = YREG+PREG->u.yx.y; + d1 = *pt1; + deref_head(d1, traced_glist_void_valy_nonvar_unk); + + traced_glist_void_valy_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, yx); + traced_UnifyBound(d0, d1); + + /* deref second argument */ + derefa_body(d1, pt1, traced_glist_void_valy_nonvar_unk, traced_glist_void_valy_nonvar_nonvar); + /* first argument bound, second unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK); +///#endif + PREG = NEXTOP(PREG, yx); + Bind(pt1, d0); + GONext(); + + ENDP(pt1); + + /* first argument may be unbound */ + derefa_body(d0, pt0, traced_glist_void_valy_unk, traced_glist_void_valy_nonvar); + /* first argument is unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_UNK); +///#endif + BEGP(pt1); + pt1 = YREG+PREG->u.yx.y; + d1 = *pt1; + deref_head(d1, traced_glist_void_valy_var_unk); + + traced_glist_void_valy_var_nonvar: + /* first unbound, second bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, yx); + Bind_Global(pt0, d1); + GONext(); + + deref_body(d1, pt1, traced_glist_void_valy_var_unk, traced_glist_void_valy_var_nonvar); + /* both arguments are unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK); +///#endif + PREG = NEXTOP(PREG, yx); + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDD(d1); + ENDP(pt0); + + BEGP(pt0); + deref_body(d0, pt0, traced_glist_void_valy_write, traced_glist_void_valy_read); + /* enter write mode */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(GL_VOID_VALY_GLIST_VOID_VALY_WRITE); +///#endif + CACHE_S(); + S_SREG = HR; + d0 = AbsPair(S_SREG); + Bind(pt0, d0); + S_SREG = HR; + /* include XREG on it */ + BEGD(d1); + d1 = YREG[PREG->u.yx.y]; + RESET_VARIABLE(S_SREG); + S_SREG[1] = d1; + ENDD(d1); + PREG = NEXTOP(PREG, yx); + HR = S_SREG + 2; + ENDCACHE_S(); + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + + +/************************************************************************\ +* Unify instructions * +\************************************************************************/ + + Op(traced_unify_x_var, ox); + EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAR_INSTINIT); + CACHE_S(); + READ_IN_S(); + BEGD(d0); + d0 = *S_SREG; +#ifdef YAPOR_SBA + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_VAR_YAPOR_SBA); + if (d0 == 0) { + d0 = (CELL)S_SREG; + } +#endif + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_VAR_END); + WRITEBACK_S(S_SREG+1); + ALWAYS_START_PREFETCH(ox); + XREG(PREG->u.ox.x) = d0; + PREG = NEXTOP(PREG, ox); + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + ENDD(d0); + ENDCACHE_S(); + ENDOp(); + + OpW(traced_unify_x_var_write, ox); + EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAR_WRITE_INSTINIT); + CACHE_S(); + READ_IN_S(); + BEGP(pt0); + pt0 = &XREG(PREG->u.ox.x); + PREG = NEXTOP(PREG, ox); + RESET_VARIABLE(S_SREG); + *pt0 = (CELL) S_SREG; + WRITEBACK_S(S_SREG+1); + ENDP(pt0); + ENDCACHE_S(); + GONextW(); + ENDOpW(); + + BOp(traced_unify_l_x_var, ox); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAR_INSTINIT); + ALWAYS_START_PREFETCH(ox); + BEGP(pt0); + BEGD(d0); + d0 = SREG[0]; + pt0 = &XREG(PREG->u.ox.x); + PREG = NEXTOP(PREG, ox); +#ifdef YAPOR_SBA + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_VAR_YAPOR_SBA); + if (d0 == 0) { + d0 = (CELL)SREG; + } +#endif + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_VAR_END); + *pt0 = d0; + ALWAYS_GONext(); + ENDD(d0); + ENDP(pt0); + ALWAYS_END_PREFETCH(); + ENDBOp(); + + BOp(traced_unify_l_x_var_write, ox); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAR_WRITE_INSTINIT); + ALWAYS_START_PREFETCH(ox); + CACHE_S(); + READ_IN_S(); + BEGP(pt0); + pt0 = &XREG(PREG->u.ox.x); + PREG = NEXTOP(PREG, ox); + RESET_VARIABLE(S_SREG); + *pt0 = (CELL)S_SREG; + ENDP(pt0); + ENDCACHE_S(); + ALWAYS_GONext(); + ENDBOp(); + ALWAYS_END_PREFETCH(); + + BOp(traced_unify_x_var2, oxx); + EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAR2_INSTINIT); + CACHE_S(); + ALWAYS_START_PREFETCH(oxx); + READ_IN_S(); + BEGP(pt0); + pt0 = &XREG(PREG->u.oxx.xr); + BEGD(d0); + d0 = S_SREG[0]; + BEGD(d1); + d1 = S_SREG[1]; +#ifdef YAPOR_SBA + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_VAR2_YAPOR_SBA); + if (d0 == 0) { + d0 = (CELL)S_SREG; + } + if (d1 == 0) { + d1 = (CELL)(S_SREG+1); + } +#endif + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_VAR2_END); + WRITEBACK_S(S_SREG+2); + XREG(PREG->u.oxx.xl) = d0; + PREG = NEXTOP(PREG, oxx); + *pt0 = d1; + ENDD(d0); + ENDD(d1); + ENDP(pt0); + ALWAYS_GONext(); + ENDBOp(); + ALWAYS_END_PREFETCH(); + ENDCACHE_S(); + + OpW(traced_unify_x_var2_write, oxx); + EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAR2_WRITE_INSTINIT); + CACHE_S(); + READ_IN_S(); + BEGP(pt0); + pt0 = &XREG(PREG->u.oxx.xr); + RESET_VARIABLE(S_SREG); + XREG(PREG->u.oxx.xl) = (CELL) S_SREG; + S_SREG++; + PREG = NEXTOP(PREG, oxx); + RESET_VARIABLE(S_SREG); + *pt0 = (CELL) S_SREG; + ENDP(pt0); + WRITEBACK_S(S_SREG+1); + ENDCACHE_S(); + GONextW(); + ENDOpW(); + + BOp(traced_unify_l_x_var2, oxx); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAR2_INSTINIT); + ALWAYS_START_PREFETCH(oxx); + CACHE_S(); + READ_IN_S(); + BEGP(pt0); + pt0 = &XREG(PREG->u.oxx.xr); + BEGD(d0); + d0 = S_SREG[0]; + BEGD(d1); + d1 = S_SREG[1]; +#ifdef YAPOR_SBA + if (d0 == 0) + XREG(PREG->u.oxx.xl) = (CELL)S_SREG; + else +#endif + XREG(PREG->u.oxx.xl) = d0; + PREG = NEXTOP(PREG, oxx); +#ifdef YAPOR_SBA + if (d1 == 0) + *pt0 = (CELL)(S_SREG+1); + else +#endif + *pt0 = d1; + ENDD(d0); + ENDD(d1); + ENDP(pt0); + ENDCACHE_S(); + ALWAYS_GONext(); + ENDBOp(); + ALWAYS_END_PREFETCH(); + + Op(traced_unify_l_x_var2_write, oxx); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAR2_WRITE_INSTINIT); + CACHE_S(); + READ_IN_S(); + BEGP(pt0); + pt0 = &XREG(PREG->u.oxx.xr); + XREG(PREG->u.oxx.xl) = (CELL) S_SREG; + RESET_VARIABLE(S_SREG); + S_SREG++; + *pt0 = (CELL) S_SREG; + PREG = NEXTOP(PREG, oxx); + RESET_VARIABLE(S_SREG); + ENDP(pt0); + ENDCACHE_S(); + GONext(); + ENDOp(); + + Op(traced_unify_y_var, oy); + EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_VAR_INSTINIT); + BEGD(d0); + d0 = *SREG++; +#ifdef YAPOR_SBA + if (d0 == 0) { + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,(CELL)(SREG-1)); + } else +#else + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,d0); +#endif /* YAPOR_SBA */ + PREG = NEXTOP(PREG, oy); + GONext(); + ENDD(d0); + ENDOp(); + + OpW(traced_unify_y_var_write, oy); + EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_VAR_WRITE_INSTINIT); + CACHE_S(); + READ_IN_S(); + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,(CELL) S_SREG); + PREG = NEXTOP(PREG, oy); + RESET_VARIABLE(S_SREG); + WRITEBACK_S(S_SREG+1); + ENDCACHE_S(); + GONextW(); + ENDOpW(); + + Op(traced_unify_l_y_var, oy); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_VAR_INSTINIT); + BEGD(d0); + d0 = SREG[0]; +#ifdef YAPOR_SBA + if (d0 == 0) { + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,(CELL)SREG); + } else +#else + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,d0); +#endif /* YAPOR_SBA */ + PREG = NEXTOP(PREG, oy); + GONext(); + ENDD(d0); + ENDOp(); + + Op(traced_unify_l_y_var_write, oy); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_VAR_WRITE_INSTINIT); + CACHE_S(); + READ_IN_S(); + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,(CELL) S_SREG); + PREG = NEXTOP(PREG, oy); + RESET_VARIABLE(S_SREG); + ENDCACHE_S(); + GONext(); + ENDOp(); + + /* We assume the value in X is pointing to an object in the + * global stack */ + Op(traced_unify_x_val, ox); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAL_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + deref_head(d0, traced_uvalx_unk); + + traced_uvalx_nonvar: + /* first argument is bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_NONVAR); +///#endif + d1 = XREG(PREG->u.ox.x); + deref_head(d1, traced_uvalx_nonvar_unk); + + traced_uvalx_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_NONVAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, ox); + SREG++; + traced_UnifyBound(d0, d1); + + /* deref second argument */ + /* pt0 is in the structure and pt1 the register */ + BEGP(pt1); + deref_body(d1, pt1, traced_uvalx_nonvar_unk, traced_uvalx_nonvar_nonvar); + /* first argument bound, second unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_NONVAR_UNK); +///#endif + PREG = NEXTOP(PREG, ox); + SREG++; + Bind(pt1, d0); + GONext(); + ENDP(pt1); + + /* first argument may be unbound */ + derefa_body(d0, pt0, traced_uvalx_unk, traced_uvalx_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_UNK); +///#endif + /* first argument is unbound */ + d1 = XREG(PREG->u.ox.x); + deref_head(d1, traced_uvalx_var_unk); + + traced_uvalx_var_nonvar: + /* first unbound, second bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_VAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, ox); + SREG++; + Bind_Global(pt0, d1); + GONext(); + + BEGP(pt1); + deref_body(d1, pt1, traced_uvalx_var_unk, traced_uvalx_var_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_X_VAL_UVALX_VAR_UNK); +///#endif + /* both arguments are unbound */ + PREG = NEXTOP(PREG, ox); + SREG++; + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + OpW(traced_unify_x_val_write, ox); + /* we are in write mode */ + EMIT_ENTRY_BLOCK(PREG,UNIFY_X_VAL_WRITE_INSTINIT); + *SREG++ = XREG(PREG->u.ox.x); + PREG = NEXTOP(PREG, ox); + GONextW(); + ENDOpW(); + + /* We assume the value in X is pointing to an object in the + * global stack */ + Op(traced_unify_l_x_val, ox); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAL_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + deref_head(d0, traced_ulvalx_unk); + + traced_ulvalx_nonvar: + /* first argument is bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_NONVAR); +///#endif + d1 = XREG(PREG->u.ox.x); + deref_head(d1, traced_ulvalx_nonvar_unk); + + traced_ulvalx_nonvar_nonvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR); +///#endif + /* both arguments are bound */ + /* we may have to bind structures */ + PREG = NEXTOP(PREG, ox); + traced_UnifyBound(d0, d1); + + BEGP(pt1); + /* deref second argument */ + deref_body(d1, pt1, traced_ulvalx_nonvar_unk, traced_ulvalx_nonvar_nonvar); + /* first argument bound, second unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_NONVAR_UNK); +///#endif + PREG = NEXTOP(PREG, ox); + Bind(pt1, d0); + GONext(); + ENDP(pt1); + + /* first argument may be unbound */ + derefa_body(d0, pt0, traced_ulvalx_unk, traced_ulvalx_nonvar); + /* first argument is unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_UNK); +///#endif + d1 = XREG(PREG->u.ox.x); + deref_head(d1, traced_ulvalx_var_unk); + + traced_ulvalx_var_nonvar: + /* first unbound, second bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_VAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, ox); + Bind_Global(pt0, d1); + GONext(); + + BEGP(pt1); + deref_body(d1, pt1, traced_ulvalx_var_unk, traced_ulvalx_var_nonvar); + /* both arguments are unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(UNIFY_L_X_VAL_ULVALX_VAR_UNK); +///#endif + PREG = NEXTOP(PREG, ox); + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_unify_l_x_val_write, ox); + /* we are in write mode */ + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_VAL_WRITE_INSTINIT); + SREG[0] = XREG(PREG->u.ox.x); + PREG = NEXTOP(PREG, ox); + GONext(); + ENDOp(); + + /* We assume the value in X is pointing to an object in the + * global stack */ + Op(traced_unify_y_val, oy); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_VAL_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + deref_head(d0, traced_uvaly_unk); + + traced_uvaly_nonvar: + /* first argument is bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_NONVAR); +///#endif + BEGP(pt1); + pt1 = YREG+PREG->u.oy.y; + d1 = *pt1; + deref_head(d1, traced_uvaly_nonvar_unk); + + traced_uvaly_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ +///#ifdef PROFILED_ABSMI + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_Y_VAL_UVALY_NONVAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, oy); + SREG++; + traced_UnifyBound(d0, d1); + + /* deref second argument */ + derefa_body(d1, pt1, traced_uvaly_nonvar_unk, traced_uvaly_nonvar_nonvar); + /* first argument bound, second unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_NONVAR_UNK); +///#endif + PREG = NEXTOP(PREG, oy); + SREG++; + Bind(pt1, d0); + GONext(); + ENDP(pt1); + + /* first argument may be unbound */ + derefa_body(d0, pt0, traced_uvaly_unk, traced_uvaly_nonvar); + /* first argument is unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_UNK); +///#endif + BEGP(pt1); + pt1 = YREG+PREG->u.oy.y; + d1 = *pt1; + deref_head(d1, traced_uvaly_var_unk); + + traced_uvaly_var_nonvar: + /* first unbound, second bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_VAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, oy); + SREG++; + Bind_Global(pt0, d1); + GONext(); + + derefa_body(d1, pt1, traced_uvaly_var_unk, traced_uvaly_var_nonvar); + /* both arguments are unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_VAL_UVALY_VAR_UNK); +///#endif + PREG = NEXTOP(PREG, oy); + SREG++; + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + OpW(traced_unify_y_val_write, oy); + EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_VAL_WRITE_INSTINIT); + /* we are in write mode */ + BEGD(d0); + d0 = YREG[PREG->u.oy.y]; +#ifdef YAPOR_SBA + if (d0 == 0) /* free variable */ + *SREG++ = (CELL)(YREG+PREG->u.oy.y); + else +#endif + *SREG++ = d0; + ENDD(d0); + PREG = NEXTOP(PREG, oy); + GONextW(); + ENDOpW(); + + /* We assume the value in X is pointing to an object in the + * global stack */ + Op(traced_unify_l_y_val, oy); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_VAL_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + deref_head(d0, traced_ulvaly_unk); + + traced_ulvaly_nonvar: + /* first argument is bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_NONVAR); +///#endif + BEGP(pt1); + pt1 = YREG+PREG->u.oy.y; + d1 = *pt1; + deref_head(d1, traced_ulvaly_nonvar_unk); + + traced_ulvaly_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ +///#ifdef PROFILED_ABSMI + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, oy); + traced_UnifyBound(d0, d1); + + /* deref second argument */ + derefa_body(d1, pt1, traced_ulvaly_nonvar_unk, traced_ulvaly_nonvar_nonvar); + /* first argument bound, second unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK); +///#endif + PREG = NEXTOP(PREG, oy); + Bind(pt1, d0); + GONext(); + ENDP(pt1); + + /* first argument may be unbound */ + derefa_body(d0, pt0, traced_ulvaly_unk, traced_ulvaly_nonvar); + /* first argument is unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_UNK); +///#endif + BEGP(pt1); + pt1 = YREG+PREG->u.oy.y; + d1 = *pt1; + deref_head(d1, traced_ulvaly_var_unk); + + traced_ulvaly_var_nonvar: + /* first unbound, second bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, oy); + Bind_Global(pt0, d1); + GONext(); + + /* Here we are in trouble: we have a clash between pt1 and + * SREG. We address this by storing SREG in d0 for the duration. */ + derefa_body(d1, pt1, traced_ulvaly_var_unk, traced_ulvaly_var_nonvar); + /* both arguments are unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_VAL_ULVALY_VAR_UNK); +///#endif + PREG = NEXTOP(PREG, oy); + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_unify_l_y_val_write, oy); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_VAL_WRITE_INSTINIT); + /* we are in write mode */ + BEGD(d0); + d0 = YREG[PREG->u.oy.y]; +#ifdef YAPOR_SBA + if (d0 == 0) /* new variable */ + SREG[0] = (CELL)(YREG+PREG->u.oy.y); + else +#endif + SREG[0] = d0; + ENDD(d0); + PREG = NEXTOP(PREG, oy); + GONext(); + ENDOp(); + + /* In the next instructions, we do not know anything about + * what is in X */ + Op(traced_unify_x_loc, ox); + EMIT_ENTRY_BLOCK(PREG,UNIFY_X_LOC_INSTINIT); + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + + profiled_deref_head_TEST(d0, traced_uvalx_loc_unk); + traced_uvalx_loc_nonvar: + /* first argument is bound */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_NONVAR); + d1 = XREG(PREG->u.ox.x); + profiled_deref_head_TEST(d1, traced_uvalx_loc_nonvar_unk); + + traced_uvalx_loc_nonvar_nonvar: + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR); + /* both arguments are bound */ + /* we may have to bind structures */ + PREG = NEXTOP(PREG, ox); + SREG++; + traced_UnifyBound(d0, d1); + + BEGP(pt1); + /* deref second argument */ + profiled_deref_body(d1, pt1, traced_uvalx_loc_nonvar_unk, traced_uvalx_loc_nonvar_nonvar); + /* first argument bound, second unbound */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK); + PREG = NEXTOP(PREG, ox); + SREG++; + Bind(pt1, d0); + GONext(); + ENDP(pt1); + + + /* first argument may be unbound */ + profiled_derefa_body(d0, pt0, traced_uvalx_loc_unk, traced_uvalx_loc_nonvar); + /* first argument is unbound */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_UNK); + d1 = XREG(PREG->u.ox.x); + profiled_deref_head_TEST(d1, traced_uvalx_loc_var_unk); + traced_uvalx_loc_var_nonvar: + /* first unbound, second bound */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR); + PREG = NEXTOP(PREG, ox); + SREG++; + Bind_Global(pt0, d1); + GONext(); + + /* Here we are in trouble: we have a clash between pt1 and + * SREG. We address this by storing SREG in d0 for the duration. */ + BEGP(pt1); + profiled_deref_body(d1, pt1, traced_uvalx_loc_var_unk, traced_uvalx_loc_var_nonvar); + /* both arguments are unbound */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_UVALX_LOC_VAR_UNK); + PREG = NEXTOP(PREG, ox); + SREG++; + UnifyCells(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + OpW(traced_unify_x_loc_write, ox); + EMIT_ENTRY_BLOCK(PREG,UNIFY_X_LOC_WRITE_INSTINIT); + /* we are in write mode */ + BEGD(d0); + d0 = XREG(PREG->u.ox.x); + profiled_deref_head_TEST(d0, traced_unify_x_loc_unk); + traced_unify_x_loc_nonvar: + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR); + *SREG++ = d0; + PREG = NEXTOP(PREG, ox); + GONextW(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_unify_x_loc_unk, traced_unify_x_loc_nonvar); + /* move ahead in the instructions */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK); + PREG = NEXTOP(PREG, ox); + /* d0 is a variable, check whether we need to globalise it */ + if (pt0 < HR) { + /* variable is global */ + *SREG++ = Unsigned(pt0); + GONextW(); + } + else { + /* bind our variable to the structure */ + CACHE_S(); + READ_IN_S(); + Bind_Local(pt0, Unsigned(S_SREG)); + RESET_VARIABLE(S_SREG); + WRITEBACK_S(S_SREG+1); + ENDCACHE_S(); + GONextW(); + } + ENDP(pt0); + ENDD(d0); + ENDOpW(); + + /* In the next instructions, we do not know anything about + * what is in X */ + Op(traced_unify_l_x_loc, ox); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_LOC_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + deref_head(d0, traced_ulvalx_loc_unk); + + traced_ulvalx_loc_nonvar: + /* first argument is bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_NONVAR); +///#endif + d1 = XREG(PREG->u.ox.x); + deref_head(d1, traced_ulvalx_loc_nonvar_unk); + + traced_ulvalx_loc_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ +///#ifdef PROFILED_ABSMI + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, ox); + traced_UnifyBound(d0, d1); + + /* deref second argument */ + deref_body(d1, pt0, traced_ulvalx_loc_nonvar_unk, traced_ulvalx_loc_nonvar_nonvar); + /* first argument bound, second unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK); +///#endif + PREG = NEXTOP(PREG, ox); + Bind(pt0, d0); + GONext(); + + /* first argument may be unbound */ + derefa_body(d0, pt0, traced_ulvalx_loc_unk, traced_ulvalx_loc_nonvar); + /* first argument is unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_UNK); +///#endif + d1 = XREG(PREG->u.ox.x); + deref_head(d1, traced_ulvalx_loc_var_unk); + + traced_ulvalx_loc_var_nonvar: + /* first unbound, second bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, ox); + Bind_Global(pt0, d1); + GONext(); + + BEGP(pt1); + deref_body(d1, pt1, traced_ulvalx_loc_var_unk, traced_ulvalx_loc_var_nonvar); + /* both arguments are unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK); +///#endif + PREG = NEXTOP(PREG, ox); + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_unify_l_x_loc_write, ox); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_X_LOC_WRITE_INSTINIT); + /* we are in write mode */ + BEGD(d0); + d0 = XREG(PREG->u.ox.x); + profiled_deref_head_TEST(d0, traced_ulnify_x_loc_unk); + traced_ulnify_x_loc_nonvar: + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR); + SREG[0] = d0; + PREG = NEXTOP(PREG, ox); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_ulnify_x_loc_unk, traced_ulnify_x_loc_nonvar); + /* d0 is a variable, check whether we need to globalise it */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK); + PREG = NEXTOP(PREG, ox); + if (pt0 < HR) { + /* variable is global */ + SREG[0] = Unsigned(pt0); + GONext(); + } + else { + /* create a new Heap variable and bind our variable to it */ + Bind_Local(pt0, Unsigned(SREG)); + RESET_VARIABLE(SREG); + GONext(); + } + ENDP(pt0); + ENDD(d0); + ENDOpW(); + + Op(traced_unify_y_loc, oy); + /* we are in read mode */ +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_LOC_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + deref_head(d0, traced_uvaly_loc_unk); + + traced_uvaly_loc_nonvar: + /* structure is bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_NONVAR); +///#endif + BEGP(pt1); + pt1 = YREG+PREG->u.oy.y; + d1 = *pt1; + deref_head(d1, traced_uvaly_loc_nonvar_unk); + + traced_uvaly_loc_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ +///#ifdef PROFILED_ABSMI + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, oy); + SREG++; + traced_UnifyBound(d0, d1); + + /* deref second argument */ + derefa_body(d1, pt1, traced_uvaly_loc_nonvar_unk, traced_uvaly_loc_nonvar_nonvar); + /* first argument bound, second unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK); +///#endif + PREG = NEXTOP(PREG, oy); + SREG++; + Bind(pt1, d0); + GONext(); + ENDP(pt1); + + /* first argument may be unbound */ + derefa_body(d0, pt0, traced_uvaly_loc_unk, traced_uvaly_loc_nonvar); + /* first argument is unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_UNK); +///#endif + BEGP(pt1); + pt1 = YREG+PREG->u.oy.y; + d1 = *pt1; + deref_head(d1, traced_uvaly_loc_var_unk); + + traced_uvaly_loc_var_nonvar: + /* first unbound, second bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, oy); + SREG++; + Bind_Global(pt0, d1); + GONext(); + + /* Here we are in trouble: we have a clash between pt1 and + * SREG. We address this by storing SREG in d0 for the duration. */ + derefa_body(d1, pt1, traced_uvaly_loc_var_unk, traced_uvaly_loc_var_nonvar); + /* both arguments are unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_UVALY_LOC_VAR_UNK); +///#endif + PREG = NEXTOP(PREG, oy); + SREG++; + UnifyCells(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + OpW(traced_unify_y_loc_write, oy); + /* we are in write mode */ + EMIT_ENTRY_BLOCK(PREG,UNIFY_Y_LOC_WRITE_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = YREG+PREG->u.oy.y; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_unify_y_loc_unk); + traced_unify_y_loc_nonvar: + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR); + *SREG++ = d0; + PREG = NEXTOP(PREG, oy); + GONextW(); + + profiled_derefa_body(d0, pt0, traced_unify_y_loc_unk, traced_unify_y_loc_nonvar); + /* d0 is a variable, check whether we need to globalise it */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK); + PREG = NEXTOP(PREG, oy); + if (pt0 < HR) { + /* variable is global */ + *SREG++ = Unsigned(pt0); + GONextW(); + } + else { + /* create a new Heap variable and bind our variable to it */ + CACHE_S(); + READ_IN_S(); + Bind_Local(pt0, Unsigned(S_SREG)); + RESET_VARIABLE(S_SREG); + WRITEBACK_S(S_SREG+1); + ENDCACHE_S(); + GONextW(); + } + ENDP(pt0); + ENDD(d0); + ENDOpW(); + + Op(traced_unify_l_y_loc, oy); + /* else we are in read mode */ +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_LOC_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + deref_head(d0, traced_ulvaly_loc_unk); + + traced_ulvaly_loc_nonvar: + /* structure is bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR); +///#endif + BEGP(pt1); + pt1 = YREG+PREG->u.oy.y; + d1 = *pt1; + deref_head(d1, traced_ulvaly_loc_nonvar_unk); + + traced_ulvaly_loc_nonvar_nonvar: + /* both arguments are bound */ + /* we may have to bind structures */ +///#ifdef PROFILED_ABSMI + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, oy); + traced_UnifyBound(d0, d1); + + /* deref second argument */ + derefa_body(d1, pt1, traced_ulvaly_loc_nonvar_unk, traced_ulvaly_loc_nonvar_nonvar); + /* first argument bound, second unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK); +///#endif + PREG = NEXTOP(PREG, oy); + Bind(pt1, d0); + GONext(); + ENDP(pt1); + + /* first argument may be unbound */ + derefa_body(d0, pt0, traced_ulvaly_loc_unk, traced_ulvaly_loc_nonvar); + /* first argument is unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_UNK); +///#endif + BEGP(pt1); + pt1 = YREG+PREG->u.oy.y; + d1 = *pt1; + deref_head(d1, traced_ulvaly_loc_var_unk); + + traced_ulvaly_loc_var_nonvar: + /* first unbound, second bound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR); +///#endif + PREG = NEXTOP(PREG, oy); + Bind_Global(pt0, d1); + GONext(); + + /* Here we are in trouble: we have a clash between pt1 and + * SREG. We address this by storing SREG in d0 for the duration. */ + derefa_body(d1, pt1, traced_ulvaly_loc_var_unk, traced_ulvaly_loc_var_nonvar); + /* both arguments are unbound */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK); +///#endif + PREG = NEXTOP(PREG, oy); + UnifyGlobalCellToCell(pt0, pt1); + GONext(); + ENDP(pt1); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_unify_l_y_loc_write, oy); + /* we are in write mode */ + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_Y_LOC_WRITE_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = YREG+PREG->u.oy.y; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_ulunify_y_loc_unk); + traced_ulunify_y_loc_nonvar: + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR); + SREG[0] = d0; + PREG = NEXTOP(PREG, oy); + GONext(); + + profiled_derefa_body(d0, pt0, traced_ulunify_y_loc_unk, traced_ulunify_y_loc_nonvar); + /* d0 is a variable, check whether we need to globalise it */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK); + PREG = NEXTOP(PREG, oy); + if (pt0 < HR) { + /* variable is global */ + SREG[0] = Unsigned(pt0); + GONext(); + } + else { + /* create a new Heap variable and bind our variable to it */ + CACHE_S(); + READ_IN_S(); + Bind_Local(pt0, Unsigned(S_SREG)); + RESET_VARIABLE(S_SREG); + ENDCACHE_S(); + GONext(); + } + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_unify_void, o); + EMIT_ENTRY_BLOCK(PREG,UNIFY_VOID_INSTINIT); + START_PREFETCH(o); + PREG = NEXTOP(PREG, o); + SREG++; + GONext(); + END_PREFETCH(); + ENDOp(); + + OpW(traced_unify_void_write, o); + EMIT_ENTRY_BLOCK(PREG,UNIFY_VOID_WRITE_INSTINIT); + CACHE_S(); + READ_IN_S(); + PREG = NEXTOP(PREG, o); + RESET_VARIABLE(S_SREG); + WRITEBACK_S(S_SREG+1); + ENDCACHE_S(); + GONextW(); + ENDOpW(); + + Op(traced_unify_l_void, o); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_VOID_INSTINIT); + PREG = NEXTOP(PREG, o); + GONext(); + ENDOp(); + + Op(traced_unify_l_void_write, o); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_VOID_WRITE_INSTINIT); + PREG = NEXTOP(PREG, o); + RESET_VARIABLE(SREG); + GONext(); + ENDOp(); + + Op(traced_unify_n_voids, os); + EMIT_ENTRY_BLOCK(PREG,UNIFY_N_VOIDS_INSTINIT); + SREG += PREG->u.os.s; + PREG = NEXTOP(PREG, os); + GONext(); + ENDOp(); + + OpW(traced_unify_n_voids_write, os); + EMIT_ENTRY_BLOCK(PREG,UNIFY_N_VOIDS_WRITE_INSTINIT); + BEGD(d0); + CACHE_S(); + d0 = PREG->u.os.s; + READ_IN_S(); + PREG = NEXTOP(PREG, os); + for (; d0 > 0; d0--) { + RESET_VARIABLE(S_SREG); + S_SREG++; + } + WRITEBACK_S(S_SREG); + ENDCACHE_S(); + ENDD(d0); + GONextW(); + ENDOpW(); + + Op(traced_unify_l_n_voids, os); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_N_VOIDS_INSTINIT); + PREG = NEXTOP(PREG, os); + GONext(); + ENDOp(); + + Op(traced_unify_l_n_voids_write, os); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_N_VOIDS_WRITE_INSTINIT); + BEGD(d0); + d0 = PREG->u.os.s; + PREG = NEXTOP(PREG, os); + CACHE_S(); + READ_IN_S(); + for (; d0 > 0; d0--) { + RESET_VARIABLE(S_SREG); + S_SREG++; + } + ENDCACHE_S(); + ENDD(d0); + GONext(); + ENDOp(); + + Op(traced_unify_atom, oc); + EMIT_ENTRY_BLOCK(PREG,UNIFY_ATOM_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = SREG++; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_uatom_unk); + traced_uatom_nonvar: + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_ATOM_UATOM_NONVAR); + if (d0 != PREG->u.oc.c) { + TRACED_FAIL(); + } + PREG = NEXTOP(PREG, oc); + GONext(); + + profiled_derefa_body(d0, pt0, traced_uatom_unk, traced_uatom_nonvar); + EMIT_SIMPLE_BLOCK_TEST(UNIFY_ATOM_UATOM_UNK); + d0 = PREG->u.oc.c; + PREG = NEXTOP(PREG, oc); + Bind_Global(pt0, d0); + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + OpW(traced_unify_atom_write, oc); + EMIT_ENTRY_BLOCK(PREG,UNIFY_ATOM_WRITE_INSTINIT); + * SREG++ = PREG->u.oc.c; + PREG = NEXTOP(PREG, oc); + GONextW(); + ENDOpW(); + + Op(traced_unify_l_atom, oc); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_ATOM_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = SREG; + d0 = *SREG; + profiled_deref_head_TEST(d0, traced_ulatom_unk); + traced_ulatom_nonvar: + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_ATOM_ULATOM_NONVAR); + if (d0 != PREG->u.oc.c) { + TRACED_FAIL(); + } + PREG = NEXTOP(PREG, oc); + GONext(); + + profiled_derefa_body(d0, pt0, traced_ulatom_unk, traced_ulatom_nonvar); + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_ATOM_ULATOM_UNK); + d0 = PREG->u.oc.c; + PREG = NEXTOP(PREG, oc); + Bind_Global(pt0, d0); + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_unify_l_atom_write, oc); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_ATOM_WRITE_INSTINIT); + SREG[0] = PREG->u.oc.c; + PREG = NEXTOP(PREG, oc); + GONext(); + ENDOp(); + + Op(traced_unify_n_atoms, osc); + EMIT_ENTRY_BLOCK(PREG,UNIFY_N_ATOMS_INSTINIT); + { + register Int i = PREG->u.osc.s; /* not enough registers */ + + BEGD(d1); + d1 = PREG->u.osc.c; + for (; i > 0; i--) { + BEGD(d0); + BEGP(pt0); + pt0 = SREG++; + d0 = *pt0; + deref_head(d0, traced_uatom_n_var); + traced_uatom_n_nonvar: + if (d0 != d1) { + TRACED_FAIL(); + } + continue; + + do { + (pt0) = (CELL *)(d0); + (d0) = *(CELL *)(d0); + if(!IsVarTerm(d0)) goto traced_uatom_n_nonvar; + traced_uatom_n_var:; + } while (Unsigned(pt0) != (d0)); + Bind_Global(pt0, d1); + continue; + ENDP(pt0); + ENDD(d0); + } + ENDD(d1); + } + PREG = NEXTOP(PREG, osc); + GONext(); + ENDOp(); + + OpW(traced_unify_n_atoms_write, osc); + EMIT_ENTRY_BLOCK(PREG,UNIFY_N_ATOMS_WRITE_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = PREG->u.osc.s; + d1 = PREG->u.osc.c; + /* write N atoms */ + CACHE_S(); + READ_IN_S(); + PREG = NEXTOP(PREG, osc); + for (; d0 > 0; d0--) { + *S_SREG++ = d1; + } + WRITEBACK_S(S_SREG); + ENDCACHE_S(); + ENDD(d1); + ENDD(d0); + GONextW(); + ENDOpW(); + + Op(traced_unify_float, od); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_FLOAT_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = SREG++; + d0 = *pt0; + deref_head(d0, traced_ufloat_unk); + traced_ufloat_nonvar: + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } + /* look inside term */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_FLOAT_UFLOAT_NONVAR_INIT); +///#endif + BEGP(pt0); + pt0 = RepAppl(d0); + BEGD(d0); + d0 = *pt0; + if (d0 != (CELL)FunctorDouble) { + TRACED_FAIL(); + } + ENDD(d0); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR); +///#endif + BEGP(pt1); + pt1 = PREG->u.od.d; + PREG = NEXTOP(PREG, od); + if ( + pt1[1] != pt0[1] +#if SIZEOF_DOUBLE == 2*SIZEOF_INT_P + || pt1[2] != pt0[2] +#endif + ) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_FLOAT_UFLOAT_NONVAR_END); +///#endif + ENDP(pt1); + ENDP(pt0); + GONext(); + + derefa_body(d0, pt0, traced_ufloat_unk, traced_ufloat_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_FLOAT_UFLOAT_UNK); +///#endif + BEGD(d1); + d1 = AbsAppl(PREG->u.od.d); + PREG = NEXTOP(PREG, od); + Bind_Global(pt0, d1); + GONext(); + ENDD(d1); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + OpW(traced_unify_float_write, od); + EMIT_ENTRY_BLOCK(PREG,UNIFY_FLOAT_WRITE_INSTINIT); + * SREG++ = AbsAppl(PREG->u.od.d); + PREG = NEXTOP(PREG, od); + GONextW(); + ENDOpW(); + + Op(traced_unify_l_float, od); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_FLOAT_INSTINIT); +///#endif + BEGD(d0); + CACHE_S(); + READ_IN_S(); + d0 = *S_SREG; + deref_head(d0, traced_ulfloat_unk); + traced_ulfloat_nonvar: + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_FLOAT_D0ISAPPL); +///#endif + BEGP(pt0); + pt0 = RepAppl(d0); + BEGD(d0); + d0 = *pt0; + if (d0 != (CELL)FunctorDouble) { + TRACED_FAIL(); + } + ENDD(d0); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_FLOAT_D0ISFUNC); +//#endif + BEGP(pt1); + pt1 = PREG->u.od.d; + PREG = NEXTOP(PREG, od); + if ( + pt1[1] != pt0[1] +#if SIZEOF_DOUBLE == 2*SIZEOF_INT_P + || pt1[2] != pt0[2] +#endif + ) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_FLOAT_EQUALS); +///#endif + ENDP(pt1); + ENDP(pt0); + GONext(); + + derefa_body(d0, S_SREG, traced_ulfloat_unk, traced_ulfloat_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_FLOAT_ULFLOAT_UNK); +///#endif + BEGD(d1); + d1 = AbsAppl(PREG->u.od.d); + PREG = NEXTOP(PREG, od); + Bind_Global(S_SREG, d1); + GONext(); + ENDD(d1); + ENDCACHE_S(); + ENDD(d0); + ENDOp(); + + Op(traced_unify_l_float_write, od); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_FLOAT_WRITE_INSTINIT); + SREG[0] = AbsAppl(PREG->u.od.d); + PREG = NEXTOP(PREG, od); + GONext(); + ENDOp(); + + Op(traced_unify_longint, oi); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_LONGINT_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = SREG++; + d0 = *pt0; + deref_head(d0, traced_ulongint_unk); + traced_ulongint_nonvar: + /* look inside term */ + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_LONGINT_D0ISAPPL); +///#endif + BEGP(pt0); + pt0 = RepAppl(d0); + BEGD(d0); + d0 = *pt0; + if (d0 != (CELL)FunctorLongInt) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_LONGINT_D0ISFUNC); +///#endif + ENDD(d0); + BEGP(pt1); + pt1 = PREG->u.oi.i; + PREG = NEXTOP(PREG, oi); + if (pt1[1] != pt0[1]) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_LONGINT_EQUALS); +///#endif + ENDP(pt1); + ENDP(pt0); + GONext(); + + derefa_body(d0, pt0, traced_ulongint_unk, traced_ulongint_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_LONGINT_ULONGINT_UNK); +///#endif + BEGD(d1); + d1 = AbsAppl(PREG->u.oi.i); + PREG = NEXTOP(PREG, oi); + Bind_Global(pt0, d1); + GONext(); + ENDD(d1); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + OpW(traced_unify_longint_write, oi); + EMIT_ENTRY_BLOCK(PREG,UNIFY_LONGINT_WRITE_INSTINIT); + * SREG++ = AbsAppl(PREG->u.oi.i); + PREG = NEXTOP(PREG, oi); + GONextW(); + ENDOpW(); + + Op(traced_unify_l_longint, oi); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_LONGINT_INSTINIT); +///#endif + BEGD(d0); + CACHE_S(); + READ_IN_S(); + d0 = *S_SREG; + deref_head(d0, traced_ullongint_unk); + traced_ullongint_nonvar: + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_LONGINT_D0ISAPPL); +///#endif + BEGP(pt0); + pt0 = RepAppl(d0); + BEGD(d0); + d0 = *pt0; + if (d0 != (CELL)FunctorLongInt) { + TRACED_FAIL(); + } + ENDD(d0); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_LONGINT_D0ISFUNC); +///#endif + BEGP(pt1); + pt1 = PREG->u.oi.i; + PREG = NEXTOP(PREG, oi); + if (pt1[1] != pt0[1]) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_LONGINT_EQUALS); +///#endif + ENDP(pt1); + ENDP(pt0); + GONext(); + + derefa_body(d0, S_SREG, traced_ullongint_unk, traced_ullongint_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_LONGINT_ULLONGINT_UNK); +///#endif + BEGD(d1); + d1 = AbsAppl(PREG->u.oi.i); + PREG = NEXTOP(PREG, oi); + Bind_Global(S_SREG, d1); + GONext(); + ENDD(d1); + ENDCACHE_S(); + ENDD(d0); + ENDOp(); + + Op(traced_unify_l_longint_write, oi); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_LONGINT_WRITE_INSTINIT); + SREG[0] = AbsAppl(PREG->u.oi.i); + PREG = NEXTOP(PREG, oi); + GONext(); + ENDOp(); + + Op(traced_unify_bigint, oN); +#ifdef USE_GMP +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_BIGINT_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = SREG++; + d0 = *pt0; + deref_head(d0, traced_ubigint_unk); + traced_ubigint_nonvar: + /* look inside term */ + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_BIGINT_D0ISAPPL); +///#endif + BEGP(pt0); + pt0 = RepAppl(d0); + BEGD(d1); + d1 = *pt0; + if (d1 != (CELL)FunctorBigInt) + { + TRACED_FAIL(); + } + ENDD(d1); + if (Yap_gmp_tcmp_big_big(d0,PREG->u.oN.b)) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_BIGINT_D1ISFUNC_GMP); +///#endif + PREG = NEXTOP(PREG, oN); + ENDP(pt0); + GONext(); + + derefa_body(d0, pt0, traced_ubigint_unk, traced_ubigint_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_BIGINT_UBIGINT_UNK); +///#endif + BEGD(d1); + d1 = PREG->u.oN.b; + PREG = NEXTOP(PREG, oN); + Bind_Global(pt0, d1); + GONext(); + ENDD(d1); + ENDP(pt0); + ENDD(d0); +#else + TRACED_FAIL(); +#endif + ENDOp(); + + Op(traced_unify_l_bigint, oN); +#ifdef USE_GMP +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_BIGINT_INSTINIT); +///#endif + BEGD(d0); + CACHE_S(); + READ_IN_S(); + d0 = *S_SREG; + deref_head(d0, traced_ulbigint_unk); + traced_ulbigint_nonvar: + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_BIGINT_D0ISAPPL); +///#endif + BEGP(pt0); + pt0 = RepAppl(d0); + BEGD(d0); + d0 = *pt0; + if (d0 != (CELL)FunctorBigInt) + { + TRACED_FAIL(); + } + ENDD(d0); + if (Yap_gmp_tcmp_big_big(d0,PREG->u.oN.b)) { + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_BIGINT_D0ISFUNC_GMP); +///#endif + PREG = NEXTOP(PREG, oN); + ENDP(pt0); + GONext(); + + derefa_body(d0, S_SREG, traced_ulbigint_unk, traced_ulbigint_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_BIGINT_ULBIGINT_UNK); +///#endif + BEGD(d1); + d1 = PREG->u.oN.b; + PREG = NEXTOP(PREG, oN); + Bind_Global(S_SREG, d1); + GONext(); + ENDD(d1); + ENDCACHE_S(); + ENDD(d0); +#else + TRACED_FAIL(); +#endif + ENDOp(); + + Op(traced_unify_dbterm, oD); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_DBTERM_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = SREG++; + d0 = *pt0; + deref_head(d0, traced_udbterm_unk); + traced_udbterm_nonvar: +///#ifdef PROFILED_ABSMI + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_DBTERM_UDBTERM_NONVAR); +///#endif + BEGD(d1); + /* we have met a preexisting dbterm */ + d1 = PREG->u.oD.D; + PREG = NEXTOP(PREG, oD); + traced_UnifyBound(d0,d1); + ENDD(d1); + + derefa_body(d0, pt0, traced_udbterm_unk, traced_udbterm_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_DBTERM_UDBTERM_UNK); +///#endif + BEGD(d1); + d1 = PREG->u.oD.D; + PREG = NEXTOP(PREG, oD); + Bind_Global(pt0, d1); + GONext(); + ENDD(d1); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_unify_l_dbterm, oD); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_DBTERM_INSTINIT); +///#endif + BEGD(d0); + CACHE_S(); + READ_IN_S(); + d0 = *S_SREG; + deref_head(d0, traced_uldbterm_unk); + traced_uldbterm_nonvar: +///#ifdef PROFILED_ABSMI + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_DBTERM_ULDBTERM_NONVAR); +///#endif + BEGD(d1); + /* we have met a preexisting dbterm */ + d1 = PREG->u.oD.D; + PREG = NEXTOP(PREG, oD); + traced_UnifyBound(d0,d1); + ENDD(d1); + + derefa_body(d0, S_SREG, traced_uldbterm_unk, traced_uldbterm_nonvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_DBTERM_ULDBTERM_UNK); +///#endif + BEGD(d1); + d1 = PREG->u.oD.D; + PREG = NEXTOP(PREG, oD); + Bind_Global(S_SREG, d1); + GONext(); + ENDD(d1); + ENDCACHE_S(); + ENDD(d0); + ENDOp(); + + OpRW(traced_unify_list, o); + EMIT_ENTRY_BLOCK(PREG,UNIFY_LIST_INSTINIT); + *--SP = Unsigned(SREG + 1); + *--SP = READ_MODE; + BEGD(d0); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_ulist_unk); + traced_ulist_nonvar: + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_LIST_READMODE); + if (!IsPairTerm(d0)) { + TRACED_FAIL(); + } + /* we continue in read mode */ + START_PREFETCH(o); + SREG = RepPair(d0); + PREG = NEXTOP(PREG, o); + GONext(); + END_PREFETCH(); + + profiled_derefa_body(d0, pt0, traced_ulist_unk, traced_ulist_nonvar); + EMIT_SIMPLE_BLOCK_TEST(UNIFY_LIST_WRITEMODE); + /* we enter write mode */ + START_PREFETCH_W(o); + CACHE_S(); + READ_IN_S(); + S_SREG = HR; + PREG = NEXTOP(PREG, o); + HR = S_SREG + 2; + d0 = AbsPair(S_SREG); + WRITEBACK_S(S_SREG); + ENDCACHE_S(); + Bind_Global(pt0, d0); + GONextW(); + END_PREFETCH_W(); + + ENDP(pt0); + + ENDD(d0); + ENDOpRW(); + + OpW(traced_unify_list_write, o); + EMIT_ENTRY_BLOCK(PREG,UNIFY_LIST_WRITE_INSTINIT); + PREG = NEXTOP(PREG, o); + BEGD(d0); + d0 = AbsPair(HR); + CACHE_S(); + READ_IN_S(); + SP -= 2; + SP[0] = WRITE_MODE; + SP[1] = Unsigned(S_SREG + 1); + S_SREG[0] = d0; + S_SREG = HR; + HR = S_SREG + 2; + WRITEBACK_S(S_SREG); + ENDCACHE_S(); + GONextW(); + ENDD(d0); + ENDOpW(); + + OpRW(traced_unify_l_list, o); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_LIST_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_ullist_unk); + traced_ullist_nonvar: + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_LIST_READMODE); + START_PREFETCH(o); + if (!IsPairTerm(d0)) { + TRACED_FAIL(); + } + /* we continue in read mode */ + PREG = NEXTOP(PREG, o); + SREG = RepPair(d0); + GONext(); + END_PREFETCH(); + + profiled_derefa_body(d0, pt0, traced_ullist_unk, traced_ullist_nonvar); + /* we enter write mode */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_LIST_WRITEMODE); + START_PREFETCH_W(o); + PREG = NEXTOP(PREG, o); + CACHE_S(); + READ_IN_S(); + S_SREG = HR; + HR = S_SREG + 2; + d0 = AbsPair(S_SREG); + WRITEBACK_S(S_SREG); + ENDCACHE_S(); + Bind_Global(pt0, d0); + GONextW(); + END_PREFETCH_W(); + + ENDP(pt0); + ENDD(d0); + ENDOpRW(); + + OpW(traced_unify_l_list_write, o); + /* we continue in write mode */ + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_LIST_WRITE_INSTINIT); + BEGD(d0); + d0 = AbsPair(HR); + PREG = NEXTOP(PREG, o); + CACHE_S(); + READ_IN_S(); + S_SREG[0] = d0; + S_SREG = HR; + HR = S_SREG + 2; + WRITEBACK_S(S_SREG); + ENDCACHE_S(); + GONextW(); + ENDD(d0); + ENDOpW(); + + OpRW(traced_unify_struct, ofa); + EMIT_ENTRY_BLOCK(PREG,UNIFY_STRUCT_INSTINIT); + *--SP = Unsigned(SREG + 1); + *--SP = READ_MODE; + BEGD(d0); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + START_PREFETCH(ofa); + profiled_deref_head_TEST(d0, traced_ustruct_unk); + traced_ustruct_nonvar: + /* we are in read mode */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_STRUCT_READMODE); + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } + CACHE_S(); + READ_IN_S(); + /* we continue in read mode */ + S_SREG = RepAppl(d0); + /* just check functor */ + d0 = (CELL) (PREG->u.ofa.f); + if (*S_SREG != d0) { + TRACED_FAIL(); + } + PREG = NEXTOP(PREG, ofa); + WRITEBACK_S(S_SREG+1); + ENDCACHE_S(); + GONext(); + END_PREFETCH(); + + profiled_derefa_body(d0, pt0, traced_ustruct_unk, traced_ustruct_nonvar); + /* Enter Write mode */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_STRUCT_WRITEMODE); + START_PREFETCH_W(ofa); + /* set d1 to be the new structure we are going to create */ + BEGD(d1); + d1 = AbsAppl(HR); + /* we know the variable must be in the heap */ + Bind_Global(pt0, d1); + /* now, set pt0 to point to the heap where we are going to + * build our term */ + pt0 = HR; + ENDD(d1); + /* first, put the functor */ + d0 = (CELL) (PREG->u.ofa.f); + *pt0++ = d0; + HR = pt0 + PREG->u.ofa.a; + PREG = NEXTOP(PREG, ofa); + /* set SREG */ + SREG = pt0; + /* update HR */ + GONextW(); + END_PREFETCH_W(); + + ENDP(pt0); + + ENDD(d0); + ENDOpRW(); + + OpW(traced_unify_struct_write, ofa); + EMIT_ENTRY_BLOCK(PREG,UNIFY_STRUCT_WRITE_INSTINIT); + CACHE_S(); + READ_IN_S(); + *--SP = Unsigned(S_SREG + 1); + *--SP = WRITE_MODE; + /* we continue in write mode */ + BEGD(d0); + d0 = AbsAppl(HR); + S_SREG[0] = d0; + S_SREG = HR; + d0 = (CELL) (PREG->u.ofa.f); + *S_SREG++ = d0; + HR = S_SREG + PREG->u.ofa.a; + PREG = NEXTOP(PREG, ofa); + WRITEBACK_S(S_SREG); + ENDCACHE_S(); + ENDD(d0); + GONextW(); + ENDOpW(); + + OpRW(traced_unify_l_struc, ofa); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_STRUC_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = SREG; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_ulstruct_unk); + traced_ulstruct_nonvar: + /* we are in read mode */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNIFY_L_STRUC_READMODE); + START_PREFETCH(ofa); + if (!IsApplTerm(d0)) { + TRACED_FAIL(); + } + /* we continue in read mode */ + SREG = RepAppl(d0); + /* just check functor */ + d0 = (CELL) (PREG->u.ofa.f); + if (*SREG++ != d0) { + TRACED_FAIL(); + } + PREG = NEXTOP(PREG, ofa); + GONext(); + END_PREFETCH(); + + profiled_derefa_body(d0, pt0, traced_ulstruct_unk, traced_ulstruct_nonvar); + /* Enter Write mode */ + EMIT_SIMPLE_BLOCK_TEST(UNIFY_L_STRUC_WRITEMODE); + /* set d1 to be the new structure we are going to create */ + START_PREFETCH_W(ofa); + BEGD(d1); + d1 = AbsAppl(HR); + /* we know the variable must be in the heap */ + Bind_Global(pt0, d1); + /* now, set pt0 to point to the heap where we are going to + * build our term */ + pt0 = HR; + ENDD(d1); + /* first, put the functor */ + d0 = (CELL) (PREG->u.ofa.f); + *pt0++ = d0; + HR = pt0 + PREG->u.ofa.a; + PREG = NEXTOP(PREG, ofa); + /* set SREG */ + SREG = pt0; + /* update HR */ + GONextW(); + END_PREFETCH_W(); + ENDP(pt0); + + ENDD(d0); + ENDOpRW(); + + OpW(traced_unify_l_struc_write, ofa); + EMIT_ENTRY_BLOCK(PREG,UNIFY_L_STRUC_WRITE_INSTINIT); + BEGD(d0); + d0 = AbsAppl(HR); + CACHE_S(); + READ_IN_S(); + S_SREG[0] = d0; + S_SREG = HR; + d0 = (CELL) (PREG->u.ofa.f); + *S_SREG++ = d0; + HR = S_SREG + PREG->u.ofa.a; + PREG = NEXTOP(PREG, ofa); + WRITEBACK_S(S_SREG); + ENDCACHE_S(); + ENDD(d0); + GONextW(); + ENDOpW(); + + +/************************************************************************\ +* Put Instructions * +\************************************************************************/ + + Op(traced_put_x_var, xx); + EMIT_ENTRY_BLOCK(PREG,PUT_X_VAR_INSTINIT); + BEGP(pt0); + pt0 = HR; + XREG(PREG->u.xx.xl) = Unsigned(pt0); + HR = pt0 + 1; + XREG(PREG->u.xx.xr) = Unsigned(pt0); + PREG = NEXTOP(PREG, xx); + RESET_VARIABLE(pt0); + ENDP(pt0); + GONext(); + ENDOp(); + + Op(traced_put_y_var, yx); + EMIT_ENTRY_BLOCK(PREG,PUT_Y_VAR_INSTINIT); + BEGP(pt0); + pt0 = YREG + PREG->u.yx.y; + XREG(PREG->u.yx.x) = (CELL) pt0; + PREG = NEXTOP(PREG, yx); +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + /* We must initialise a shared variable to point to the SBA */ + if (Unsigned((Int)(pt0)-(Int)(H_FZ)) > + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { + *pt0 = (CELL)STACK_TO_SBA(pt0); + } else +#endif /* YAPOR_SBA && FROZEN_STACKS */ + INITIALIZE_PERMVAR(pt0, (CELL)pt0); + ENDP(pt0); + GONext(); + ENDOp(); + + Op(traced_put_x_val, xx); + EMIT_ENTRY_BLOCK(PREG,PUT_X_VAL_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xx.xl); + XREG(PREG->u.xx.xr) = d0; + ENDD(d0); + PREG = NEXTOP(PREG, xx); + GONext(); + ENDOp(); + + Op(traced_put_xx_val, xxxx); + EMIT_ENTRY_BLOCK(PREG,PUT_XX_VAL_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.xxxx.xl1); + d1 = XREG(PREG->u.xxxx.xl2); + XREG(PREG->u.xxxx.xr1) = d0; + XREG(PREG->u.xxxx.xr2) = d1; + ENDD(d1); + ENDD(d0); + PREG = NEXTOP(PREG, xxxx); + GONext(); + ENDOp(); + + Op(traced_put_y_val, yx); + EMIT_ENTRY_BLOCK(PREG,PUT_Y_VAL_INSTINIT); + BEGD(d0); + d0 = YREG[PREG->u.yx.y]; +#ifdef YAPOR_SBA + if (d0 == 0) { /* new variable */ + XREG(PREG->u.yx.x) = (CELL)(YREG+PREG->u.yx.y); + } else +#endif + XREG(PREG->u.yx.x) = d0; + ENDD(d0); + PREG = NEXTOP(PREG, yx); + GONext(); + ENDOp(); + + Op(traced_put_y_vals, yyxx); + EMIT_ENTRY_BLOCK(PREG,PUT_Y_VALS_INSTINIT); + ALWAYS_START_PREFETCH(yyxx); + BEGD(d0); + d0 = YREG[PREG->u.yyxx.y1]; +#ifdef YAPOR_SBA + if (d0 == 0) /* new variable */ + XREG(PREG->u.yyxx.x1) = (CELL)(YREG+PREG->u.yyxx.y1); + else +#endif + XREG(PREG->u.yyxx.x1) = d0; + ENDD(d0); + /* allow for some prefetching */ + PREG = NEXTOP(PREG, yyxx); + BEGD(d1); + d1 = YREG[PREVOP(PREG,yyxx)->u.yyxx.y2]; +#ifdef YAPOR_SBA + if (d1 == 0) /* new variable */ + XREG(PREVOP(traced_PREG->u.yyxx,yyxx).x2) = (CELL)(YREG+PREG->u.yyxx.y2); + else +#endif + XREG(PREVOP(PREG,yyxx)->u.yyxx.x2) = d1; + ENDD(d1); + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + ENDOp(); + + Op(traced_put_unsafe, yx); + EMIT_ENTRY_BLOCK(PREG,PUT_UNSAFE_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = YREG+PREG->u.yx.y; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_punsafe_unk); + traced_punsafe_nonvar: + EMIT_SIMPLE_BLOCK_TEST(PUT_UNSAFE_PUNSAFE_NONVAR); + XREG(PREG->u.yx.x) = d0; + PREG = NEXTOP(PREG, yx); + GONext(); + + profiled_derefa_body(d0, pt0, traced_punsafe_unk, traced_punsafe_nonvar); + EMIT_SIMPLE_BLOCK_TEST(PUT_UNSAFE_PUNSAFE_UNK); + /* d0 is a variable, check whether we need to globalise it */ + if (pt0 <= HR || pt0 >= YREG) { + /* variable is safe */ + XREG(PREG->u.yx.x) = Unsigned(pt0); + PREG = NEXTOP(PREG, yx); + GONext(); + } + else { + /* create a new Heap variable and bind our variable to it */ + Bind_Local(pt0, Unsigned(HR)); + XREG(PREG->u.yx.x) = (CELL) HR; + RESET_VARIABLE(HR); + H++; + PREG = NEXTOP(PREG, yx); + GONext(); + } + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_put_atom, xc); + EMIT_ENTRY_BLOCK(PREG,PUT_ATOM_INSTINIT); + BEGD(d0); + d0 = PREG->u.xc.c; + XREG(PREG->u.xc.x) = d0; + PREG = NEXTOP(PREG, xc); + GONext(); + ENDD(d0); + ENDOp(); + + Op(traced_put_dbterm, xD); + EMIT_ENTRY_BLOCK(PREG,PUT_DBTERM_INSTINIT); + BEGD(d0); + d0 = PREG->u.xD.D; + XREG(PREG->u.xD.x) = d0; + PREG = NEXTOP(PREG, xD); + GONext(); + ENDD(d0); + ENDOp(); + + Op(traced_put_bigint, xN); + EMIT_ENTRY_BLOCK(PREG,PUT_BIGINT_INSTINIT); + BEGD(d0); + d0 = PREG->u.xN.b; + XREG(PREG->u.xN.x) = d0; + PREG = NEXTOP(PREG, xN); + GONext(); + ENDD(d0); + ENDOp(); + + Op(traced_put_float, xd); + EMIT_ENTRY_BLOCK(PREG,PUT_FLOAT_INSTINIT); + BEGD(d0); + d0 = AbsAppl(PREG->u.xd.d); + XREG(PREG->u.xd.x) = d0; + PREG = NEXTOP(PREG, xd); + GONext(); + ENDD(d0); + ENDOp(); + + Op(traced_put_longint, xi); + EMIT_ENTRY_BLOCK(PREG,PUT_LONGINT_INSTINIT); + BEGD(d0); + d0 = AbsAppl(PREG->u.xi.i); + XREG(PREG->u.xi.x) = d0; + PREG = NEXTOP(PREG, xi); + GONext(); + ENDD(d0); + ENDOp(); + + Op(traced_put_list, x); + EMIT_ENTRY_BLOCK(PREG,PUT_LIST_INSTINIT); + CACHE_S(); + READ_IN_S(); + S_SREG = HR; + HR += 2; + BEGD(d0); + d0 = AbsPair(S_SREG); + XREG(PREG->u.x.x) = d0; + PREG = NEXTOP(PREG, x); + ENDD(d0); + WRITEBACK_S(S_SREG); + ENDCACHE_S(); + GONext(); + ENDOp(); + + Op(traced_put_struct, xfa); + EMIT_ENTRY_BLOCK(PREG,PUT_STRUCT_INSTINIT); + BEGD(d0); + d0 = AbsAppl(HR); + XREG(PREG->u.xfa.x) = d0; + d0 = (CELL) (PREG->u.xfa.f); + *H++ = d0; + SREG = HR; + HR += PREG->u.xfa.a; + ENDD(d0); + PREG = NEXTOP(PREG, xfa); + GONext(); + ENDOp(); + +/************************************************************************\ +* Write Instructions * +\************************************************************************/ + + Op(traced_write_x_var, x); + EMIT_ENTRY_BLOCK(PREG,WRITE_X_VAR_INSTINIT); + XREG(PREG->u.x.x) = Unsigned(SREG); + PREG = NEXTOP(PREG, x); + RESET_VARIABLE(SREG); + SREG++; + GONext(); + ENDOp(); + + Op(traced_write_void, e); + EMIT_ENTRY_BLOCK(PREG,WRITE_VOID_INSTINIT); + PREG = NEXTOP(PREG, e); + RESET_VARIABLE(SREG); + SREG++; + GONext(); + ENDOp(); + + Op(traced_write_n_voids, s); + EMIT_ENTRY_BLOCK(PREG,WRITE_N_VOIDS_INSTINIT); + BEGD(d0); + d0 = PREG->u.s.s; + PREG = NEXTOP(PREG, s); + for (; d0 > 0; d0--) { + RESET_VARIABLE(SREG); + SREG++; + } + ENDD(d0); + GONext(); + ENDOp(); + + Op(traced_write_y_var, y); + EMIT_ENTRY_BLOCK(PREG,WRITE_Y_VAR_INSTINIT); + INITIALIZE_PERMVAR(YREG+PREG->u.y.y,Unsigned(SREG)); + PREG = NEXTOP(PREG, y); + RESET_VARIABLE(SREG); + SREG++; + GONext(); + ENDOp(); + + Op(traced_write_x_val, x); + EMIT_ENTRY_BLOCK(PREG,WRITE_X_VAL_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.x.x); + *SREG++ = d0; + ENDD(d0); + PREG = NEXTOP(PREG, x); + GONext(); + ENDOp(); + + Op(traced_write_x_loc, x); + EMIT_ENTRY_BLOCK(PREG,WRITE_X_LOC_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.x.x); + PREG = NEXTOP(PREG, x); + profiled_deref_head_TEST(d0, traced_w_x_unk); + traced_w_x_bound: + EMIT_SIMPLE_BLOCK_TEST(WRITE_X_LOC_W_X_BOUND); + *SREG++ = d0; + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_w_x_unk, traced_w_x_bound); + EMIT_SIMPLE_BLOCK_TEST(WRITE_X_LOC_W_X_UNK); +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + if (pt0 > HR && pt0<(CELL *)B_FZ) { +#else + if (pt0 > HR) { +#endif /* YAPOR_SBA && FROZEN_STACKS */ + /* local variable: let us bind it to the list */ +#ifdef FROZEN_STACKS /* TRAIL */ + Bind_Local(pt0, Unsigned(SREG)); +#else + TRAIL_LOCAL(pt0, Unsigned(SREG)); + *pt0 = Unsigned(SREG); +#endif /* FROZEN_STACKS */ + RESET_VARIABLE(SREG); + SREG++; + GONext(); + } + else { + *SREG++ = Unsigned(pt0); + GONext(); + } + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_write_y_val, y); + EMIT_ENTRY_BLOCK(PREG,WRITE_Y_VAL_INSTINIT); + BEGD(d0); + d0 = YREG[PREG->u.y.y]; +#ifdef YAPOR_SBA + if (d0 == 0) /* new variable */ + *SREG++ = (CELL)(YREG+PREG->u.y.y); + else +#endif + *SREG++ = d0; + ENDD(d0); + PREG = NEXTOP(PREG, y); + GONext(); + ENDOp(); + + Op(traced_write_y_loc, y); + EMIT_ENTRY_BLOCK(PREG,WRITE_Y_LOC_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = YREG+PREG->u.y.y; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_w_y_unk); + traced_w_y_bound: + EMIT_SIMPLE_BLOCK_TEST(WRITE_Y_LOC_W_Y_BOUND); + PREG = NEXTOP(PREG, y); + *SREG++ = d0; + GONext(); + + profiled_derefa_body(d0, pt0, traced_w_y_unk, traced_w_y_bound); + EMIT_SIMPLE_BLOCK_TEST(WRITE_Y_LOC_W_Y_UNK); + if (pt0 > HR +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) + && pt0<(CELL *)B_FZ +#endif /* YAPOR_SBA && FROZEN_STACKS */ + ) { + PREG = NEXTOP(PREG, y); + /* local variable: let us bind it to the list */ +#ifdef FROZEN_STACKS + Bind_Local(pt0, Unsigned(SREG)); +#else + *pt0 = Unsigned(SREG); + TRAIL_LOCAL(pt0, Unsigned(SREG)); +#endif /* FROZEN_STACKS */ + RESET_VARIABLE(SREG); + SREG++; + GONext(); + } else { + PREG = NEXTOP(PREG, y); + *SREG++ = Unsigned(pt0); + GONext(); + } + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_write_atom, c); + EMIT_ENTRY_BLOCK(PREG,WRITE_ATOM_INSTINIT); + BEGD(d0); + d0 = PREG->u.c.c; + *SREG++ = d0; + ENDD(d0); + PREG = NEXTOP(PREG, c); + GONext(); + ENDOp(); + + Op(traced_write_bigint, N); + EMIT_ENTRY_BLOCK(PREG,WRITE_BIGINT_INSTINIT); + BEGD(d0); + d0 = PREG->u.N.b; + *SREG++ = d0; + ENDD(d0); + PREG = NEXTOP(PREG, N); + GONext(); + ENDOp(); + + Op(traced_write_dbterm, D); + EMIT_ENTRY_BLOCK(PREG,WRITE_DBTERM_INSTINIT); + BEGD(d0); + d0 = PREG->u.D.D; + *SREG++ = d0; + ENDD(d0); + PREG = NEXTOP(PREG, D); + GONext(); + ENDOp(); + + Op(traced_write_float, d); + EMIT_ENTRY_BLOCK(PREG,WRITE_FLOAT_INSTINIT); + BEGD(d0); + d0 = AbsAppl(PREG->u.d.d); + *SREG++ = d0; + ENDD(d0); + PREG = NEXTOP(PREG, d); + GONext(); + ENDOp(); + + Op(traced_write_longint, i); + EMIT_ENTRY_BLOCK(PREG,WRITE_LONGIT_INSTINIT); + BEGD(d0); + d0 = AbsAppl(PREG->u.i.i); + *SREG++ = d0; + ENDD(d0); + PREG = NEXTOP(PREG, i); + GONext(); + ENDOp(); + + Op(traced_write_n_atoms, sc); + EMIT_ENTRY_BLOCK(PREG,WRITE_N_ATOMS_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = PREG->u.sc.s; + d1 = PREG->u.sc.c; + for (; d0 > 0; d0--) { + *SREG++ = d1; + } + ENDD(d1); + ENDD(d0); + PREG = NEXTOP(PREG, sc); + GONext(); + ENDOp(); + + Op(traced_write_list, e); + EMIT_ENTRY_BLOCK(PREG,WRITE_LIST_INSTINIT); + BEGD(d0); + d0 = AbsPair(HR); + *SREG++ = d0; + /* I will not actually store the mode in the stack */ + SP[-1] = Unsigned(SREG); + SP[-2] = 1; /* Put instructions follow the main stream */ + SP -= 2; + SREG = HR; + HR += 2; + ENDD(d0); + PREG = NEXTOP(PREG, e); + GONext(); + ENDOp(); + + Op(traced_write_l_list, e); + EMIT_ENTRY_BLOCK(PREG,WRITE_L_LIST_INSTINIT); + ALWAYS_START_PREFETCH(e); + PREG = NEXTOP(PREG, e); + BEGD(d0); + CACHE_S(); + READ_IN_S(); + d0 = AbsPair(HR); + *S_SREG = d0; + WRITEBACK_S(HR); + HR += 2; + ENDCACHE_S(); + ENDD(d0); + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + ENDOp(); + + Op(traced_write_struct, fa); + EMIT_ENTRY_BLOCK(PREG,WRITE_STRUCT_INSTINIT); + BEGD(d0); + d0 = AbsAppl(HR); + *SREG++ = d0; + SP[-1] = Unsigned(SREG); + SP[-2] = 1; /* Put instructions follow the main stream */ + SP -= 2; + d0 = (CELL) (PREG->u.fa.f); + *H++ = d0; + ENDD(d0); + BEGD(d0); + d0 = PREG->u.fa.a; + PREG = NEXTOP(PREG, fa); + SREG = HR; + HR += d0; + ENDD(d0); + GONext(); + ENDOp(); + + Op(traced_write_l_struc, fa); + EMIT_ENTRY_BLOCK(PREG,WRITE_L_STRUC_INSTINIT); + BEGD(d0); + d0 = AbsAppl(HR); + *SREG = d0; + d0 = (CELL) (PREG->u.fa.f); + *H++ = d0; + SREG = HR; + ENDD(d0); + BEGD(d0); + d0 = PREG->u.fa.a; + PREG = NEXTOP(PREG, fa); + HR += d0; + ENDD(d0); + GONext(); + ENDOp(); + +/************************************************************************\ +* Save last unified struct or list * +\************************************************************************/ + +/* vitor: I think I should kill these two instructions, by expanding the + * othe instructions. + */ + + Op(traced_save_pair_x, ox); + EMIT_ENTRY_BLOCK(PREG,SAVE_PAIR_X_INSTINIT); + XREG(PREG->u.ox.x) = AbsPair(SREG); + PREG = NEXTOP(PREG, ox); + GONext(); + ENDOp(); + + OpW(traced_save_pair_x_write, ox); + EMIT_ENTRY_BLOCK(PREG,SAVE_PAIR_X_WRITE_INSTINIT); + XREG(PREG->u.ox.x) = AbsPair(SREG); + PREG = NEXTOP(PREG, ox); + GONextW(); + ENDOpW(); + + Op(traced_save_pair_y, oy); + EMIT_ENTRY_BLOCK(PREG,SAVE_PAIR_Y_INSTINIT); + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,AbsPair(SREG)); + PREG = NEXTOP(PREG, oy); + GONext(); + ENDOp(); + + OpW(traced_save_pair_y_write, oy); + EMIT_ENTRY_BLOCK(PREG,SAVE_PAIR_Y_WRITE_INSTINIT); + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,AbsPair(SREG)); + PREG = NEXTOP(PREG, oy); + GONextW(); + ENDOpW(); + + Op(traced_save_appl_x, ox); + EMIT_ENTRY_BLOCK(PREG,SAVE_APPL_X_INSTINIT); + XREG(PREG->u.ox.x) = AbsAppl(SREG - 1); + PREG = NEXTOP(PREG, ox); + GONext(); + ENDOp(); + + OpW(traced_save_appl_x_write, ox); + EMIT_ENTRY_BLOCK(PREG,SAVE_APPL_X_WRITE_INSTINIT); + XREG(PREG->u.ox.x) = AbsAppl(SREG - 1); + PREG = NEXTOP(PREG, ox); + GONextW(); + ENDOpW(); + + Op(traced_save_appl_y, oy); + EMIT_ENTRY_BLOCK(PREG,SAVE_APPL_Y_INSTINIT); + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,AbsAppl(SREG-1)); + PREG = NEXTOP(PREG, oy); + GONext(); + ENDOp(); + + OpW(traced_save_appl_y_write, oy); + EMIT_ENTRY_BLOCK(PREG,SAVE_APPL_Y_WRITE_INSTINIT); + INITIALIZE_PERMVAR(YREG+PREG->u.oy.y,AbsAppl(SREG-1)); + PREG = NEXTOP(PREG, oy); + GONextW(); + ENDOpW(); + + +/************************************************************************\ +* Instructions for implemeting 'or;' * +\************************************************************************/ + + BOp(traced_jump, l); + EMIT_ENTRY_BLOCK(PREG,JUMP_INSTINIT); + PREG = PREG->u.l.l; + JMPNext(); + ENDBOp(); + + /* This instruction is called when the previous goal + was interrupted when waking up goals + */ + BOp(traced_move_back, l); + EMIT_ENTRY_BLOCK(PREG,MOVE_BACK_INSTINIT); + PREG = (yamop *)(((char *)PREG)-(Int)(NEXTOP((yamop *)NULL,Osbpp))); + JMPNext(); + ENDBOp(); + + /* This instruction is called when the previous goal + was interrupted when waking up goals + */ + BOp(traced_skip, l); + EMIT_ENTRY_BLOCK(PREG,SKIP_INSTINIT); + PREG = NEXTOP(PREG,l); + JMPNext(); + ENDBOp(); + + Op(traced_either, Osblp); + EMIT_ENTRY_BLOCK(PREG,EITHER_INSTINIT); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(EITHER_LOW_LEVEL_TRACER); + low_level_trace(try_or, (PredEntry *)PREG, NULL); + } +#endif +#ifdef COROUTINING + CACHE_Y_AS_ENV(YREG); + EMIT_SIMPLE_BLOCK_TEST(NoStackEither_Exception); + check_stack(NoStackEither, HR); + ENDCACHE_Y_AS_ENV(); +#endif + EMIT_SIMPLE_BLOCK_TEST(EITHER_POST_COROUTINING); + BEGD(d0); + /* Try to preserve the environment */ + d0 = PREG->u.Osblp.s; + BEGCHO(pt1); + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); + EMIT_SIMPLE_BLOCK_TEST(EITHER_FROZEN_YSBA); +#ifdef FROZEN_STACKS + choiceptr top_b = PROTECT_FROZEN_B(B); +#ifdef YAPOR_SBA + if (pt1 > top_b || pt1 < (choiceptr)H) + pt1 = top_b; +#else + if (pt1 > top_b) + pt1 = top_b; +#endif /* YAPOR_SBA */ +#else + if (pt1 > B) + pt1 = B; +#endif /* FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK_TEST(EITHER_POST_FROZEN_YSBA); + pt1 = (choiceptr)(((CELL *) pt1)-1); + *(CELL **) pt1 = YREG; + store_yaam_regs_for_either(PREG->u.Osblp.l, PREG); + SREG = (CELL *) (B = pt1); +#ifdef YAPOR + EMIT_SIMPLE_BLOCK_TEST(EITHER_YAPOR); + SCH_set_load(pt1); +#endif /* YAPOR */ + EMIT_SIMPLE_BLOCK_TEST(EITHER_END); + SET_BB(pt1); + ENDCHO(pt1); + /* skip the current instruction plus the next one */ + PREG = NEXTOP(NEXTOP(PREG, Osblp),l); + GONext(); + ENDD(d0); + ENDOp(); + + Op(traced_or_else, Osblp); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,OR_ELSE_INSTINIT); +///#endif + HR = HRBREG = PROTECT_FROZEN_H(B); + ENV = B->cp_env; + B->cp_cp = PREG; +#ifdef DEPTH_LIMIT +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(OR_ELSE_DEPTH); +///#endif + DEPTH = B->cp_depth; +#endif /* DEPTH_LIMIT */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(OR_ELSE_POST_DEPTH); +///#endif + SET_BB(PROTECT_FROZEN_B(B)); +#ifdef YAPOR + if (SCH_top_shared_cp(B)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(OR_ELSE_YAPOR); +///#endif + SCH_new_alternative(PREG, PREG->u.Osblp.l); + } else +#endif /* YAPOR */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(OR_ELSE_END); +///#endif + B->cp_ap = PREG->u.Osblp.l; + PREG = NEXTOP(PREG, Osblp); + YREG = (CELL *) B->cp_a1; + GONext(); + ENDOp(); + +#ifdef YAPOR + Op(traced_or_last, Osblp); +#else + Op(traced_or_last, p); +#endif /* YAPOR */ + EMIT_ENTRY_BLOCK(PREG,OR_LAST_INSTINIT); + BEGCHO(pt0); + pt0 = B; +#ifdef YAPOR + if (SCH_top_shared_cp(B)) { + EMIT_SIMPLE_BLOCK_TEST(OR_LAST_IFOK_INIT); + H = HRBREG = PROTECT_FROZEN_H(pt0); + YREG = (CELL *) pt0->cp_a1; + ENV = pt0->cp_env; +#ifdef DEPTH_LIMIT + EMIT_SIMPLE_BLOCK_TEST(OR_LAST_IFOK_DEPTH); + DEPTH = pt0->cp_depth; +#endif /* DEPTH_LIMIT */ + EMIT_SIMPLE_BLOCK_TEST(OR_LAST_IFOK_END); + SCH_new_alternative(PREG, NULL); + } + else +#endif /* YAPOR */ + { + EMIT_SIMPLE_BLOCK_TEST(OR_LAST_NOIF_INIT); + B = pt0->cp_b; + H = PROTECT_FROZEN_H(pt0); + YREG = (CELL *) pt0->cp_a1; + ENV = pt0->cp_env; +#ifdef DEPTH_LIMIT + EMIT_SIMPLE_BLOCK_TEST(OR_LAST_NOIF_DEPTH); + DEPTH = pt0->cp_depth; +#endif /* DEPTH_LIMIT */ + EMIT_SIMPLE_BLOCK_TEST(OR_LAST_NOIF_END); + HBREG = PROTECT_FROZEN_H(B); + } +#ifdef YAPOR + EMIT_SIMPLE_BLOCK_TEST(OR_LAST_YAPOR); + PREG = NEXTOP(PREG, Osblp); +#else + EMIT_SIMPLE_BLOCK_TEST(OR_LAST_NOYAPOR); + PREG = NEXTOP(PREG, p); +#endif /* YAPOR */ + EMIT_SIMPLE_BLOCK_TEST(OR_LAST_END); + SET_BB(PROTECT_FROZEN_B(B)); + GONext(); + ENDCHO(pt0); + ENDOp(); + +/************************************************************************\ +* Pop operations * +\************************************************************************/ + + OpRW(traced_pop_n, s); + /* write mode might have been called from read mode */ + EMIT_ENTRY_BLOCK(PREG,POP_N_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(POP_N_END); + BEGD(d0); + d0 = PREG->u.os.s; + SP = (CELL *) (((char *) SP) + d0); + ENDD(d0); + BEGD(d0); + d0 = SP[0]; + if (d0) { + START_PREFETCH(s); + SREG = (CELL *) (SP[1]); + SP += 2; + PREG = NEXTOP(PREG, s); + GONext(); + END_PREFETCH(); + } + else { + START_PREFETCH_W(s); + SREG = (CELL *) (SP[1]); + SP += 2; + PREG = NEXTOP(PREG, s); + GONextW(); + END_PREFETCH_W(); + } + ENDD(d0); + ENDOpRW(); + + OpRW(traced_pop, e); + EMIT_ENTRY_BLOCK(PREG,POP_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(POP_END); + BEGD(d0); + d0 = SP[0]; + SREG = (CELL *) (SP[1]); + SP += 2; + if (d0) { + START_PREFETCH(e); + PREG = NEXTOP(PREG, e); + GONext(); + END_PREFETCH(); + } + else { + START_PREFETCH_W(e); + PREG = NEXTOP(PREG, e); + GONextW(); + END_PREFETCH_W(); + } + ENDD(d0); + ENDOpRW(); + +/************************************************************************\ +* Call C predicates instructions * +\************************************************************************/ + + BOp(traced_call_cpred, Osbpp); + EMIT_ENTRY_BLOCK(PREG,CALL_CPRED_INSTINIT); + EMIT_SIMPLE_BLOCK_TEST(YAAM_CHECK_TRAIL_TR); + check_trail(TR); + EMIT_SIMPLE_BLOCK_TEST(CALL_CPRED_TEST_STACK); + if (!(PREG->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { + CACHE_Y_AS_ENV(YREG); + EMIT_SIMPLE_BLOCK_TEST(NoStackCall_Exception); + check_stack(NoStackCall, HR); + ENDCACHE_Y_AS_ENV(); + } +#ifdef FROZEN_STACKS + { + EMIT_SIMPLE_BLOCK_TEST(CALL_CPRED_FROZEN_INIT); + choiceptr top_b = PROTECT_FROZEN_B(B); + + EMIT_SIMPLE_BLOCK_TEST(CALL_CPRED_TOPB); +#ifdef YAPOR_SBA + if (YREG > (CELL *) top_b || YREG < HR) + ASP = (CELL *)top_b; +#else + if (YREG > (CELL *) top_b) + ASP = (CELL *)top_b; +#endif /* YAPOR_SBA */ + else + ASP = (CELL *)(((char *)YREG) + PREG->u.Osbpp.s); + } +#else + EMIT_SIMPLE_BLOCK_TEST(CALL_CPRED_NOFROZEN); + SET_ASP(YREG, PREG->u.Osbpp.s); + /* for slots to work */ +#endif /* FROZEN_STACKS */ +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(CALL_CPRED_LOW_LEVEL_TRACER); + low_level_trace(enter_pred,PREG->u.Osbpp.p,XREGS+1); + } +#endif /* LOW_LEVEL_TRACE */ + EMIT_SIMPLE_BLOCK_TEST(CALL_CPRED_POST_LOW_LEVEL_TRACER); + BEGD(d0); + CPredicate f = PREG->u.Osbpp.p->cs.f_code; + PREG = NEXTOP(PREG, Osbpp); + saveregs(); + d0 = (f)(PASS_REGS1); + setregs(); +#ifdef SHADOW_S + EMIT_SIMPLE_BLOCK_TEST(CALL_CPRED_SETSREG); + SREG = Yap_REGS.S_; +#endif + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_CPRED_END); + if (!d0) { + TRACED_FAIL(); + } + CACHE_A1(); + ENDD(d0); + JMPNext(); + ENDBOp(); + + /* execute Label */ + BOp(traced_execute_cpred, pp); + EMIT_ENTRY_BLOCK(PREG,EXECUTE_CPRED_INSTINIT); + EMIT_SIMPLE_BLOCK_TEST(YAAM_CHECK_TRAIL_TR); + check_trail(TR); + { + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_POST_CHECK_TRAIL); + PredEntry *pt0; + + BEGD(d0); + CACHE_Y_AS_ENV(YREG); +#ifdef FROZEN_STACKS + { + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_FROZEN); + choiceptr top_b = PROTECT_FROZEN_B(B); + + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_TOPB); +#ifdef YAPOR_SBA + if (YREG > (CELL *) top_b || YREG < HR) { + ASP = (CELL *)top_b; + } +#else + if (YREG > (CELL *) top_b) { + ASP = (CELL *)top_b; + } +#endif /* YAPOR_SBA */ + else { + ASP = YREG+E_CB; + } + } +#else + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_NOFROZEN); + SET_ASP(YREG, E_CB*sizeof(CELL)); + /* for slots to work */ +#endif /* FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_POST_FROZEN); + pt0 = PREG->u.pp.p; +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_LOW_LEVEL_TRACER); + low_level_trace(enter_pred,pt0,XREGS+1); + } +#endif /* LOW_LEVEL_TRACE */ + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_POST_LOW_LEVEL_TRACER); + CACHE_A1(); + BEGD(d0); + d0 = (CELL)B; +#ifndef NO_CHECKING + EMIT_SIMPLE_BLOCK_TEST(NoStackExecute_Exception); + check_stack(NoStackExecute, HR); +#endif + /* for profiler */ + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_SAVE_PC); + save_pc(); + ENV_YREG[E_CB] = d0; + ENDD(d0); +#ifdef DEPTH_LIMIT + if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is prolog */ + EMIT_CONDITIONAL_SUCCESS("DEPTH <= MkIntTerm(1)"); + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_DEPTH_MINOR); + if (pt0->ModuleOfPred) { + if (DEPTH == MkIntTerm(0)) { + TRACED_FAIL(); + } + else { + DEPTH = RESET_DEPTH(); + } + } + } else if (pt0->ModuleOfPred) { + EMIT_CONDITIONAL_FAIL("DEPTH <= MkIntTerm(1)"); + EMIT_CONDITIONAL_SUCCESS("pt0->ModuleOfPred"); + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_DEPTH_MOFPRED); + DEPTH -= MkIntConstant(2); + } + else { + EMIT_CONDITIONAL_FAIL("DEPTH <= MkIntTerm(1)"); + EMIT_CONDITIONAL_FAIL("pt0->ModuleOfPred"); + EMIT_SIMPLE_BLOCK_TEST(EXECUTE_CPRED_DEPTH_END); +} +#endif /* DEPTH_LIMIT */ + /* now call C-Code */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(EXECUTE_CPRED_END); + { + CPredicate f = PREG->u.pp.p->cs.f_code; + yamop *oldPREG = PREG; + saveregs(); + d0 = (f)(PASS_REGS1); + setregs(); +#ifdef SHADOW_S + SREG = Yap_REGS.S_; +#endif + if (!d0) { + TRACED_FAIL(); + } + if (oldPREG == PREG) { + /* we did not update PREG */ + /* we can proceed */ + PREG = CPREG; + ENV_YREG = ENV; +#ifdef DEPTH_LIMIT + DEPTH = ENV_YREG[E_DEPTH]; +#endif + WRITEBACK_Y_AS_ENV(); + } else { + /* call the new code */ + CACHE_A1(); + } + } + JMPNext(); + ENDCACHE_Y_AS_ENV(); + ENDD(d0); + } + ENDBOp(); + + /* Like previous, the only difference is that we do not */ + /* trust the C-function we are calling and hence we must */ + /* guarantee that *all* machine registers are saved and */ + /* restored */ + BOp(traced_call_usercpred, Osbpp); + EMIT_ENTRY_BLOCK(PREG,CALL_USERCPRED_INSTINIT); + CACHE_Y_AS_ENV(YREG); + EMIT_SIMPLE_BLOCK_TEST(NoStackCall_Exception); + check_stack(NoStackCall, HR); + ENDCACHE_Y_AS_ENV(); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(CALL_USERCPRED_LOW_LEVEL_TRACER); + low_level_trace(enter_pred,PREG->u.Osbpp.p,XREGS+1); + } +#endif /* LOW_LEVEL_TRACE */ + EMIT_SIMPLE_BLOCK_TEST(CALL_USERCPRED_FROZEN); +#ifdef FROZEN_STACKS + { + choiceptr top_b = PROTECT_FROZEN_B(B); +#ifdef YAPOR_SBA + if (YREG > (CELL *) top_b || YREG < HR) + ASP = (CELL *) top_b; +#else + if (YREG > (CELL *) top_b) + ASP = (CELL *) top_b; +#endif /* YAPOR_SBA */ + else + ASP = (CELL *)(((char *)YREG) + PREG->u.Osbpp.s); + } +#else + SET_ASP(YREG, PREG->u.Osbpp.s); + /* for slots to work */ +#endif /* FROZEN_STACKS */ + { + EMIT_SIMPLE_BLOCK_TEST(CALL_USERCPRED_POST_FROZEN); + /* make sure that we can still have access to our old PREG after calling user defined goals and backtracking or failing */ + yamop *savedP; + + Yap_StartSlots( PASS_REGS1 ); + LOCAL_PrologMode = UserCCallMode; + { + PredEntry *p = PREG->u.Osbpp.p; + + PREG = NEXTOP(PREG, Osbpp); + savedP = PREG; + saveregs(); + save_machine_regs(); + + SREG = (CELL *) YAP_Execute(p, p->cs.f_code); + } + Yap_CloseSlots( PASS_REGS1 ); + setregs(); + LOCAL_PrologMode = UserMode; + restore_machine_regs(); + PREG = savedP; + } + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_USERCPRED_END); + if (EX) { + struct DB_TERM *exp = EX; + EX = NULL; + Yap_JumpToEnv(Yap_PopTermFromDB(exp)); + } + if (!SREG) { + TRACED_FAIL(); + } + /* in case we call Execute */ + YENV = ENV; + YREG = ENV; + JMPNext(); + ENDBOp(); + + BOp(traced_call_c_wfail, slp); + //printf("call_c_wfail!!\n\n"); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + low_level_trace(enter_pred,PREG->u.slp.p,XREGS+1); + } +#endif /* LOW_LEVEL_TRACE */ +#ifdef FROZEN_STACKS + { + choiceptr top_b = PROTECT_FROZEN_B(B); +#ifdef YAPOR_SBA + if (YREG > (CELL *) top_b || YREG < HR) ASP = (CELL *) top_b; +#else + if (YREG > (CELL *) top_b) ASP = (CELL *) top_b; +#endif /* YAPOR_SBA */ + else { + BEGD(d0); + d0 = PREG->u.slp.s; + ASP = ((CELL *)YREG) + d0; + ENDD(d0); + } + } +#else + if (YREG > (CELL *) B) + ASP = (CELL *) B; + else { + BEGD(d0); + d0 = PREG->u.slp.s; + ASP = ((CELL *) YREG) + d0; + ENDD(d0); + } +#endif /* FROZEN_STACKS */ + { + CPredicate f = PREG->u.slp.p->cs.f_code; + saveregs(); + SREG = (CELL *)((f)(PASS_REGS1)); + setregs(); + } + if (!SREG) { + /* be careful about error handling */ + if (PREG != FAILCODE) + PREG = PREG->u.slp.l; + } else { + PREG = NEXTOP(PREG, slp); + } + CACHE_A1(); + JMPNext(); + ENDBOp(); + + BOp(traced_try_c, OtapFs); + //printf("try_c!!\n\n"); +#ifdef YAPOR + CUT_wait_leftmost(); +#endif /* YAPOR */ + CACHE_Y(YREG); +#ifdef CUT_C + /* Alocate space for the cut_c structure*/ + CUT_C_PUSH(NEXTOP(NEXTOP(PREG,OtapFs),OtapFs),S_YREG); +#endif + S_YREG = S_YREG - PREG->u.OtapFs.extra; + store_args(PREG->u.OtapFs.s); + store_yaam_regs(NEXTOP(PREG, OtapFs), 0); + B = B_YREG; +#ifdef YAPOR + SCH_set_load(B_YREG); +#endif /* YAPOR */ + SET_BB(B_YREG); + ENDCACHE_Y(); + + traced_TRYCC: + ASP = (CELL *)B; + { + CPredicate f = (CPredicate)(PREG->u.OtapFs.f); + saveregs(); + SREG = (CELL *) ((f) (PASS_REGS1)); + /* This last instruction changes B B*/ +#ifdef CUT_C + while (POP_CHOICE_POINT(B)){ + cut_c_pop(); + } +#endif + setregs(); + } + if (!SREG) { +#ifdef CUT_C + /* Removes the cut functions from the stack + without executing them because we have fail + and not cuted the predicate*/ + while(POP_CHOICE_POINT(B)) + cut_c_pop(); +#endif + TRACED_FAIL(); + } + if ((CELL *) B == YREG && ASP != (CELL *) B) { + /* as Luis says, the predicate that did the try C might + * have left some data on the stack. We should preserve + * it, unless the builtin also did cut */ + YREG = ASP; + HBREG = PROTECT_FROZEN_H(B); + SET_BB(B); + } + PREG = CPREG; + YREG = ENV; + JMPNext(); + ENDBOp(); + + BOp(traced_retry_c, OtapFs); + //printf("retry_c!!\n\n"); +#ifdef YAPOR + CUT_wait_leftmost(); +#endif /* YAPOR */ + CACHE_Y(B); + CPREG = B_YREG->cp_cp; + ENV = B_YREG->cp_env; + HR = PROTECT_FROZEN_H(B); +#ifdef DEPTH_LIMIT + DEPTH =B->cp_depth; +#endif + HRBREG = HR; + restore_args(PREG->u.OtapFs.s); + ENDCACHE_Y(); + goto traced_TRYCC; + ENDBOp(); + +#ifdef CUT_C + BOp(traced_cut_c, OtapFs); + //printf("cut_c!!\n"); + /*This is a phantom instruction. This is not executed by the WAM*/ +#ifdef DEBUG + /*If WAM executes this instruction, probably there's an error + when we put this instruction, cut_c, after retry_c*/ + printf ("ERROR: Should not print this message FILE: absmi.c %d\n",__LINE__); +#endif /*DEBUG*/ + ENDBOp(); +#endif + + BOp(traced_try_userc, OtapFs); + //printf("try_userc!!\n\n"); +#ifdef YAPOR + CUT_wait_leftmost(); +#endif /* YAPOR */ + CACHE_Y(YREG); +#ifdef CUT_C + /* Alocate space for the cut_c structure*/ + CUT_C_PUSH(NEXTOP(NEXTOP(PREG,OtapFs),OtapFs),S_YREG); +#endif + S_YREG = S_YREG - PREG->u.OtapFs.extra; + store_args(PREG->u.OtapFs.s); + store_yaam_regs(NEXTOP(PREG, OtapFs), 0); + B = B_YREG; +#ifdef YAPOR + SCH_set_load(B_YREG); +#endif + SET_BB(B_YREG); + ENDCACHE_Y(); + LOCAL_PrologMode = UserCCallMode; + ASP = YREG; + /* for slots to work */ + Yap_StartSlots( PASS_REGS1 ); + saveregs(); + save_machine_regs(); + SREG = (CELL *) YAP_ExecuteFirst(PREG->u.OtapFs.p, (CPredicate)(PREG->u.OtapFs.f)); + EX = 0L; + restore_machine_regs(); + setregs(); + LOCAL_PrologMode = UserMode; + Yap_CloseSlots( PASS_REGS1 ); + if (!SREG) { + TRACED_FAIL(); + } + if ((CELL *) B == YREG && ASP != (CELL *) B) { + /* as Luis says, the predicate that did the try C might + * have left some data on the stack. We should preserve + * it, unless the builtin also did cut */ + YREG = ASP; + HBREG = PROTECT_FROZEN_H(B); + } + PREG = CPREG; + YREG = ENV; + CACHE_A1(); + JMPNext(); + ENDBOp(); + + BOp(traced_retry_userc, OtapFs); + //printf("retry_userc!!\n\n"); +#ifdef YAPOR + CUT_wait_leftmost(); +#endif /* YAPOR */ + CACHE_Y(B); + CPREG = B_YREG->cp_cp; + ENV = B_YREG->cp_env; + HR = PROTECT_FROZEN_H(B); +#ifdef DEPTH_LIMIT + DEPTH =B->cp_depth; +#endif + HRBREG = HR; + restore_args(PREG->u.OtapFs.s); + ENDCACHE_Y(); + + LOCAL_PrologMode = UserCCallMode; + SET_ASP(YREG, E_CB*sizeof(CELL)); + /* for slots to work */ + Yap_StartSlots( PASS_REGS1 ); + saveregs(); + save_machine_regs(); + SREG = (CELL *) YAP_ExecuteNext(PREG->u.OtapFs.p, (CPredicate)(PREG->u.OtapFs.f)); + EX = 0L; + restore_machine_regs(); + setregs(); + LOCAL_PrologMode = UserMode; + Yap_CloseSlots( PASS_REGS1 ); + if (!SREG) { +#ifdef CUT_C + /* Removes the cut functions from the stack + without executing them because we have fail + and not cuted the predicate*/ + while(POP_CHOICE_POINT(B)) + cut_c_pop(); +#endif + TRACED_FAIL(); + } + if ((CELL *) B == YREG && ASP != (CELL *) B) { + /* as Luis says, the predicate that did the try C might + * have left some data on the stack. We should preserve + * it, unless the builtin also did cut */ + YREG = ASP; + HBREG = PROTECT_FROZEN_H(B); + } + PREG = CPREG; + YREG = ENV; + CACHE_A1(); + JMPNext(); + ENDBOp(); + +#ifdef CUT_C + BOp(traced_cut_userc, OtapFs); + //printf("cut_userc!!\n"); + /*This is a phantom instruction. This is not executed by the WAM*/ +#ifdef DEBUG + /*If WAM executes this instruction, probably there's an error + when we put this instruction, cut_userc, after retry_userc*/ + printf ("ERROR: Should not print this message FILE: absmi.c %d\n",__LINE__); +#endif /*DEBUG*/ + CACHE_A1(); + JMPNext(); + ENDBOp(); +#endif + + +/************************************************************************\ +* support instructions * +\************************************************************************/ + + BOp(traced_lock_pred, e); + { +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,LOCK_PRED_INSTINIT); +///#endif + PredEntry *ap = PredFromDefCode(PREG); + PELOCK(10,ap); + PP = ap; + if (!ap->cs.p_code.NOfClauses) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(LOCK_PRED_FIRSTIFOK); +///#endif + UNLOCKPE(11,ap); + TRACED_FAIL(); + } + /* + we do not lock access to the predicate, + we must take extra care here + */ + if (ap->cs.p_code.NOfClauses > 1 && + !(ap->PredFlags & IndexedPredFlag)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(LOCK_PRED_SECONDTIFOK); +///#endif + /* update ASP before calling IPred */ + SET_ASP(YREG, E_CB*sizeof(CELL)); + saveregs(); + Yap_IPred(ap, 0, CP); + /* IPred can generate errors, it thus must get rid of the lock itself */ + setregs(); + CACHE_A1(); + /* for profiler */ + save_pc(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(LOCK_PRED_END); +///#endif + PREG = ap->cs.p_code.TrueCodeOfPred; + } + JMPNext(); + ENDBOp(); + + BOp(traced_index_pred, e); + { + EMIT_ENTRY_BLOCK(PREG,INDEX_PRED_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(INDEX_PRED_END); + PredEntry *ap = PredFromDefCode(PREG); +#if defined(YAPOR) || defined(THREADS) + /* + we do not lock access to the predicate, + we must take extra care here + */ + if (!PP) { + PELOCK(11,ap); + } + if (ap->OpcodeOfPred != INDEX_OPCODE) { + /* someone was here before we were */ + if (!PP) { + UNLOCKPE(11,ap); + } + PREG = ap->CodeOfPred; + /* for profiler */ + save_pc(); + JMPNext(); + } +#endif + /* update ASP before calling IPred */ + SET_ASP(YREG, E_CB*sizeof(CELL)); + saveregs(); + Yap_IPred(ap, 0, CP); + /* IPred can generate errors, it thus must get rid of the lock itself */ + setregs(); + CACHE_A1(); + PREG = ap->CodeOfPred; + /* for profiler */ + save_pc(); +#if defined(YAPOR) || defined(THREADS) + if (!PP) +#endif + { + UNLOCKPE(14,ap); + } + + } + JMPNext(); + ENDBOp(); + +#if THREADS + BOp(traced_thread_local, e); + EMIT_ENTRY_BLOCK(PREG,THREAD_LOCAL_INSTINIT); + { + PredEntry *ap = PredFromDefCode(PREG); + ap = Yap_GetThreadPred(ap PASS_REGS); + PREG = ap->CodeOfPred; + /* for profiler */ + save_pc(); + } + JMPNext(); + ENDBOp(); +#endif + + BOp(traced_expand_index, e); + { + printf("expand index ainda não perfilado!\n"); + exit(1); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,EXPAND_INDEX_INSTINIT); +///#endif + PredEntry *pe = PredFromExpandCode(PREG); + yamop *pt0; + + /* update ASP before calling IPred */ + SET_ASP(YREG, E_CB*sizeof(CELL)); +#if defined(YAPOR) || defined(THREADS) + if (!PP) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_YAPOR_THREADS_NOPP); +///#endif + PELOCK(12,pe); + } + if (!same_lu_block(PREG_ADDR, PREG)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT); +///#endif + PREG = *PREG_ADDR; + if (!PP) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK); +///#endif + UNLOCKPE(15,pe); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_YAPOR_THREADS_IFOK_END); +///#endif + JMPNext(); + } +#endif +#ifdef SHADOW_S +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS); +///#endif + S = SREG; +#endif /* SHADOW_S */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS); +///#endif + saveregs(); + pt0 = Yap_ExpandIndex(pe, 0); + /* restart index */ + setregs(); +#ifdef SHADOW_S +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG); +///#endif + SREG = S; +#endif /* SHADOW_S */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG); +///#endif + PREG = pt0; +#if defined(YAPOR) || defined(THREADS) + if (!PP) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_UNLOCK); +///#endif + UNLOCKPE(12,pe); + } +#endif +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_INDEX_END); +///#endif + JMPNext(); + } + ENDBOp(); + + BOp(traced_expand_clauses, sssllp); + { +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,EXPAND_CLAUSES_INSTINIT); +///#endif + PredEntry *pe = PREG->u.sssllp.p; + yamop *pt0; + + /* update ASP before calling IPred */ + SET_ASP(YREG, E_CB*sizeof(CELL)); +#if defined(YAPOR) || defined(THREADS) + if (PP == NULL) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_CLAUSES_YAPOR_THREADS_NOPP); +///#endif + PELOCK(13,pe); + } + if (!same_lu_block(PREG_ADDR, PREG)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT); +///#endif + PREG = *PREG_ADDR; + if (!PP) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK); +///#endif + UNLOCKPE(16,pe); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END); +///#endif + JMPNext(); + } +#endif +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_CLAUSES_NOYAPOR_NOTHREADS); +///#endif + saveregs(); + pt0 = Yap_ExpandIndex(pe, 0); + /* restart index */ + setregs(); + UNLOCKPE(17,pe); + PREG = pt0; +#if defined(YAPOR) || defined(THREADS) + if (!PP) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_CLAUSES_UNLOCK); +///#endif + UNLOCKPE(18,pe); + } +#endif +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(EXPAND_CLAUSES_END); +///#endif + JMPNext(); + } + ENDBOp(); + + BOp(traced_undef_p, e); + /* save S for module name */ + EMIT_ENTRY_BLOCK(PREG,UNDEF_P_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(UNDEF_P_END); + { + PredEntry *pe = PredFromDefCode(PREG); + BEGD(d0); + /* avoid trouble with undefined dynamic procedures */ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { +#if defined(YAPOR) || defined(THREADS) + PP = NULL; +#endif + UNLOCKPE(19,pe); + TRACED_FAIL(); + } + d0 = pe->ArityOfPE; + UNLOCKPE(19,pe); + if (d0 == 0) { + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); + } + else { + HR[d0 + 2] = AbsAppl(HR); + *H = (CELL) pe->FunctorOfPred; + HR++; + BEGP(pt1); + pt1 = XREGS + 1; + for (; d0 > 0; --d0) { + BEGD(d1); + BEGP(pt0); + pt0 = pt1++; + d1 = *pt0; + deref_head(d1, traced_undef_unk); + traced_undef_nonvar: + /* just copy it to the heap */ + *H++ = d1; + continue; + + do { + (pt0) = (CELL *)(d1); + (d1) = *(CELL *)(d1); + if(!IsVarTerm(d1)) goto traced_undef_nonvar; + traced_undef_unk:; + } while (Unsigned(pt0) != (d1)); + + if (pt0 <= HR) { + /* variable is safe */ + *H++ = (CELL)pt0; + } else { + /* bind it, in case it is a local variable */ + d1 = Unsigned(HR); + RESET_VARIABLE(HR); + HR += 1; + Bind_Local(pt0, d1); + } + ENDP(pt0); + ENDD(d1); + } + ENDP(pt1); + } + ENDD(d0); + H[0] = Yap_Module_Name(pe); + ARG1 = (Term) AbsPair(HR); + H += 2; +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + low_level_trace(enter_pred,UndefCode,XREGS+1); + } +#endif /* LOW_LEVEL_TRACE */ + } + + PREG = UndefCode->CodeOfPred; + /* for profiler */ + save_pc(); + CACHE_A1(); + JMPNext(); + ENDBOp(); + + BOp(traced_spy_pred, e); + traced_dospy: + { +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,SPY_PRED_INSTINIT); +///#endif + PredEntry *pe = PredFromDefCode(PREG); + BEGD(d0); + PELOCK(14,pe); + if (!(pe->PredFlags & IndexedPredFlag) && + pe->cs.p_code.NOfClauses > 1) { + /* update ASP before calling IPred */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_FIRSTIFOK); +///#endif + SET_ASP(YREG, E_CB*sizeof(CELL)); + saveregs(); + Yap_IPred(pe, 0, CP); + /* IPred can generate errors, it thus must get rid of the lock itself */ + setregs(); + } + /* first check if we need to increase the counter */ + if ((pe->PredFlags & CountPredFlag)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_SECONDIFOK_INIT); +///#endif + LOCK(pe->StatisticsForPred.lock); + pe->StatisticsForPred.NOfEntries++; + UNLOCK(pe->StatisticsForPred.lock); + LOCAL_ReductionsCounter--; + if (LOCAL_ReductionsCounter == 0 && LOCAL_ReductionsCounterOn) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_SECONDIFOK_FIRSTIFOK); +///#endif + UNLOCKPE(20,pe); + saveregs(); + Yap_NilError(CALL_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_SECONDIFOK_POST_FIRSTIF); +///#endif + LOCAL_PredEntriesCounter--; + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_SECONDIFOK_SECONDIFOK); +///#endif + UNLOCKPE(21,pe); + saveregs(); + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); + setregs(); + JMPNext(); + } + if ((pe->PredFlags & (CountPredFlag|ProfiledPredFlag|SpiedPredFlag)) == + CountPredFlag) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_SECONDIFOK_THIRDIFOK); +///#endif + PREG = pe->cs.p_code.TrueCodeOfPred; + UNLOCKPE(22,pe); + JMPNext(); + } + } + /* standard profiler */ + if ((pe->PredFlags & ProfiledPredFlag)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_THIRDIFOK_INIT); +///#endif + LOCK(pe->StatisticsForPred.lock); + pe->StatisticsForPred.NOfEntries++; + UNLOCK(pe->StatisticsForPred.lock); + if (!(pe->PredFlags & SpiedPredFlag)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_THIRDIFOK_FIRSTIFOK); +///#endif + PREG = pe->cs.p_code.TrueCodeOfPred; + UNLOCKPE(23,pe); + JMPNext(); + } + } + if (!LOCAL_DebugOn) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_FOURTHIFOK); +///#endif + PREG = pe->cs.p_code.TrueCodeOfPred; + UNLOCKPE(24,pe); + JMPNext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_POST_FOURTHIF); +///#endif + UNLOCKPE(25,pe); + + d0 = pe->ArityOfPE; + /* save S for ModuleName */ + if (d0 == 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_D0ISZERO); +///#endif + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_D0ISNOZERO_INIT); +///#endif + *H = (CELL) pe->FunctorOfPred; + HR[d0 + 2] = AbsAppl(HR); + HR++; + BEGP(pt1); + pt1 = XREGS + 1; + for (; d0 > 0; --d0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT); +///#endif + BEGD(d1); + BEGP(pt0); + pt0 = pt1++; + d1 = *pt0; + deref_head(d1, traced_dospy_unk); + traced_dospy_nonvar: + /* just copy it to the heap */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR); +///#endif + *H++ = d1; + continue; + + derefa_body(d1, pt0, traced_dospy_unk, traced_dospy_nonvar); + if (pt0 <= HR) { + /* variable is safe */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR); +///#endif + *H++ = (CELL)pt0; + } else { + /* bind it, in case it is a local variable */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR); +///#endif + d1 = Unsigned(HR); + RESET_VARIABLE(HR); + HR += 1; + Bind_Local(pt0, d1); + } + ENDP(pt0); + ENDD(d1); + } + ENDP(pt1); + } + ENDD(d0); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_POST_IFS); +///#endif + H[0] = Yap_Module_Name(pe); + } + ARG1 = (Term) AbsPair(HR); + HR += 2; + { + PredEntry *pt0; +#ifdef THREADS +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_THREADS_LOCK); +///#endif + LOCK(GLOBAL_ThreadHandlesLock); +#endif +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_POST_LOCK); +///#endif + pt0 = SpyCode; + P_before_spy = PREG; + PREG = pt0->CodeOfPred; + /* for profiler */ +#ifdef THREADS +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_THREADS_UNLOCK); +///#endif + UNLOCK(GLOBAL_ThreadHandlesLock); +#endif +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_POST_UNLOCK); +///#endif + save_pc(); + CACHE_A1(); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_LOW_LEVEL_TRACER); +///#endif + low_level_trace(enter_pred,pt0,XREGS+1); + } +#endif /* LOW_LEVEL_TRACE */ + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(SPY_PRED_END); +///#endif + JMPNext(); + ENDBOp(); + + +/************************************************************************\ +* Try / Retry / Trust for main indexing blocks * +\************************************************************************/ + + BOp(traced_try_clause, Otapl); + EMIT_ENTRY_BLOCK(PREG,TRY_CLAUSE_INSTINIT); + check_trail(TR); + CACHE_Y(YREG); + /* Point AP to the code that follows this instruction */ + store_at_least_one_arg(PREG->u.Otapl.s); + store_yaam_regs(NEXTOP(PREG, Otapl), 0); + PREG = PREG->u.Otapl.d; + set_cut(S_YREG, B); + B = B_YREG; +#ifdef YAPOR + EMIT_SIMPLE_BLOCK_TEST(TRY_CLAUSE_YAPOR); + SCH_set_load(B_YREG); +#endif /* YAPOR */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(TRY_CLAUSE_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + JMPNext(); + ENDBOp(); + + BOp(traced_try_clause2, l); + EMIT_ENTRY_BLOCK(PREG,TRY_CLAUSE2_INSTINIT); + check_trail(TR); + CACHE_Y(YREG); + /* Point AP to the code that follows this instruction */ + { + register CELL x2 = ARG2; + register CELL x1 = ARG1; + + store_yaam_regs(NEXTOP(PREG, l), 2); + B_YREG->cp_a1 = x1; + B_YREG->cp_a2 = x2; + } + PREG = PREG->u.l.l; + set_cut(S_YREG, B); + B = B_YREG; +#ifdef YAPOR + EMIT_SIMPLE_BLOCK_TEST(TRY_CLAUSE2_YAPOR); + SCH_set_load(B_YREG); +#endif /* YAPOR */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(TRY_CLAUSE2_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + JMPNext(); + ENDBOp(); + + BOp(traced_try_clause3, l); + EMIT_ENTRY_BLOCK(PREG,TRY_CLAUSE3_INSTINIT); + check_trail(TR); + CACHE_Y(YREG); + /* Point AP to the code that follows this instruction */ + { + store_yaam_regs(NEXTOP(PREG, l), 3); + B_YREG->cp_a1 = ARG1; + B_YREG->cp_a2 = ARG2; + B_YREG->cp_a3 = ARG3; + } + PREG = PREG->u.l.l; + set_cut(S_YREG, B); + B = B_YREG; +#ifdef YAPOR + EMIT_SIMPLE_BLOCK_TEST(TRY_CLAUSE3_YAPOR); + SCH_set_load(B_YREG); +#endif /* YAPOR */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(TRY_CLAUSE3_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + JMPNext(); + ENDBOp(); + + BOp(traced_try_clause4, l); + EMIT_ENTRY_BLOCK(PREG,TRY_CLAUSE4_INSTINIT); + check_trail(TR); + CACHE_Y(YREG); + /* Point AP to the code that follows this instruction */ + { + store_yaam_regs(NEXTOP(PREG, l), 4); + B_YREG->cp_a1 = ARG1; + B_YREG->cp_a2 = ARG2; + B_YREG->cp_a3 = ARG3; + B_YREG->cp_a4 = ARG4; + } + PREG = PREG->u.l.l; + set_cut(S_YREG, B); + B = B_YREG; +#ifdef YAPOR + EMIT_SIMPLE_BLOCK_TEST(TRY_CLAUSE4_YAPOR); + SCH_set_load(B_YREG); +#endif /* YAPOR */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(TRY_CLAUSE4_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + JMPNext(); + ENDBOp(); + + BOp(traced_retry, Otapl); + EMIT_ENTRY_BLOCK(PREG,RETRY_INSTINIT); + CACHE_Y(B); + restore_yaam_regs(NEXTOP(PREG, Otapl)); + restore_at_least_one_arg(PREG->u.Otapl.s); +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK_TEST(RETRY_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + EMIT_SIMPLE_BLOCK_TEST(RETRY_NOFROZEN); + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(RETRY_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + PREG = PREG->u.Otapl.d; + JMPNext(); + ENDBOp(); + + BOp(traced_retry2, l); + EMIT_ENTRY_BLOCK(PREG,RETRY2_INSTINIT); + CACHE_Y(B); + restore_yaam_regs(NEXTOP(PREG, l)); + PREG = PREG->u.l.l; + ARG1 = B_YREG->cp_a1; + ARG2 = B_YREG->cp_a2; +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK_TEST(RETRY2_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + EMIT_SIMPLE_BLOCK_TEST(RETRY2_NOFROZEN); + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(RETRY2_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + JMPNext(); + ENDBOp(); + + BOp(traced_retry3, l); + EMIT_ENTRY_BLOCK(PREG,RETRY3_INSTINIT); + CACHE_Y(B); + restore_yaam_regs(NEXTOP(PREG, l)); + PREG = PREG->u.l.l; + ARG1 = B_YREG->cp_a1; + ARG2 = B_YREG->cp_a2; + ARG3 = B_YREG->cp_a3; +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK_TEST(RETRY3_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + EMIT_SIMPLE_BLOCK_TEST(RETRY3_NOFROZEN); + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(RETRY3_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + JMPNext(); + ENDBOp(); + + BOp(traced_retry4, l); + EMIT_ENTRY_BLOCK(PREG,RETRY4_INSTINIT); + CACHE_Y(B); + restore_yaam_regs(NEXTOP(PREG, l)); + PREG = PREG->u.l.l; + ARG1 = B_YREG->cp_a1; + ARG2 = B_YREG->cp_a2; + ARG3 = B_YREG->cp_a3; + ARG4 = B_YREG->cp_a4; +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK_TEST(RETRY4_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + EMIT_SIMPLE_BLOCK_TEST(RETRY4_NOFROZEN); + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(RETRY4_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + JMPNext(); + ENDBOp(); + + BOp(traced_trust, Otapl); + EMIT_ENTRY_BLOCK(PREG,TRUST_INSTINIT); + CACHE_Y(B); +#ifdef YAPOR + if (SCH_top_shared_cp(B)) { + EMIT_SIMPLE_BLOCK_TEST(TRUST_IFOK_INIT); + SCH_last_alternative(PREG, B_YREG); + restore_at_least_one_arg(PREG->u.Otapl.s); +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK_TEST(TRUST_IFOK_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + EMIT_SIMPLE_BLOCK_TEST(TRUST_IFOK_END); + set_cut(S_YREG, B->cp_b); + } + else +#endif /* YAPOR */ + { + EMIT_SIMPLE_BLOCK_TEST(TRUST_NOIF_INIT); + pop_yaam_regs(); + pop_at_least_one_arg(PREG->u.Otapl.s); +#ifdef FROZEN_STACKS + EMIT_SIMPLE_BLOCK_TEST(TRUST_NOIF_FROZEN); + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B); + } + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(TRUST_END); + SET_BB(B_YREG); + ENDCACHE_Y(); + PREG = PREG->u.Otapl.d; + JMPNext(); + ENDBOp(); + + BOp(traced_try_in, l); + EMIT_ENTRY_BLOCK(PREG,TRY_IN_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(TRY_IN_END); + B->cp_ap = NEXTOP(PREG, l); + PREG = PREG->u.l.l; + JMPNext(); + ENDBOp(); + + + +/************************************************************************\ +* Logical Updates * +\************************************************************************/ + + /* enter logical pred */ + BOp(traced_enter_lu_pred, Illss); + check_trail(TR); + /* mark the indexing code */ + { + LogUpdIndex *cl = PREG->u.Illss.I; + PredEntry *ap = cl->ClPred; + + if (ap->LastCallOfPred != LUCALL_EXEC) { + /* + only increment time stamp if we are working on current time + stamp + */ + if (ap->TimeStampOfPred >= TIMESTAMP_RESET) + Yap_UpdateTimestamps(ap); + ap->TimeStampOfPred++; + ap->LastCallOfPred = LUCALL_EXEC; + /* fprintf(stderr,"R %x--%d--%ul\n",ap,ap->TimeStampOfPred,ap->ArityOfPE);*/ + } + *--YREG = MkIntegerTerm(ap->TimeStampOfPred); + /* fprintf(stderr,"> %p/%p %d %d\n",cl,ap,ap->TimeStampOfPred,PREG->u.Illss.s);*/ + PREG = PREG->u.Illss.l1; + /* indicate the indexing code is being used */ +#if MULTIPLE_STACKS + /* just store a reference */ + INC_CLREF_COUNT(cl); + TRAIL_CLREF(cl); +#else + if (!(cl->ClFlags & InUseMask)) { + cl->ClFlags |= InUseMask; + TRAIL_CLREF(cl); + } +#endif + } + JMPNext(); + ENDBOp(); + + BOp(traced_try_logical, OtaLl); + check_trail(TR); + { + UInt timestamp; + + CACHE_Y(YREG); + timestamp = IntegerOfTerm(S_YREG[0]); + /* fprintf(stderr,"+ %p/%p %d %d %d--%u\n",PREG,PREG->u.OtaLl.d->ClPred,timestamp,PREG->u.OtaLl.d->ClPred->TimeStampOfPred,PREG->u.OtaLl.d->ClTimeStart,PREG->u.OtaLl.d->ClTimeEnd);*/ + /* Point AP to the code that follows this instruction */ + /* always do this, even if we are not going to use it */ + store_args(PREG->u.OtaLl.s); + store_yaam_regs(PREG->u.OtaLl.n, 0); + set_cut(S_YREG, B); + B = B_YREG; +#ifdef YAPOR + SCH_set_load(B_YREG); +#endif /* YAPOR */ +#ifdef YAPOR + PP = PREG->u.OtaLl.d->ClPred; +#endif /* YAPOR */ + if (!VALID_TIMESTAMP(timestamp, PREG->u.OtaLl.d)) { + /* jump to next alternative */ + PREG=PREG->u.OtaLl.n; + } else { + PREG = PREG->u.OtaLl.d->ClCode; + } + SET_BB(B_YREG); + ENDCACHE_Y(); + } + JMPNext(); + ENDBOp(); + + BOp(traced_retry_logical, OtaLl); + check_trail(TR); + { + UInt timestamp; + CACHE_Y(B); + +#if defined(YAPOR) || defined(THREADS) + if (!PP) { + PP = PREG->u.OtaLl.d->ClPred; + PELOCK(15,PP); + } +#endif + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[PREG->u.OtaLl.s]); + /* fprintf(stderr,"^ %p/%p %d %d %d--%u\n",PREG,PREG->u.OtaLl.d->ClPred,timestamp,PREG->u.OtaLl.d->ClPred->TimeStampOfPred,PREG->u.OtaLl.d->ClTimeStart,PREG->u.OtaLl.d->ClTimeEnd);*/ + if (!VALID_TIMESTAMP(timestamp, PREG->u.OtaLl.d)) { + /* jump to next instruction */ + PREG=PREG->u.OtaLl.n; + JMPNext(); + } + restore_yaam_regs(PREG->u.OtaLl.n); + restore_at_least_one_arg(PREG->u.OtaLl.s); +#ifdef THREADS + PP = PREG->u.OtaLl.d->ClPred; +#endif + PREG = PREG->u.OtaLl.d->ClCode; +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); + set_cut(S_YREG, B->cp_b); +#else + set_cut(S_YREG, B_YREG->cp_b); +#endif /* FROZEN_STACKS */ + SET_BB(B_YREG); + ENDCACHE_Y(); + } + JMPNext(); + ENDBOp(); + + BOp(traced_trust_logical, OtILl); + CACHE_Y(B); + { + LogUpdIndex *cl = PREG->u.OtILl.block; + PredEntry *ap = cl->ClPred; + LogUpdClause *lcl = PREG->u.OtILl.d; + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); + + /* fprintf(stderr,"- %p/%p %d %d %p\n",PREG,ap,timestamp,ap->TimeStampOfPred,PREG->u.OtILl.d->ClCode);*/ +#if defined(YAPOR) || defined(THREADS) + if (!PP) { + PELOCK(16,ap); + PP = ap; + } +#endif + if (!VALID_TIMESTAMP(timestamp, lcl)) { + /* jump to next alternative */ + PREG = FAILCODE; + } else { + PREG = lcl->ClCode; + } + /* HREY, leave indexing block alone!! */ + /* check if we are the ones using this code */ +#if MULTIPLE_STACKS + DEC_CLREF_COUNT(cl); + /* clear the entry from the trail */ + B->cp_tr--; + TR = B->cp_tr; + /* actually get rid of the code */ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { + if (PREG != FAILCODE) { + if (lcl->ClRefCount == 1) { + /* make sure the clause isn't destroyed */ + /* always add an extra reference */ + INC_CLREF_COUNT(lcl); + TRAIL_CLREF(lcl); + B->cp_tr = TR; + } + } + if (cl->ClFlags & ErasedMask) { + saveregs(); + Yap_ErLogUpdIndex(cl); + setregs(); + } else { + saveregs(); + Yap_CleanUpIndex(cl); + setregs(); + } + save_pc(); + } +#else + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && + B->cp_tr != B->cp_b->cp_tr) { + cl->ClFlags &= ~InUseMask; + B->cp_tr--; +#if FROZEN_STACKS + if (B->cp_tr > TR_FZ) +#endif + { + TR = B->cp_tr; + } + /* next, recover space for the indexing code if it was erased */ + if (cl->ClFlags & (ErasedMask|DirtyMask)) { + if (PREG != FAILCODE) { + /* make sure we don't erase the clause we are jumping too */ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { + lcl->ClFlags |= InUseMask; + TRAIL_CLREF(lcl); + B->cp_tr = TR; + } + } + if (cl->ClFlags & ErasedMask) { + saveregs(); + Yap_ErLogUpdIndex(cl); + setregs(); + } else { + saveregs(); + Yap_CleanUpIndex(cl); + setregs(); + } + } + } +#endif +#ifdef YAPOR + if (SCH_top_shared_cp(B)) { + SCH_last_alternative(PREG, B_YREG); + restore_args(ap->ArityOfPE); +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#else + S_YREG++; +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B->cp_b); + } else +#endif /* YAPOR */ + { + pop_yaam_regs(); + pop_args(ap->ArityOfPE); + S_YREG--; +#ifdef FROZEN_STACKS + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); +#endif /* FROZEN_STACKS */ + set_cut(S_YREG, B); + } + SET_BB(B_YREG); + ENDCACHE_Y(); +#if defined(YAPOR) || defined(THREADS) + if (PREG == FAILCODE) { + UNLOCKPE(26,PP); + PP = NULL; + } +#endif + JMPNext(); + } + ENDBOp(); + + +/************************************************************************\ +* Indexing in ARG1 * +\************************************************************************/ + + BOp(traced_user_switch, lp); + { + EMIT_ENTRY_BLOCK(PREG,USER_SWITCH_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(USER_SWITCH_END); + yamop *new = Yap_udi_search(PREG->u.lp.p); + if (!new) { + PREG = PREG->u.lp.l; + JMPNext(); + } + PREG = new; + JMPNext(); + } + ENDBOp(); + + BOp(traced_switch_on_type, llll); + EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_TYPE_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_TYPE_END); + BEGD(d0); + d0 = CACHED_A1(); + deref_head(d0, traced_swt_unk); + /* nonvar */ + traced_swt_nvar: + if (IsPairTerm(d0)) { + /* pair */ + SREG = RepPair(d0); + copy_jmp_address(PREG->u.llll.l1); + PREG = PREG->u.llll.l1; + JMPNext(); + } + else if (!IsApplTerm(d0)) { + /* constant */ + copy_jmp_address(PREG->u.llll.l2); + PREG = PREG->u.llll.l2; + I_R = d0; + JMPNext(); + } + else { + /* appl */ + copy_jmp_address(PREG->u.llll.l3); + PREG = PREG->u.llll.l3; + SREG = RepAppl(d0); + JMPNext(); + } + + BEGP(pt0); + do { + if(!IsVarTerm(d0)) goto traced_swt_nvar; + traced_swt_unk: + (pt0) = (CELL *)(d0); + (d0) = *(CELL *)(d0); + } while (Unsigned(pt0) != (d0)); + + /* variable */ + copy_jmp_address(PREG->u.llll.l4); + PREG = PREG->u.llll.l4; + JMPNext(); + ENDP(pt0); + ENDD(d0); + ENDBOp(); + + /* specialised case where the arguments may be: + * a list; + * the empty list; + * some other atom; + * a variable; + * + */ + BOp(traced_switch_list_nl, ollll); + EMIT_ENTRY_BLOCK(PREG,SWITCH_LIST_NL_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_LIST_NL_END); + ALWAYS_LOOKAHEAD(PREG->u.ollll.pop); + BEGD(d0); + d0 = CACHED_A1(); +#if UNIQUE_TAG_FOR_PAIRS + deref_list_head(d0, traced_swlnl_unk_p); + traced_swlnl_list_p: + { +#else + deref_head(d0, traced_swlnl_unk_p); + /* non variable */ + traced_swlnl_nvar_p: + if (__builtin_expect(IsPairTerm(d0),1)) { + /* pair */ +#endif + copy_jmp_address(PREG->u.ollll.l1); + PREG = PREG->u.ollll.l1; + SREG = RepPair(d0); + ALWAYS_GONext(); + } +#if UNIQUE_TAG_FOR_PAIRS + traced_swlnl_nlist_p: +#endif + if (d0 == TermNil) { + /* empty list */ + PREG = PREG->u.ollll.l2; + JMPNext(); + } + else { + /* appl or constant */ + if (IsApplTerm(d0)) { + copy_jmp_address(PREG->u.ollll.l3); + PREG = PREG->u.ollll.l3; + SREG = RepAppl(d0); + JMPNext(); + } else { + copy_jmp_address(PREG->u.ollll.l3); + PREG = PREG->u.ollll.l3; + I_R = d0; + JMPNext(); + } + } + + BEGP(pt0); +#if UNIQUE_TAG_FOR_PAIRS + traced_swlnl_unk_p: + deref_list_body(d0, pt0, traced_swlnl_list_p, traced_swlnl_nlist_p); +#else + deref_body(d0, pt0, traced_swlnl_unk_p, traced_swlnl_nvar_p); +#endif + ENDP(pt0); + /* variable */ + copy_jmp_address(PREG->u.ollll.l4); + PREG = PREG->u.ollll.l4; + JMPNext(); + ENDD(d0); + } + ENDBOp(); + + BOp(traced_switch_on_arg_type, xllll); + EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_ARG_TYPE_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_ARG_TYPE_END); + BEGD(d0); + d0 = XREG(PREG->u.xllll.x); + deref_head(d0, traced_arg_swt_unk); + /* nonvar */ + traced_arg_swt_nvar: + if (IsPairTerm(d0)) { + /* pair */ + copy_jmp_address(PREG->u.xllll.l1); + PREG = PREG->u.xllll.l1; + SREG = RepPair(d0); + JMPNext(); + } + else if (!IsApplTerm(d0)) { + /* constant */ + copy_jmp_address(PREG->u.xllll.l2); + PREG = PREG->u.xllll.l2; + I_R = d0; + JMPNext(); + } + else { + /* appl */ + copy_jmp_address(PREG->u.xllll.l3); + PREG = PREG->u.xllll.l3; + SREG = RepAppl(d0); + JMPNext(); + } + + BEGP(pt0); + deref_body(d0, pt0, traced_arg_swt_unk, traced_arg_swt_nvar); + /* variable */ + copy_jmp_address(PREG->u.xllll.l4); + PREG = PREG->u.xllll.l4; + JMPNext(); + ENDP(pt0); + ENDD(d0); + ENDBOp(); + + BOp(traced_switch_on_sub_arg_type, sllll); + EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_SUB_ARG_TYPE_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_SUB_ARG_TYPE_END); + BEGD(d0); + d0 = SREG[PREG->u.sllll.s]; + deref_head(d0, traced_sub_arg_swt_unk); + /* nonvar */ + traced_sub_arg_swt_nvar: + if (IsPairTerm(d0)) { + /* pair */ + copy_jmp_address(PREG->u.sllll.l1); + PREG = PREG->u.sllll.l1; + SREG = RepPair(d0); + JMPNext(); + } + else if (!IsApplTerm(d0)) { + /* constant */ + copy_jmp_address(PREG->u.sllll.l2); + PREG = PREG->u.sllll.l2; + I_R = d0; + JMPNext(); + } + else { + /* appl */ + copy_jmp_address(PREG->u.sllll.l3); + PREG = PREG->u.sllll.l3; + SREG = RepAppl(d0); + JMPNext(); + } + + BEGP(pt0); + do { + if(!IsVarTerm(d0)) goto traced_sub_arg_swt_nvar; + traced_sub_arg_swt_unk: + (pt0) = (CELL *)(d0); + (d0) = *(CELL *)(d0); + } while (Unsigned(pt0) != (d0)); + + /* variable */ + copy_jmp_address(PREG->u.sllll.l4); + PREG = PREG->u.sllll.l4; + JMPNext(); + ENDP(pt0); + ENDD(d0); + ENDBOp(); + + BOp(traced_jump_if_var, l); + EMIT_ENTRY_BLOCK(PREG,JUMP_IF_VAR_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(JUMP_IF_VAR_END); + BEGD(d0); + d0 = CACHED_A1(); + deref_head(d0, traced_jump_if_unk); + /* non var */ + traced_jump0_if_nonvar: + PREG = NEXTOP(PREG, l); + JMPNext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_jump_if_unk, traced_jump0_if_nonvar); + /* variable */ + copy_jmp_address(PREG->u.l.l); + PREG = PREG->u.l.l; + ENDP(pt0); + JMPNext(); + ENDD(d0); + ENDBOp(); + + BOp(traced_jump_if_nonvar, xll); + EMIT_ENTRY_BLOCK(PREG,JUMP_IF_NONVAR_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(JUMP_IF_NONVAR_END); + BEGD(d0); + d0 = XREG(PREG->u.xll.x); + deref_head(d0, traced_jump2_if_unk); + /* non var */ + traced_jump2_if_nonvar: + copy_jmp_address(PREG->u.xll.l1); + PREG = PREG->u.xll.l1; + JMPNext(); + + BEGP(pt0); + do { + if(!IsVarTerm(d0)) goto traced_jump2_if_nonvar; + traced_jump2_if_unk: + (pt0) = (CELL *)(d0); + (d0) = *(CELL *)(d0); + } while (Unsigned(pt0) != (d0)); + + /* variable */ + PREG = NEXTOP(PREG, xll); + ENDP(pt0); + JMPNext(); + ENDD(d0); + ENDBOp(); + + BOp(traced_if_not_then, clll); + EMIT_ENTRY_BLOCK(PREG,IF_NOT_THEN_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(IF_NOT_THEN_END); + BEGD(d0); + d0 = CACHED_A1(); + deref_head(d0, traced_if_n_unk); + traced_if_n_nvar: + /* not variable */ + if (d0 == PREG->u.clll.c) { + /* equal to test value */ + copy_jmp_address(PREG->u.clll.l2); + PREG = PREG->u.clll.l2; + JMPNext(); + } + else { + /* different from test value */ + /* the case to optimise */ + copy_jmp_address(PREG->u.clll.l1); + PREG = PREG->u.clll.l1; + JMPNext(); + } + + BEGP(pt0); + do { + if(!IsVarTerm(d0)) goto traced_if_n_nvar; + traced_if_n_unk: + (pt0) = (CELL *)(d0); + (d0) = *(CELL *)(d0); + } while (Unsigned(pt0) != (d0)); + + ENDP(pt0); + /* variable */ + copy_jmp_address(PREG->u.clll.l3); + PREG = PREG->u.clll.l3; + JMPNext(); + ENDD(d0); + ENDBOp(); + +/************************************************************************\ +* Indexing on ARG1 * +\************************************************************************/ + +#define HRASH_SHIFT 6 + + BOp(traced_switch_on_func, sssl); + EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_FUNC_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_FUNC_END); + BEGD(d1); + d1 = *SREG++; + /* we use a very simple hash function to find elements in a + * switch table */ + { + CELL + /* first, calculate the mask */ + Mask = (PREG->u.sssl.s - 1) << 1, /* next, calculate the hash function */ + hash = d1 >> (HRASH_SHIFT - 1) & Mask; + CELL *base; + + base = (CELL *)PREG->u.sssl.l; + /* PREG now points at the beginning of the hash table */ + BEGP(pt0); + /* pt0 will always point at the item */ + pt0 = base + hash; + BEGD(d0); + d0 = pt0[0]; + /* a match happens either if we found the value, or if we + * found an empty slot */ + if (d0 == d1 || d0 == 0) { + copy_jmp_addressa(pt0+1); + PREG = (yamop *) (pt0[1]); + JMPNext(); + } + else { + /* ooops, collision, look for other items */ + register CELL d = ((d1 | 1) << 1) & Mask; + + while (1) { + hash = (hash + d) & Mask; + pt0 = base + hash; + d0 = pt0[0]; + if (d0 == d1 || d0 == 0) { + copy_jmp_addressa(pt0+1); + PREG = (yamop *) pt0[1]; + JMPNext(); + } + } + } + ENDD(d0); + ENDP(pt0); + } + ENDD(d1); + ENDBOp(); + + BOp(traced_switch_on_cons, sssl); + EMIT_ENTRY_BLOCK(PREG,SWITCH_ON_CONS_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(SWITCH_ON_CONS_END); + BEGD(d1); + d1 = I_R; + /* we use a very simple hash function to find elements in a + * switch table */ + { + CELL + /* first, calculate the mask */ + Mask = (PREG->u.sssl.s - 1) << 1, /* next, calculate the hash function */ + hash = d1 >> (HRASH_SHIFT - 1) & Mask; + CELL *base; + + base = (CELL *)PREG->u.sssl.l; + /* PREG now points at the beginning of the hash table */ + BEGP(pt0); + /* pt0 will always point at the item */ + pt0 = base + hash; + BEGD(d0); + d0 = pt0[0]; + /* a match happens either if we found the value, or if we + * found an empty slot */ + if (d0 == d1 || d0 == 0) { + copy_jmp_addressa(pt0+1); + PREG = (yamop *) (pt0[1]); + JMPNext(); + } + else { + /* ooops, collision, look for other items */ + register CELL d = ((d1 | 1) << 1) & Mask; + + while (1) { + hash = (hash + d) & Mask; + pt0 = base + hash; + d0 = pt0[0]; + if (d0 == d1 || d0 == 0) { + copy_jmp_addressa(pt0+1); + PREG = (yamop *) pt0[1]; + JMPNext(); + } + } + } + ENDD(d0); + ENDP(pt0); + } + ENDD(d1); + ENDBOp(); + + BOp(traced_go_on_func, sssl); + EMIT_ENTRY_BLOCK(PREG,GO_ON_FUNC_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GO_ON_FUNC_END); + BEGD(d0); + { + CELL *pt = (CELL *)(PREG->u.sssl.l); + + d0 = *SREG++; + if (d0 == pt[0]) { + copy_jmp_addressa(pt+1); + PREG = (yamop *) pt[1]; + JMPNext(); + } else { + copy_jmp_addressa(pt+3); + PREG = (yamop *) pt[3]; + JMPNext(); + } + } + ENDD(d0); + ENDBOp(); + + BOp(traced_go_on_cons, sssl); + EMIT_ENTRY_BLOCK(PREG,GO_ON_CONS_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(GO_ON_CONS_END); + BEGD(d0); + { + CELL *pt = (CELL *)(PREG->u.sssl.l); + + d0 = I_R; + if (d0 == pt[0]) { + copy_jmp_addressa(pt+1); + PREG = (yamop *) pt[1]; + JMPNext(); + } else { + copy_jmp_addressa(pt+3); + PREG = (yamop *) pt[3]; + JMPNext(); + } + } + ENDD(d0); + ENDBOp(); + + BOp(traced_if_func, sssl); + EMIT_ENTRY_BLOCK(PREG,IF_FUNC_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(IF_FUNC_END); + BEGD(d1); + BEGP(pt0); + pt0 = (CELL *) PREG->u.sssl.l; + d1 = *SREG++; + while (pt0[0] != d1 && pt0[0] != (CELL)NULL ) { + pt0 += 2; + } + copy_jmp_addressa(pt0+1); + PREG = (yamop *) (pt0[1]); + JMPNext(); + ENDP(pt0); + ENDD(d1); + ENDBOp(); + + BOp(traced_if_cons, sssl); + EMIT_ENTRY_BLOCK(PREG,IF_CONS_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(IF_CONS_END); + BEGD(d1); + BEGP(pt0); + pt0 = (CELL *) PREG->u.sssl.l; + d1 = I_R; + while (pt0[0] != d1 && pt0[0] != 0L ) { + pt0 += 2; + } + copy_jmp_addressa(pt0+1); + PREG = (yamop *) (pt0[1]); + JMPNext(); + ENDP(pt0); + ENDD(d1); + ENDBOp(); + + Op(traced_index_dbref, e); + EMIT_ENTRY_BLOCK(PREG,INDEX_DBREF_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(INDEX_DBREF_END); + PREG = NEXTOP(PREG, e); + I_R = AbsAppl(SREG-1); + GONext(); + ENDOp(); + + Op(traced_index_blob, e); + EMIT_ENTRY_BLOCK(PREG,INDEX_BLOB_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(INDEX_BLOB_END); + PREG = NEXTOP(PREG, e); + I_R = Yap_DoubleP_key(SREG); + GONext(); + ENDOp(); + + Op(traced_index_long, e); + EMIT_ENTRY_BLOCK(PREG,INDEX_LONG_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(INDEX_LONG_END); + PREG = NEXTOP(PREG, e); + I_R = Yap_IntP_key(SREG); + GONext(); + ENDOp(); + + + +/************************************************************************\ +* Native Code Execution * +\************************************************************************/ + + /* native_me */ + BOp(traced_jit_handler, jhc); + + /* Needs to recompile */ + if (PREG->u.jhc.jh->jitman.torecomp) { + /* First: recompile on Smart JIT */ + if (ExpEnv.config_struc.execution_mode == SMART_JIT) { + PREG->u.jhc.jh->jitman.torecomp = 0; + recompile((void*)PREG); + if (NativeArea->area.p[PREG->u.jhc.jh->caa.naddress]) + goto native_lbl; + else { + PREG->u.jhc.jh->caa.taddress = -1; + PREG->u.jhc.jh->caa.naddress = -1; +#if YAP_DBG_PREDS + print_main_when_head(PREG, ON_PROFILED_INTERPRETER); +#endif + PREG = NEXTOP(PREG, jhc); + JMPNext(); + } + } + /* Recompile on Continuous compilation */ + else if (ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { + CELL i = 0; + while (i < ExpEnv.config_struc.compilation_threads && ExpEnv.config_struc.posthreads[i]) i++; + if (!ExpEnv.config_struc.posthreads[i]) { + yamop* pt = PREG; + ExpEnv.config_struc.posthreads[i] = 1; + PREG->u.jhc.jh->jitman.used_thread = i; + if(pthread_create(&ExpEnv.config_struc.threaded_compiler_threads[i], NULL, recompile, (void*)pt)) { + fprintf(stderr, "Error creating thread\n"); + exit(1); + } + PREG->u.jhc.jh->jitman.torecomp = 0; +#if YAP_DBG_PREDS + print_main_when_head(PREG, ON_PROFILED_INTERPRETER); +#endif + PREG = NEXTOP(PREG, jhc); + JMPNext(); + } + else if (i == ExpEnv.config_struc.compilation_threads) { +#if YAP_DBG_PREDS + print_main_when_head(PREG, ON_PROFILED_INTERPRETER); +#endif + PREG = NEXTOP(PREG, jhc); + JMPNext(); + } + } + } + /* Does not need to recompile */ + else { + /* Do I have native function to execute? */ + if (PREG->u.jhc.jh->caa.naddress != -1 && NativeArea->area.p && NativeArea->area.p[PREG->u.jhc.jh->caa.naddress] && NativeArea->area.ok[PREG->u.jhc.jh->caa.naddress]) { + /* Yes, I do */ + native_lbl:; + void* (*callee)(yamop**,yamop**,CELL**,void*[],void*[]); + void* go; + callee = (void*(*)(yamop**,yamop**,CELL**,void*[],void*[]))NativeArea->area.p[PREG->u.jhc.jh->caa.naddress]; + + HREADPREG = PREG; +#if YAP_STAT_PREDS + getrusage(RUSAGE_SELF, &rustart); +#endif +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.pprint_me.nativerun_init != 0 && ExpEnv.debug_struc.pprint_me.nativerun_init != 0x1) { + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.nativerun_init); + } +#endif + go = (*callee)(&PREG, &CPREG, &SREG, control_labels, OpAddress); +#if YAP_STAT_PREDS + getrusage(RUSAGE_SELF, &ruend); + timstart = rustart.ru_utime; + timend = ruend.ru_utime; + NativeArea->t_runs[HEADPREG->u.jhc.jh->caa.naddress] += (((double)timend.tv_sec - (double)timstart.tv_sec) + ((double)timend.tv_usec - (double)timstart.tv_usec) / 1000000.0); + //fprintf(stdout, "Executou nativo!!\n\n"); +#endif + + /* Do I need to recompile? */ + if (HREADPREG->u.jhc.jh->jitman.torecomp) { + /* Yes. Manage intermediate code so that emitted BBs append to right last block */ + IntermediatecodeArea->area.isactive[HEADPREG->u.jhc.jh->caa.taddress] = 1; + BlocksContext* b = IntermediatecodeArea->area.t[HEADPREG->u.jhc.jh->caa.taddress]->bc; + set_last_deeply(b, &(IntermediatecodeArea->area.lastblock[HEADPREG->u.jhc.jh->caa.taddress])); + } + + goto *go; + } + /* No, I don't. So, Did PREG reach threshold value to become hot? */ + else if (PREG->u.jhc.jh->fi.bcst.c == ExpEnv.config_struc.frequency_bound && PREG->u.jhc.jh->caa.taddress != -1 && IntermediatecodeArea->area.t && IntermediatecodeArea->area.t[PREG->u.jhc.jh->caa.taddress] && IntermediatecodeArea->area.ok[PREG->u.jhc.jh->caa.taddress]) { + /* Yes, it did */ + if (ExpEnv.config_struc.useonlypi) { + /* Don't compile. Use only profiled insts. + This will be executed only if "only_profiled_interpreter" is used */ + IntermediatecodeArea->area.isactive[PREG->u.jhc.jh->caa.taddress] = 0; + PREG->u.jhc.jh->fi.bcst.c = 2*ExpEnv.config_struc.frequency_bound; +#if YAP_DBG_PREDS + print_main_when_head(PREG, ON_PROFILED_INTERPRETER); + PREG = NEXTOP(PREG, jhc); +#endif + JMPNext(); + } + + /* Compile on Smart JIT */ + if (ExpEnv.config_struc.execution_mode == SMART_JIT) { + compile((void*)PREG); + PREG->u.jhc.jh->fi.bcst.c = 2*ExpEnv.config_struc.frequency_bound; + if (PREG->u.jhc.jh->caa.naddress != -1 && NativeArea->area.p[PREG->u.jhc.jh->caa.naddress]) // success + goto native_lbl; + else { // fail +#if YAP_DBG_PREDS + print_main_when_head(PREG, ON_PROFILED_INTERPRETER); +#endif + PREG = NEXTOP(PREG, jhc); + JMPNext(); + } + } + /* Compile on Continuous compilation */ + else if (ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { + CELL i = 0; + /* verifying thread availability */ + while (i < ExpEnv.config_struc.compilation_threads && ExpEnv.config_struc.posthreads[i]) i++; + if (!ExpEnv.config_struc.posthreads[i]) { + /* I have available thread */ + yamop* pt = PREG; + ExpEnv.config_struc.posthreads[i] = 1; + PREG->u.jhc.jh->jitman.used_thread = i; + if(pthread_create(&ExpEnv.config_struc.threaded_compiler_threads[i], NULL, compile, (void*)pt)) { + fprintf(stderr, "Error creating thread\n"); + exit(1); + } + PREG->u.jhc.jh->fi.bcst.c = 2*ExpEnv.config_struc.frequency_bound; +#if YAP_DBG_PREDS + print_main_when_head(PREG, ON_PROFILED_INTERPRETER); +#endif + PREG = NEXTOP(PREG, jhc); + JMPNext(); + } + else if (i == ExpEnv.config_struc.compilation_threads) { + /* I don't have */ +#if YAP_DBG_PREDS + print_main_when_head(PREG, ON_PROFILED_INTERPRETER); + PREG = NEXTOP(PREG, jhc); +#endif + JMPNext(); + } + } + } + /* No, I don't have native pointer to execute and PREG did not become hot */ + else { + if (!PREG->u.jhc.jh->fi.bcst.c) PREG->u.jhc.jh->mf.isground = IsGround(PREG); + PREG->u.jhc.jh->fi.bcst.c++; + + /* Did PREG reach threshold value to become critical? */ + if (PREG->u.jhc.jh->fi.bcst.c == (COUNT)(ExpEnv.config_struc.frequency_bound*(ExpEnv.config_struc.profiling_startp)) && !PREG->u.jhc.jh->mf.isground) { + /* Yes, it did + So... */ + critical_lbl:; + { + /* Set displacement */ + ExpEnv.config_struc.current_displacement = ExpEnv.config_struc.TOTAL_OF_OPCODES; + /* Init new trace with NATIVE_ME_INSTINIT as first BB and ...*/ + EMIT_ENTRY_BLOCK(PREG,JIT_HANDLER_INSTINIT); + IntermediatecodeArea->area.t = (TraceContext**)realloc(IntermediatecodeArea->area.t, (IntermediatecodeArea->n+1)*sizeof(TraceContext*)); + IntermediatecodeArea->area.ok = (COUNT*)realloc(IntermediatecodeArea->area.ok, (IntermediatecodeArea->n+1)*sizeof(COUNT)); + IntermediatecodeArea->area.isactive = (COUNT*)realloc(IntermediatecodeArea->area.isactive, (IntermediatecodeArea->n+1)*sizeof(COUNT)); + IntermediatecodeArea->area.lastblock = (BlocksContext**)realloc(IntermediatecodeArea->area.lastblock, (IntermediatecodeArea->n+1)*sizeof(BlocksContext*)); +#if YAP_STAT_PREDS + IntermediatecodeArea->area.profiling_time = (double*)realloc(IntermediatecodeArea->area.profiling_time, (IntermediatecodeArea->n+1)*sizeof(double)); +#endif + PREG->u.jhc.jh->caa.taddress = IntermediatecodeArea->n; + IntermediatecodeArea->n += 1; + IntermediatecodeArea->area.isactive[PREG->u.jhc.jh->caa.taddress] = 1; + IntermediatecodeArea->area.ok[PREG->u.jhc.jh->caa.taddress] = 1; + IntermediatecodeArea->area.t[PREG->u.jhc.jh->caa.taddress] = (TraceContext*)malloc(sizeof(TraceContext)); + IntermediatecodeArea->area.t[PREG->u.jhc.jh->caa.taddress]->bc = NULL; + IntermediatecodeArea->area.t[PREG->u.jhc.jh->caa.taddress]->tracesize = 0; + IntermediatecodeArea->area.t[PREG->u.jhc.jh->caa.taddress]->n = 0; + curtrace = &IntermediatecodeArea->area.t[PREG->u.jhc.jh->caa.taddress]; + headoftrace = PREG; + ineedredefinedest = 0; + /* Define NATIVE_ME_INSTINIT as simple BB on traces initialized before the latter */ + EMIT_HEAD_BLOCK(PREG); + IntermediatecodeArea->area.lastblock[PREG->u.jhc.jh->caa.taddress] = (*curtrace)->bc; + } + } + else if (PREG->u.jhc.jh->fi.bcst.c >= (COUNT)(ExpEnv.config_struc.frequency_bound*(ExpEnv.config_struc.profiling_startp)) && PREG->u.jhc.jh->fi.bcst.c < ExpEnv.config_struc.frequency_bound && !PREG->u.jhc.jh->mf.isground) { + /* No, PREG is critical but still not hot */ + EMIT_ENTRY_BLOCK(PREG,JIT_HANDLER_INSTINIT); + { + curtrace = &IntermediatecodeArea->area.t[PREG->u.jhc.jh->caa.taddress]; + headoftrace = PREG; + ineedredefinedest = 0; + EMIT_HEAD_BLOCK(PREG); + IntermediatecodeArea->area.lastblock[PREG->u.jhc.jh->caa.taddress] = (*curtrace)->bc; + } + } + else { + /* PREG is not critical */ + EMIT_ENTRY_BLOCK(PREG,JIT_HANDLER_INSTINIT); + } +#if YAP_DBG_PREDS + print_main_when_head(PREG, ON_PROFILED_INTERPRETER); +#endif + PREG = NEXTOP(PREG, jhc); + JMPNext(); + } + } + ENDBOp(); + + + +/************************************************************************\ +* Basic Primitive Predicates * +\************************************************************************/ + + Op(traced_p_atom_x, xl); + EMIT_ENTRY_BLOCK(PREG,P_ATOM_X_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + profiled_deref_head_TEST(d0, traced_atom_x_unk); + traced_atom_x_nvar: + if (IsAtomTerm(d0) && !IsBlob(AtomOfTerm(d0))) { + EMIT_SIMPLE_BLOCK_TEST(P_ATOM_X_ATOM); + PREG = NEXTOP(PREG, xl); + GONext(); + } + else { + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_ATOM_X_NOATOM); + PREG = PREG->u.xl.F; + GONext(); + } + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_atom_x_unk, traced_atom_x_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_ATOM_X_NOATOM); + PREG = PREG->u.xl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_atom_y, yl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_ATOM_Y_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + deref_head(d0, traced_atom_y_unk); + traced_atom_y_nvar: + if (IsAtomTerm(d0) && !IsBlob(AtomOfTerm(d0))) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ATOM_Y_IFOK); +///#endif + PREG = NEXTOP(PREG, yl); + GONext(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ATOM_Y_NOIF); +///#endif + PREG = PREG->u.yl.F; + GONext(); + } + + derefa_body(d0, pt0, traced_atom_y_unk, traced_atom_y_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ATOM_Y_END); +//#endif + PREG = PREG->u.yl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_atomic_x, xl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_ATOMIC_X_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + deref_head(d0, traced_atomic_x_unk); + traced_atomic_x_nvar: + /* non variable */ + if (IsAtomicTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ATOMIC_X_NONVAR); +///#endif + PREG = NEXTOP(PREG, xl); + GONext(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ATOMIC_X_VAR); +///#endif + PREG = PREG->u.xl.F; + GONext(); + } + + BEGP(pt0); + deref_body(d0, pt0, traced_atomic_x_unk, traced_atomic_x_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ATOMIC_X_END); +//#endif + PREG = PREG->u.xl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_atomic_y, yl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_ATOMIC_Y_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + deref_head(d0, traced_atomic_y_unk); + traced_atomic_y_nvar: + /* non variable */ + if (IsAtomicTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ATOMIC_Y_NONVAR); +///#endif + PREG = NEXTOP(PREG, yl); + GONext(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ATOMIC_Y_VAR); +//#endif + PREG = PREG->u.yl.F; + GONext(); + } + + derefa_body(d0, pt0, traced_atomic_y_unk, traced_atomic_y_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ATOMIC_Y_END); +///#endif + PREG = PREG->u.yl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_integer_x, xl); + EMIT_ENTRY_BLOCK(PREG,P_INTEGER_X_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + profiled_deref_head_TEST(d0, traced_integer_x_unk); + traced_integer_x_nvar: + /* non variable */ + if (IsIntTerm(d0)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_INTEGER_X_INTEGER_X_NVAR_OK); + PREG = NEXTOP(PREG, xl); + GONext(); + } + if (IsApplTerm(d0)) { + Functor f0 = FunctorOfTerm(d0); + if (IsExtensionFunctor(f0)) { + switch ((CELL)f0) { + case (CELL)FunctorLongInt: + case (CELL)FunctorBigInt: + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_CONDITIONAL_SUCCESS("IsApplTerm(d0)"); + EMIT_CONDITIONAL_SUCCESS("IsExtensionFunctor(f0)"); + EMIT_CONDITIONAL_SUCCESS("(CELL)f0 == (CELL)FunctorLongInt || (CELL)f0 == (CELL)FunctorBigInt"); + EMIT_SIMPLE_BLOCK_TEST(P_INTEGER_X_INTEGER_X_NVAR_OK); + PREG = NEXTOP(PREG, xl); + GONext(); + default: + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_CONDITIONAL_SUCCESS("IsApplTerm(d0)"); + EMIT_CONDITIONAL_SUCCESS("IsExtensionFunctor(f0)"); + EMIT_CONDITIONAL_FAIL("(CELL)f0 == (CELL)FunctorLongInt || (CELL)f0 == (CELL)FunctorBigInt"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_INTEGER_X_INTEGER_X_NVAR_NOOK); + PREG = PREG->u.xl.F; + GONext(); + } + } + } + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_CONDITIONAL_FAIL("IsApplTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_INTEGER_X_INTEGER_X_NVAR_NOOK); + PREG = PREG->u.xl.F; + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_integer_x_unk, traced_integer_x_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_INTEGER_X_INTEGER_X_UNK); + PREG = PREG->u.xl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_integer_y, yl); + EMIT_ENTRY_BLOCK(PREG,P_INTEGER_Y_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_integer_y_unk); + traced_integer_y_nvar: + /* non variable */ + if (IsIntTerm(d0)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_INTEGER_Y_INTEGER_Y_NVAR_OK); + PREG = NEXTOP(PREG, yl); + GONext(); + } + if (IsApplTerm(d0)) { + Functor f0 = FunctorOfTerm(d0); + if (IsExtensionFunctor(f0)) { + switch ((CELL)f0) { + case (CELL)FunctorLongInt: +#ifdef USE_GMP + case (CELL)FunctorBigInt: +#endif + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_CONDITIONAL_SUCCESS("IsApplTerm(d0)"); + EMIT_CONDITIONAL_SUCCESS("IsExtensionFunctor(f0)"); + EMIT_CONDITIONAL_SUCCESS(FUNCTOR_LARGE_INT); + EMIT_SIMPLE_BLOCK_TEST(P_INTEGER_Y_INTEGER_Y_NVAR_OK); + PREG = NEXTOP(PREG, yl); + GONext(); + default: + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_CONDITIONAL_SUCCESS("IsApplTerm(d0)"); + EMIT_CONDITIONAL_SUCCESS("IsExtensionFunctor(f0)"); + EMIT_CONDITIONAL_FAIL(FUNCTOR_LARGE_INT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_INTEGER_Y_INTEGER_Y_NVAR_NOOK); + PREG = PREG->u.yl.F; + GONext(); + } + } + } + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_CONDITIONAL_FAIL("IsApplTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_INTEGER_Y_INTEGER_Y_NVAR_NOOK); + PREG = PREG->u.yl.F; + GONext(); + + profiled_derefa_body(d0, pt0, traced_integer_y_unk, traced_integer_y_nvar); + EMIT_SIMPLE_BLOCK(P_INTEGER_Y_INTEGER_Y_UNK); + PREG = PREG->u.yl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_nonvar_x, xl); + EMIT_ENTRY_BLOCK(PREG,P_NONVAR_X_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + profiled_deref_head_TEST(d0, traced_nonvar_x_unk); + traced_nonvar_x_nvar: + EMIT_SIMPLE_BLOCK_TEST(P_NONVAR_X_NONVAR); + PREG = NEXTOP(PREG, xl); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_nonvar_x_unk, traced_nonvar_x_nvar); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_NONVAR_X_NONONVAR); + PREG = PREG->u.xl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_nonvar_y, yl); + EMIT_ENTRY_BLOCK(PREG,P_NONVAR_Y_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_nonvar_y_unk); + traced_nonvar_y_nvar: + EMIT_SIMPLE_BLOCK_TEST(P_NONVAR_Y_NONVAR); + PREG = NEXTOP(PREG, yl); + GONext(); + + profiled_derefa_body(d0, pt0, traced_nonvar_y_unk, traced_nonvar_y_nvar); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_NONVAR_Y_NONONVAR); + PREG = PREG->u.yl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_number_x, xl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_NUMBER_X_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + deref_head(d0, traced_number_x_unk); + traced_number_x_nvar: + /* non variable */ + + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_X_INT); +///#endif + PREG = NEXTOP(PREG, xl); + GONext(); + } + if (IsApplTerm(d0)) { + Functor f0 = FunctorOfTerm(d0); + if (IsExtensionFunctor(f0)) { + switch ((CELL)f0) { + case (CELL)FunctorLongInt: + case (CELL)FunctorDouble: +#ifdef USE_GMP + case (CELL)FunctorBigInt: +#endif +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_X_FUNCTORINT); +///#endif + PREG = NEXTOP(PREG, xl); + GONext(); + default: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_X_FUNCTORDEFAULT); +///#endif + PREG = PREG->u.xl.F; + GONext(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_X_POST_IF); +///#endif + PREG = PREG->u.xl.F; + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_number_x_unk, traced_number_x_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_X_NUMBER_X_UNK); +///#endif + PREG = PREG->u.xl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_number_y, yl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_NUMBER_Y_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + deref_head(d0, traced_number_y_unk); + traced_number_y_nvar: + /* non variable */ + /* non variable */ + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_Y_INT); +///#endif + PREG = NEXTOP(PREG, xl); + GONext(); + } + if (IsApplTerm(d0)) { + Functor f0 = FunctorOfTerm(d0); + if (IsExtensionFunctor(f0)) { + switch ((CELL)f0) { + case (CELL)FunctorLongInt: + case (CELL)FunctorDouble: +#ifdef USE_GMP + case (CELL)FunctorBigInt: +#endif +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_Y_FUNCTORINT); +///#endif + PREG = NEXTOP(PREG, yl); + GONext(); + default: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_Y_FUNCTORDEFAULT); +///#endif + PREG = PREG->u.yl.F; + GONext(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_Y_POST_IF); +///#endif + PREG = PREG->u.xl.F; + GONext(); + + derefa_body(d0, pt0, traced_number_y_unk, traced_number_y_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_NUMBER_Y_NUMBER_Y_UNK); +///#endif + PREG = PREG->u.yl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_var_x, xl); + EMIT_ENTRY_BLOCK(PREG,P_VAR_X_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + profiled_deref_head_TEST(d0, traced_var_x_unk); + traced_var_x_nvar: + /* non variable */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_VAR_X_NONVAR); + PREG = PREG->u.xl.F; + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_var_x_unk, traced_var_x_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_VAR_X_VAR); + PREG = NEXTOP(PREG, xl); + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_var_y, yl); + EMIT_ENTRY_BLOCK(PREG,P_VAR_Y_INSTINIT); + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + profiled_deref_head_TEST(d0, traced_var_y_unk); + traced_var_y_nvar: + /* non variable */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_VAR_Y_NONVAR); + PREG = PREG->u.yl.F; + GONext(); + + profiled_derefa_body(d0, pt0, traced_var_y_unk, traced_var_y_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_VAR_Y_VAR); + PREG = NEXTOP(PREG, yl); + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_db_ref_x, xl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_DB_REF_X_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + deref_head(d0, traced_dbref_x_unk); + traced_dbref_x_nvar: + /* non variable */ + if (IsDBRefTerm(d0)) { + /* only allow references to the database, not general references + * to go through. */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DB_REF_X_DBREF); +///#endif + PREG = NEXTOP(PREG, xl); + GONext(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DB_REF_X_NODBREF); +///#endif + PREG = PREG->u.xl.F; + GONext(); + } + + BEGP(pt0); + deref_body(d0, pt0, traced_dbref_x_unk, traced_dbref_x_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DB_REF_X_DBREF_X_UNK); +///#endif + PREG = PREG->u.xl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_db_ref_y, yl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_DB_REF_Y_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + deref_head(d0, traced_dbref_y_unk); + traced_dbref_y_nvar: + /* non variable */ + if (IsDBRefTerm(d0)) { + /* only allow references to the database, not general references + * to go through. */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DB_REF_Y_DBREF); +///#endif + PREG = NEXTOP(PREG, yl); + GONext(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DB_REF_Y_NODBREF); +///#endif + PREG = PREG->u.yl.F; + GONext(); + } + + derefa_body(d0, pt0, traced_dbref_y_unk, traced_dbref_y_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DB_REF_Y_DBREF_Y_UNK); +///#endif + PREG = PREG->u.yl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_primitive_x, xl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_PRIMITIVE_X_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + deref_head(d0, traced_primi_x_unk); + traced_primi_x_nvar: + /* non variable */ + if (IsPrimitiveTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_PRIMITIVE_X_PRIMITIVE); +///#endif + PREG = NEXTOP(PREG, xl); + GONext(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_PRIMITIVE_X_NOPRIMITIVE); +///#endif + PREG = PREG->u.xl.F; + GONext(); + } + + BEGP(pt0); + deref_body(d0, pt0, traced_primi_x_unk, traced_primi_x_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_PRIMITIVE_X_PRIMI_X_UNK); +///#endif + PREG = PREG->u.xl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_primitive_y, yl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_PRIMITIVE_Y_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + deref_head(d0, traced_primi_y_unk); + traced_primi_y_nvar: + /* non variable */ + if (IsPrimitiveTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_PRIMITIVE_Y_PRIMITIVE); +///#endif + PREG = NEXTOP(PREG, yl); + GONext(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_PRIMITIVE_Y_NOPRIMITIVE); +///#endif + PREG = PREG->u.yl.F; + GONext(); + } + + derefa_body(d0, pt0, traced_primi_y_unk, traced_primi_y_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_PRIMITIVE_Y_PRIMI_Y_UNK); +///#endif + PREG = PREG->u.yl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_compound_x, xl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_COMPOUND_X_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + deref_head(d0, traced_compound_x_unk); + traced_compound_x_nvar: + /* non variable */ + if (IsPairTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_X_PAIR); +///#endif + PREG = NEXTOP(PREG, xl); + GONext(); + } + else if (IsApplTerm(d0)) { + if (IsExtensionFunctor(FunctorOfTerm(d0))) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_X_APPL_IFOK); +///#endif + PREG = PREG->u.xl.F; + GONext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_X_APPL); +///#endif + PREG = NEXTOP(PREG, xl); + GONext(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_X_NOAPPL); +///#endif + PREG = PREG->u.xl.F; + GONext(); + } + + BEGP(pt0); + deref_body(d0, pt0, traced_compound_x_unk, traced_compound_x_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_X_COMPOUND_X_UNK); +///#endif + PREG = PREG->u.xl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_compound_y, yl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_COMPOUND_Y_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + deref_head(d0, traced_compound_y_unk); + traced_compound_y_nvar: + /* non variable */ + if (IsPairTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_Y_PAIR); +///#endif + PREG = NEXTOP(PREG, yl); + GONext(); + } + else if (IsApplTerm(d0)) { + if (IsExtensionFunctor(FunctorOfTerm(d0))) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_Y_APPL_IFOK); +///#endif + PREG = PREG->u.yl.F; + GONext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_Y_APPL); +///#endif + PREG = NEXTOP(PREG, yl); + GONext(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_Y_NOAPPL); +///#endif + PREG = PREG->u.yl.F; + GONext(); + } + + derefa_body(d0, pt0, traced_compound_y_unk, traced_compound_y_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_COMPOUND_Y_COMPOUND_Y_UNK); +///#endif + PREG = PREG->u.yl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_float_x, xl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FLOAT_X_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xl.x); + deref_head(d0, traced_float_x_unk); + traced_float_x_nvar: + /* non variable */ + if (IsFloatTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FLOAT_X_FLOAT); +///#endif + PREG = NEXTOP(PREG, xl); + GONext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FLOAT_X_POST_IF); +///#endif + PREG = PREG->u.xl.F; + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_float_x_unk, traced_float_x_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FLOAT_X_FLOAT_X_UNK); +///#endif + PREG = PREG->u.xl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_float_y, yl); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FLOAT_Y_INSTINIT); +///#endif + BEGD(d0); + BEGP(pt0); + pt0 = YREG + PREG->u.yl.y; + d0 = *pt0; + deref_head(d0, traced_float_y_unk); + traced_float_y_nvar: + /* non variable */ + if (IsFloatTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FLOAT_Y_FLOAT); +///#endif + PREG = NEXTOP(PREG, yl); + GONext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FLOAT_Y_POST_IF); +///#endif + PREG = PREG->u.yl.F; + GONext(); + + derefa_body(d0, pt0, traced_float_y_unk, traced_float_y_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FLOAT_Y_FLOAT_Y_UNK); +///#endif + PREG = PREG->u.yl.F; + GONext(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_plus_vv, xxx); + EMIT_ENTRY_BLOCK(PREG,P_PLUS_VV_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.xxx.x1); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_plus_vv_unk); + traced_plus_vv_nvar: + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VV_PLUS_VV_NVAR); + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + profiled_deref_head_TEST(d1, traced_plus_vv_nvar_unk); + traced_plus_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT); + d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1)); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT); + saveregs(); + d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(PREG, xxx); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_plus_vv_unk, traced_plus_vv_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VV_PLUS_VV_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is _+B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_plus_vv_nvar_unk, traced_plus_vv_nvar_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VV_PLUS_VV_NVAR_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_plus_vc, xxn); + EMIT_ENTRY_BLOCK(PREG,P_PLUS_VC_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_plus_vc_unk); + traced_plus_vc_nvar: + { + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VC_PLUS_VC_NVAR_INT); + d0 = MkIntegerTerm(IntOfTerm(d0) + d1); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VC_PLUS_VC_NVAR_NOINT); + saveregs(); + d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_plus_vc_unk, traced_plus_vc_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_VC_PLUS_VC_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, PREG->u.xxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_plus_y_vv, yxx); + EMIT_ENTRY_BLOCK(PREG,P_PLUS_Y_VV_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.yxx.x1); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_plus_y_vv_unk); + traced_plus_y_vv_nvar: + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VV_PLUS_Y_VV_NVAR); + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + profiled_deref_head_TEST(d1, traced_plus_y_vv_nvar_unk); + traced_plus_y_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT); + d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1)); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT); + saveregs(); + d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + BEGP(pt0); + pt0 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_plus_y_vv_unk, traced_plus_y_vv_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VV_PLUS_Y_VV_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_plus_y_vv_nvar_unk, traced_plus_y_vv_nvar_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_plus_y_vc, yxn); + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + EMIT_ENTRY_BLOCK(PREG,P_PLUS_Y_VC_INSTINIT); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_plus_y_vc_unk); + + traced_plus_y_vc_nvar: + { + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT); + d0 = MkIntegerTerm(IntOfTerm(d0) + d1); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT); + saveregs(); + d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_plus_y_vc_unk, traced_plus_y_vc_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_PLUS_Y_VC_PLUS_Y_VC_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, PREG->u.yxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_minus_vv, xxx); + EMIT_ENTRY_BLOCK(PREG,P_MINUS_VV_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.xxx.x1); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_minus_vv_unk); + traced_minus_vv_nvar: + EMIT_SIMPLE_BLOCK_TEST(P_MINUS_VV_MINUS_VV_NVAR); + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + profiled_deref_head_TEST(d1, traced_minus_vv_nvar_unk); + traced_minus_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT); + d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1)); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT); + saveregs(); + d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(PREG, xxx); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_minus_vv_unk, traced_minus_vv_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_MINUS_VV_MINUS_VV_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_minus_vv_nvar_unk, traced_minus_vv_nvar_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_MINUS_VV_MINUS_VV_NVAR_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_minus_cv, xxn); + EMIT_ENTRY_BLOCK(PREG,P_MINUS_CV_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_minus_cv_unk); + traced_minus_cv_nvar: + { + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { + EMIT_SIMPLE_BLOCK_TEST(P_MINUS_CV_MINUS_CV_NVAR_INT); + d0 = MkIntegerTerm(d1 - IntOfTerm(d0)); + } + else { + EMIT_SIMPLE_BLOCK_TEST(P_MINUS_CV_MINUS_CV_NVAR_NOINT); + saveregs(); + d0 = p_minus(MkIntegerTerm(d1),Yap_Eval(d0)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_minus_cv_unk, traced_minus_cv_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_MINUS_CV_MINUS_CV_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "-A", PREG->u.xxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_minus_y_vv, yxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_MINUS_Y_VV_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.yxx.x1); + /* first check pt1 */ + deref_head(d0, traced_minus_y_vv_unk); + traced_minus_y_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_MINUS_Y_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_minus_y_vv_nvar_unk); + traced_minus_y_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_INTTERM); +///#endif + d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1)); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_minus_y_vv_unk, traced_minus_y_vv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_MINUS_Y_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + deref_body(d1, pt0, traced_minus_y_vv_nvar_unk, traced_minus_y_vv_nvar_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_minus_y_cv, yxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_MINUS_Y_CV_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + /* first check pt1 */ + deref_head(d0, traced_minus_y_cv_unk); + traced_minus_y_cv_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_CV_MINUS_Y_CV_NVAR); +///#endif + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_CV_INTTERM); +///#endif + d0 = MkIntegerTerm(d1 - IntOfTerm(d0)); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_CV_NOINTTERM); +///#endif + saveregs(); + d0 = p_minus(MkIntegerTerm(d1), Yap_Eval(d0)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_CV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_CV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_minus_y_cv_unk, traced_minus_y_cv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_MINUS_Y_CV_MINUS_Y_CV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "-A", PREG->u.yxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_times_vv, xxx); + EMIT_ENTRY_BLOCK(PREG,P_TIMES_VV_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.xxx.x1); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_times_vv_unk); + traced_times_vv_nvar: + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VV_TIMES_VV_NVAR); + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + profiled_deref_head_TEST(d1, traced_times_vv_nvar_unk); + traced_times_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT); + d0 = times_int(IntOfTerm(d0), IntOfTerm(d1)); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT); + saveregs(); + d0 = p_times(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(PREG, xxx); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_times_vv_unk, traced_times_vv_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VV_TIMES_VV_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_times_vv_nvar_unk, traced_times_vv_nvar_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VV_TIMES_VV_NVAR_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_times_vc, xxn); + EMIT_ENTRY_BLOCK(PREG,P_TIMES_VC_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_times_vc_unk); + traced_times_vc_nvar: + { + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VC_TIMES_VC_NVAR_INT); + d0 = times_int(IntOfTerm(d0), d1); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VC_TIMES_VC_NVAR_NOINT); + saveregs(); + d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_times_vc_unk, traced_times_vc_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_VC_TIMES_VC_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A* " Int_FORMAT, PREG->u.xxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_times_y_vv, yxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_TIMES_Y_VV_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.yxx.x1); + /* first check pt1 */ + deref_head(d0, traced_times_y_vv_unk); + traced_times_y_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_TIMES_Y_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_times_y_vv_nvar_unk); + traced_times_y_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_INTTERM); +///#endif + d0 = times_int(IntOfTerm(d0), IntOfTerm(d1)); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_times(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_times_y_vv_unk, traced_times_y_vv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_TIMES_Y_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + deref_body(d1, pt0, traced_times_y_vv_nvar_unk, traced_times_y_vv_nvar_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_times_y_vc, yxn); + EMIT_ENTRY_BLOCK(PREG,P_TIMES_Y_VC_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_times_y_vc_unk); + traced_times_y_vc_nvar: + { + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT); + d0 = times_int(IntOfTerm(d0), d1); + } + else { + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT); + saveregs(); + d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_times_y_vc_unk, traced_times_y_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK_TEST(P_TIMES_Y_VC_TIMES_Y_VC_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A* " Int_FORMAT, PREG->u.yxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_div_vv, xxx); + EMIT_ENTRY_BLOCK(PREG,P_DIV_VV_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.xxx.x1); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_div_vv_unk); + traced_div_vv_nvar: + EMIT_SIMPLE_BLOCK_TEST(P_DIV_VV_DIV_VV_NVAR); + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + profiled_deref_head_TEST(d1, traced_div_vv_nvar_unk); + traced_div_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_DIV_VV_DIV_VV_NVAR_NVAR_INT); + Int div = IntOfTerm(d1); + if (div == 0) { + saveregs(); + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); + setregs(); + TRACED_FAIL(); + } + d0 = MkIntTerm(IntOfTerm(d0) / div); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT); + saveregs(); + d0 = p_div(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(PREG, xxx); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_div_vv_unk, traced_div_vv_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_DIV_VV_DIV_VV_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_div_vv_nvar_unk, traced_div_vv_nvar_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_DIV_VV_DIV_VV_NVAR_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_div_vc, xxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_DIV_VC_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + /* first check pt1 */ + deref_head(d0, traced_div_vc_unk); + traced_div_vc_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_VC_DIV_VC_NVAR); +///#endif + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_VC_INTTERM); +///#endif + d0 = MkIntTerm(IntOfTerm(d0) / d1); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_VC_NOINTTERM); +///#endif + saveregs(); + d0 = p_div(Yap_Eval(d0),MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_VC_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_VC_NVAR_END); +///#endif + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_div_vc_unk, traced_div_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_VC_DIV_VC_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_div_cv, xxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_DIV_CV_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + /* first check pt1 */ + deref_head(d0, traced_div_cv_unk); + traced_div_cv_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_CV_DIV_CV_NVAR); +///#endif + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_CV_INTTERM_INIT); +///#endif + Int div = IntOfTerm(d0); + if (div == 0){ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_CV_INTTERM_DIVEQUALS0); +///#endif + saveregs(); + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_CV_INTTERM_END); +///#endif + d0 = MkIntegerTerm(d1 / div); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_CV_NOINTTERM); +///#endif + saveregs(); + d0 = p_div(MkIntegerTerm(d1),Yap_Eval(d0)); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_CV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_CV_NVAR_END); +///#endif + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_div_cv_unk, traced_div_cv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_CV_DIV_CV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "// A", PREG->u.xxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_div_y_vv, yxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_DIV_Y_VV_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.yxx.x1); + /* first check pt1 */ + deref_head(d0, traced_div_y_vv_unk); + traced_div_y_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_DIV_Y_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_div_y_vv_nvar_unk); + traced_div_y_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_INTTERM_INIT); +///#endif + Int div = IntOfTerm(d1); + if (div == 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_INTTERM_DIVEQUALS0); +///#endif + saveregs(); + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_INTTERM_END); +///#endif + d0 = MkIntTerm(IntOfTerm(d0) / div); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_div(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_div_y_vv_unk, traced_div_y_vv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_DIV_Y_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + deref_body(d1, pt0, traced_div_y_vv_nvar_unk, traced_div_y_vv_nvar_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_div_y_vc, yxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_DIV_Y_VC_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + /* first check pt1 */ + deref_head(d0, traced_div_y_vc_unk); + traced_div_y_vc_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VC_DIV_Y_VC_NVAR); +///#endif + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { +//#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VC_INTTERM); +///#endif + d0 = MkIntTerm(IntOfTerm(d0)/d1); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VC_NOINTTERM); +///#endif + saveregs(); + d0 = p_div(Yap_Eval(d0),MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VC_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VC_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_div_y_vc_unk, traced_div_y_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_VC_DIV_Y_VC_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_div_y_cv, yxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_DIV_Y_CV_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + /* first check pt1 */ + deref_head(d0, traced_div_y_cv_unk); + traced_div_y_cv_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_DIV_Y_CV_NVAR); +///#endif + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_INTTERM_INIT); +///#endif + Int div = IntOfTerm(d0); + if (div == 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_INTTERM_DIVEQUALS0); +///#endif + saveregs(); + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_INTTERM_END); +///#endif + d0 = MkIntegerTerm(d1 / div); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_NOINTTERM); +///#endif + saveregs(); + d0 = p_div(MkIntegerTerm(d1), Yap_Eval(d0)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_div_y_cv_unk, traced_div_y_cv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_DIV_Y_CV_DIV_Y_CV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "// A", PREG->u.yxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + + Op(traced_p_and_vv, xxx); + EMIT_ENTRY_BLOCK(PREG,P_AND_VV_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.xxx.x1); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_and_vv_unk); + traced_and_vv_nvar: + EMIT_SIMPLE_BLOCK_TEST(P_AND_VV_AND_VV_NVAR); + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + profiled_deref_head_TEST(d1, traced_and_vv_nvar_unk); + traced_and_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_AND_VV_AND_VV_NVAR_NVAR_INT); + d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1)); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_SIMPLE_BLOCK_TEST(P_AND_VV_AND_VV_NVAR_NVAR_NOINT); + saveregs(); + d0 = p_and(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(PREG, xxx); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_and_vv_unk, traced_and_vv_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_AND_VV_AND_VV_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_and_vv_nvar_unk, traced_and_vv_nvar_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_AND_VV_AND_VV_NVAR_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_and_vc, xxn); + EMIT_ENTRY_BLOCK(PREG,P_AND_VC_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_and_vc_unk); + traced_and_vc_nvar: + { + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_AND_VC_AND_VC_NVAR_INT); + d0 = MkIntegerTerm(IntOfTerm(d0) & d1); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_AND_VC_AND_VC_NVAR_NOINT); + saveregs(); + d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_and_vc_unk, traced_and_vc_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_AND_VC_AND_VC_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A /\\ " Int_FORMAT , PREG->u.xxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_and_y_vv, yxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_AND_Y_VV_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.yxx.x1); + /* first check pt1 */ + deref_head(d0, traced_and_y_vv_unk); + traced_and_y_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VV_AND_Y_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_and_y_vv_nvar_unk); + traced_and_y_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VV_INTTERM); +///#endif + d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1)); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_and(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_and_y_vv_unk, traced_and_y_vv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VV_AND_Y_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + deref_body(d1, pt0, traced_and_y_vv_nvar_unk, traced_and_y_vv_nvar_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VV_AND_Y_VV_NVAR_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_and_y_vc, yxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_AND_Y_VC_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + /* first check pt1 */ + deref_head(d0, traced_and_y_vc_unk); + traced_and_y_vc_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VC_AND_Y_VC_NVAR); +///#endif + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VC_INTTERM); +///#endif + d0 = MkIntegerTerm(IntOfTerm(d0) & d1); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VC_NOINTTERM); +///#endif + saveregs(); + d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VC_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VC_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_and_y_vc_unk, traced_and_y_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_AND_Y_VC_AND_Y_VC_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A /\\ " Int_FORMAT , PREG->u.yxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + + Op(traced_p_or_vv, xxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_OR_VV_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.xxx.x1); + /* first check pt1 */ + deref_head(d0, traced_or_vv_unk); + traced_or_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VV_OR_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_or_vv_nvar_unk); + traced_or_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VV_INTTERM); +///#endif + d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1)); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_or(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VV_NVAR_END); +///#endif + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(PREG, xxx); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_or_vv_unk, traced_or_vv_nvar); +//#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VV_OR_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + deref_body(d1, pt0, traced_or_vv_nvar_unk, traced_or_vv_nvar_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VV_OR_VV_NVAR_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_or_vc, xxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_OR_VC_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + /* first check pt1 */ + deref_head(d0, traced_or_vc_unk); + traced_or_vc_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VC_OR_VC_NVAR); +///#endif + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VC_INTTERM); +///#endif + d0 = MkIntegerTerm(IntOfTerm(d0) | d1); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VC_NOINTTERM); +///#endif + saveregs(); + d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1)); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VC_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VC_NVAR_END); +///#endif + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_or_vc_unk, traced_or_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_VC_OR_VC_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A \\/ " Int_FORMAT , PREG->u.xxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_or_y_vv, yxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_OR_Y_VV_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.yxx.x1); + /* first check pt1 */ + deref_head(d0, traced_or_y_vv_unk); + traced_or_y_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VV_OR_Y_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_or_y_vv_nvar_unk); + traced_or_y_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VV_INTTERM); +///#endif + d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1)); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_or(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_or_y_vv_unk, traced_or_y_vv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VV_OR_Y_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + deref_body(d1, pt0, traced_or_y_vv_nvar_unk, traced_or_y_vv_nvar_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VV_OR_Y_VV_NVAR_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_or_y_vc, yxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_OR_Y_VC_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + /* first check pt1 */ + deref_head(d0, traced_or_y_vc_unk); + traced_or_y_vc_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VC_OR_Y_VC_NVAR); +///#endif + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VC_INTTERM); +///#endif + d0 = MkIntegerTerm(IntOfTerm(d0) | d1); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VC_NOINTTERM); +///#endif + saveregs(); + d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VC_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VC_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_or_y_vc_unk, traced_or_y_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_OR_Y_VC_OR_Y_VC_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A \\/ " Int_FORMAT , PREG->u.yxn.c); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_sll_vv, xxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_SLL_VV_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.xxx.x1); + /* first check pt1 */ + deref_head(d0, traced_sll_vv_unk); + traced_sll_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VV_SLL_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_sll_vv_nvar_unk); + traced_sll_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VV_INTTERM_INIT); +///#endif + Int i2 = IntOfTerm(d1); + if (i2 < 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VV_INTTERM_LESS); +///#endif + d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2)); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VV_INTTERM_GREATER); +///#endif + d0 = do_sll(IntOfTerm(d0),i2); + } + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + } + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VV_NVAR_END); +///#endif + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(PREG, xxx); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_sll_vv_unk, traced_sll_vv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VV_SLL_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxn.xi); + /* first check pt1 */ + deref_head(d0, traced_sll_vc_unk); + traced_sll_vc_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VC_SLL_VC_NVAR); +///#endif + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VC_INTTERM); +///#endif + d0 = do_sll(IntOfTerm(d0), (Int)d1); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VC_NOINTTERM); +///#endif + saveregs(); + d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + } + } + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VC_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VC_NVAR_END); +///#endif + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_sll_vc_unk, traced_sll_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_VC_SLL_VC_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxn.xi); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_sll_cv_unk); + traced_sll_cv_nvar: + { + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_SLL_CV_SLL_CV_NVAR_INT); + Int i2 = IntOfTerm(d0); + if (i2 < 0) { + d0 = MkIntegerTerm(SLR(d1, -i2)); + } else { + d0 = do_sll(d1,i2); + } + } else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_SLL_CV_SLL_CV_NVAR_NOINT); + saveregs(); + d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(d0)); + setregs(); + } + } + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_sll_cv_unk, traced_sll_cv_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_SLL_CV_SLL_CV_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.yxx.x1); + /* first check pt1 */ + deref_head(d0, traced_sll_y_vv_unk); + traced_sll_y_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_SLL_Y_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_sll_y_vv_nvar_unk); + traced_sll_y_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_INTTERM_INIT); +///#endif + Int i2 = IntOfTerm(d1); + if (i2 < 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_INTERM_LESS); +///#endif + d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2)); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_INTTERM_GREATER); +///#endif + d0 = do_sll(IntOfTerm(d0),i2); + } + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + } + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_sll_y_vv_unk, traced_sll_y_vv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VV_SLL_Y_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.yxn.xi); + /* first check pt1 */ + deref_head(d0, traced_sll_y_vc_unk); + traced_sll_y_vc_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VC_SLL_Y_VC_NVAR); +///#endif + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VC_INTTERM); +///#endif + d0 = do_sll(IntOfTerm(d0), Yap_Eval(d1)); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VC_NOINTTERM); +///#endif + saveregs(); + d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + } + } + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VC_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VC_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_sll_y_vc_unk, traced_sll_y_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_VC_SLL_Y_VC_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.yxn.xi); + /* first check pt1 */ + deref_head(d0, traced_sll_y_cv_unk); + traced_sll_y_cv_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_SLL_Y_CV_NVAR); +///#endif + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_INTTERM_INIT); +///#endif + Int i2 = IntOfTerm(d0); + if (i2 < 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_INTTERM_LESS); +///#endif + d0 = MkIntegerTerm(SLR(d1, -i2)); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_INTTERM_GREATER); +///#endif + d0 = do_sll(d1,i2); + } + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_NOINTTERM); +///#endif + saveregs(); + d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(0)); + setregs(); + } + } + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_sll_y_cv_unk, traced_sll_y_cv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLL_Y_CV_SLL_Y_CV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxx.x1); + /* first check pt1 */ + deref_head(d0, traced_slr_vv_unk); + traced_slr_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_VV_SLR_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_slr_vv_nvar_unk); + traced_slr_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_VV_INTTERM_INIT); +///#endif + Int i2 = IntOfTerm(d1); + if (i2 < 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_VV_INTTERM_LESS); +///#endif + d0 = do_sll(IntOfTerm(d0), -i2); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_VV_INTTERM_GREATER); +///#endif + d0 = MkIntTerm(SLR(IntOfTerm(d0), i2)); + } + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + } + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_VV_NVAR_END); +///#endif + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(PREG, xxx); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_slr_vv_unk, traced_slr_vv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_VV_SRL_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + deref_body(d1, pt0, traced_slr_vv_nvar_unk, traced_slr_vv_nvar_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_VV_SRL_VV_NVAR_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_slr_vc, xxn); + EMIT_ENTRY_BLOCK(PREG,P_SLR_VC_INSTINIT); + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + /* first check pt1 */ + profiled_deref_head_TEST(d0, traced_slr_vc_unk); + traced_slr_vc_nvar: + { + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_SLR_VC_SLR_VC_NVAR_INT); + d0 = MkIntTerm(SLR(IntOfTerm(d0), d1)); + } + else { + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0)"); + EMIT_SIMPLE_BLOCK_TEST(P_SLR_VC_SLR_VC_NVAR_NOINT); + saveregs(); + d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_slr_vc_unk, traced_slr_vc_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_SLR_VC_SRL_VC_UNK); + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_slr_cv, xxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_SLR_CV_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + /* first check pt1 */ + deref_head(d0, traced_slr_cv_unk); + traced_slr_cv_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_CV_SLR_CV_NVAR); +///#endif + Int d1 = PREG->u.xxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_CV_INTTERM_INIT); +///#endif + Int i2 = IntOfTerm(d0); + if (i2 < 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_CV_INTTERM_LESS); +///#endif + d0 = do_sll(d1, -i2); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_CV_INTTERM_GREATER); +///#endif + d0 = MkIntegerTerm(SLR(d1, i2)); + } + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_CV_NOINTTERM); +///#endif + saveregs(); + d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0)); + setregs(); + } + } + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_CV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_CV_NVAR_END); +///#endif + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(PREG, xxn); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_slr_cv_unk, traced_slr_cv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_CV_SLR_CV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_slr_y_vv, yxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_SLR_Y_VV_INSTINIT); +///#endif + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.yxx.x1); + /* first check pt1 */ + deref_head(d0, traced_slr_y_vv_unk); + traced_slr_y_vv_nvar: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_SLR_Y_VV_NVAR); +///#endif + d1 = XREG(PREG->u.xxx.x2); + /* next check A2 */ + deref_head(d1, traced_slr_y_vv_nvar_unk); + traced_slr_y_vv_nvar_nvar: + /* d0 and d1 are where I want them */ + if (IsIntTerm(d0) && IsIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_INTTERM_INIT); +///#endif + Int i2 = IntOfTerm(d1); + if (i2 < 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_INTTERM_LESS); +///#endif + d0 = do_sll(IntOfTerm(d0), -i2); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_INTTERM_GREATER); +///#endif + d0 = MkIntTerm(SLR(IntOfTerm(d0), i2)); + } + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_NOINTTERM); +///#endif + saveregs(); + d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1)); + setregs(); + } + BEGP(pt0); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_NVAR_END); +///#endif + pt0 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_slr_y_vv_unk, traced_slr_y_vv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_SLR_Y_VV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + + BEGP(pt0); + deref_body(d1, pt0, traced_slr_y_vv_nvar_unk, traced_slr_y_vv_nvar_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_slr_y_vc, yxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_SLR_Y_VC_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + /* first check pt1 */ + deref_head(d0, traced_slr_y_vc_unk); + traced_slr_y_vc_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VC_SLR_Y_VC_NVAR); +///#endif + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VC_INTTERM); +///#endif + d0 = MkIntTerm(SLR(IntOfTerm(d0), d1)); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VC_NOINTTERM); +///#endif + saveregs(); + d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1)); + setregs(); + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VC_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } + } + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VC_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_slr_y_vc_unk, traced_slr_y_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_VC_SLR_Y_VC_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); + setregs(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + Op(traced_p_slr_y_cv, yxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_SLR_Y_CV_INSTINIT); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + /* first check pt1 */ + deref_head(d0, traced_slr_y_cv_unk); + traced_slr_y_cv_nvar: + { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_SLR_Y_CV_NVAR); +///#endif + Int d1 = PREG->u.yxn.c; + if (IsIntTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_INTTERM_INIT); +///#endif + Int i2 = IntOfTerm(d0); + if (i2 < 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_INTTERM_LESS); +///#endif + d0 = do_sll(d1, -i2); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_INTTERM_GREATER); +///#endif + d0 = MkIntegerTerm(SLR(d1, i2)); + } + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_NOINTTERM); +///#endif + saveregs(); + d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0)); + setregs(); + } + } + if (d0 == 0L) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_D0EQUALS0L); +///#endif + saveregs(); + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); + setregs(); + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_NVAR_END); +///#endif + BEGP(pt0); + pt0 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt0,d0); + ENDP(pt0); + GONext(); + + BEGP(pt0); + deref_body(d0, pt0, traced_slr_y_cv_unk, traced_slr_y_cv_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_SLR_Y_CV_SLR_Y_CV_UNK); +///#endif + saveregs(); + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); + setregs(); + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + BOp(traced_call_bfunc_xx, plxxs); + EMIT_ENTRY_BLOCK(PREG,CALL_BFUNC_XX_INSTINIT); + BEGD(d0); + BEGD(d1); + d0 = XREG(PREG->u.plxxs.x1); + traced_call_bfunc_xx_nvar: + EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR); + d1 = XREG(PREG->u.plxxs.x2); + traced_call_bfunc_xx2_nvar: + profiled_deref_head_TEST(d0, traced_call_bfunc_xx_unk); + profiled_deref_head_TEST(d1, traced_call_bfunc_xx2_unk); + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT); + COUNT flags; + + Int v = IntOfTerm(d0) - IntOfTerm(d1); + flags = PREG->u.plxxs.flags; + if (v > 0) { + if (flags & GT_OK_IN_CMP) { + yamop *nextp = NEXTOP(PREG, plxxs); + ALWAYS_LOOKAHEAD(nextp->opc); + PREG = nextp; + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + } + else { + yamop *nextp = PREG->u.plxxs.f; + ALWAYS_LOOKAHEAD(nextp->opc); + PREG = nextp; + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + } + } + else if (v < 0) { + if (flags & LT_OK_IN_CMP) { + yamop *nextp = NEXTOP(PREG, plxxs); + ALWAYS_LOOKAHEAD(nextp->opc); + PREG = nextp; + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + } + else { + yamop *nextp = PREG->u.plxxs.f; + ALWAYS_LOOKAHEAD(nextp->opc); + PREG = nextp; + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + } + } + else /* if (v == 0) */ { + if (flags & EQ_OK_IN_CMP) { + yamop *nextp = NEXTOP(PREG, plxxs); + ALWAYS_LOOKAHEAD(nextp->opc); + PREG = nextp; + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + } + else { + yamop *nextp = PREG->u.plxxs.f; + ALWAYS_LOOKAHEAD(nextp->opc); + PREG = nextp; + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + } + } + } + traced_exec_bin_cmp_xx: + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT); + { + CmpPredicate f = PREG->u.plxxs.p->cs.d_code; + saveregs(); + d0 = (CELL) (f) (d0,d1); + setregs(); + } + if (PREG == FAILCODE) { + JMPNext(); + } + if (!d0) { + PREG = PREG->u.plxxs.f; + JMPNext(); + } + PREG = NEXTOP(PREG, plxxs); + JMPNext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_call_bfunc_xx_unk, traced_call_bfunc_xx_nvar); + EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_XX_CALL_BFUNC_XX_UNK); + d1 = Deref(d1); + goto traced_exec_bin_cmp_xx; + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_call_bfunc_xx2_unk, traced_call_bfunc_xx2_nvar); + goto traced_exec_bin_cmp_xx; + ENDP(pt0); + + ENDD(d1); + ENDD(d0); + ENDBOp(); + + BOp(traced_call_bfunc_yx, plxys); + EMIT_ENTRY_BLOCK(PREG,CALL_BFUNC_YX_INSTINIT); + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = YREG + PREG->u.plxys.y; + d1 = XREG(PREG->u.plxys.x); + d0 = *pt0; + ENDP(pt0); + profiled_deref_head_TEST(d0, traced_call_bfunc_yx_unk); + traced_call_bfunc_yx_nvar: + profiled_deref_head_TEST(d1, traced_call_bfunc_yx2_unk); + traced_call_bfunc_yx2_nvar: + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT); + int flags; + + Int v = IntOfTerm(d0) - IntOfTerm(d1); + flags = PREG->u.plxys.flags; + if (v > 0) { + if (flags & GT_OK_IN_CMP) { + PREG = NEXTOP(PREG, plxys); + JMPNext(); + } else { + PREG = PREG->u.plxys.f; + JMPNext(); + } + } else if (v < 0) { + if (flags & LT_OK_IN_CMP) { + PREG = NEXTOP(PREG, plxys); + JMPNext(); + } else { + PREG = PREG->u.plxys.f; + JMPNext(); + } + } else /* if (v == 0) */ { + if (flags & EQ_OK_IN_CMP) { + PREG = NEXTOP(PREG, plxys); + JMPNext(); + } else { + PREG = PREG->u.plxys.f; + JMPNext(); + } + } + } + traced_exec_bin_cmp_yx: + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT); + { + CmpPredicate f = PREG->u.plxys.p->cs.d_code; + saveregs(); + d0 = (CELL) (f) (d0,d1); + setregs(); + } + if (!d0 || PREG == FAILCODE) { + if (PREG != FAILCODE) { + PREG = PREG->u.plxys.f; + } + JMPNext(); + } + PREG = NEXTOP(PREG, plxys); + JMPNext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_call_bfunc_yx_unk, traced_call_bfunc_yx_nvar); + EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_YX_CALL_BFUNC_YX_UNK); + d1 = Deref(d1); + goto traced_exec_bin_cmp_yx; + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_call_bfunc_yx2_unk, traced_call_bfunc_yx2_nvar); + goto traced_exec_bin_cmp_yx; + ENDP(pt0); + + ENDD(d1); + ENDD(d0); + ENDBOp(); + + BOp(traced_call_bfunc_xy, plxys); + EMIT_ENTRY_BLOCK(PREG,CALL_BFUNC_XY_INSTINIT); + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = YREG + PREG->u.plxys.y; + d0 = XREG(PREG->u.plxys.x); + d1 = *pt0; + ENDP(pt0); + profiled_deref_head_TEST(d0, traced_call_bfunc_xy_unk); + traced_call_bfunc_xy_nvar: + profiled_deref_head_TEST(d1, traced_call_bfunc_xy2_unk); + traced_call_bfunc_xy2_nvar: + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT); + int flags; + + Int v = IntOfTerm(d0) - IntOfTerm(d1); + flags = PREG->u.plxys.flags; + if (v > 0) { + if (flags & GT_OK_IN_CMP) { + PREG = NEXTOP(PREG, plxys); + JMPNext(); + } else { + PREG = PREG->u.plxys.f; + JMPNext(); + } + } else if (v < 0) { + if (flags & LT_OK_IN_CMP) { + PREG = NEXTOP(PREG, plxys); + JMPNext(); + } else { + PREG = PREG->u.plxys.f; + JMPNext(); + } + } else /* if (v == 0) */ { + if (flags & EQ_OK_IN_CMP) { + PREG = NEXTOP(PREG, plxys); + JMPNext(); + } else { + PREG = PREG->u.plxys.f; + JMPNext(); + } + } + } + traced_exec_bin_cmp_xy: + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT); + { + CmpPredicate f = PREG->u.plxys.p->cs.d_code; + saveregs(); + d0 = (CELL) (f) (d0,d1); + setregs(); + } + if (!d0 || PREG == FAILCODE) { + if (PREG != FAILCODE) { + PREG = PREG->u.plxys.f; + } + JMPNext(); + } + PREG = NEXTOP(PREG, plxys); + JMPNext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_call_bfunc_xy_unk, traced_call_bfunc_xy_nvar); + EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_XY_CALL_BFUNC_XY_UNK); + d1 = Deref(d1); + goto traced_exec_bin_cmp_xy; + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_call_bfunc_xy2_unk, traced_call_bfunc_xy2_nvar); + goto traced_exec_bin_cmp_xy; + ENDP(pt0); + + ENDD(d1); + ENDD(d0); + ENDBOp(); + + BOp(traced_call_bfunc_yy, plyys); + EMIT_ENTRY_BLOCK(PREG,CALL_BFUNC_YY_INSTINIT); + BEGD(d0); + BEGD(d1); + BEGP(pt0); + pt0 = YREG + PREG->u.plyys.y1; + BEGP(pt1); + pt1 = YREG + PREG->u.plyys.y2; + d0 = *pt0; + d1 = *pt1; + ENDP(pt1); + ENDP(pt0); + profiled_deref_head_TEST(d0, traced_call_bfunc_yy_unk); + traced_call_bfunc_yy_nvar: + profiled_deref_head_TEST(d1, traced_call_bfunc_yy2_unk); + traced_call_bfunc_yy2_nvar: + if (IsIntTerm(d0) && IsIntTerm(d1)) { + EMIT_CONDITIONAL_SUCCESS("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT); + int flags; + + Int v = IntOfTerm(d0) - IntOfTerm(d1); + flags = PREG->u.plyys.flags; + if (v > 0) { + if (flags & GT_OK_IN_CMP) { + PREG = NEXTOP(PREG, plyys); + JMPNext(); + } else { + PREG = PREG->u.plyys.f; + JMPNext(); + } + } else if (v < 0) { + if (flags & LT_OK_IN_CMP) { + PREG = NEXTOP(PREG, plyys); + JMPNext(); + } else { + PREG = PREG->u.plyys.f; + JMPNext(); + } + } else /* if (v == 0) */ { + if (flags & EQ_OK_IN_CMP) { + PREG = NEXTOP(PREG, plyys); + JMPNext(); + } else { + PREG = PREG->u.plyys.f; + JMPNext(); + } + } + } + traced_exec_bin_cmp_yy: + EMIT_CONDITIONAL_FAIL("IsIntTerm(d0) && IsIntTerm(d1)"); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT); + { + CmpPredicate f = PREG->u.plyys.p->cs.d_code; + saveregs(); + d0 = (CELL) (f) (d0,d1); + setregs(); + } + if (!d0 || PREG == FAILCODE) { + if (PREG != FAILCODE) { + PREG = PREG->u.plyys.f; + } + JMPNext(); + } + PREG = NEXTOP(PREG, plyys); + JMPNext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_call_bfunc_yy_unk, traced_call_bfunc_yy_nvar); + EMIT_SIMPLE_BLOCK_TEST(CALL_BFUNC_YY_CALL_BFUNC_YY_UNK); + d1 = Deref(d1); + goto traced_exec_bin_cmp_yy; + ENDP(pt0); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_call_bfunc_yy2_unk, traced_call_bfunc_yy2_nvar); + goto traced_exec_bin_cmp_yy; + ENDP(pt0); + + ENDD(d1); + ENDD(d0); + ENDBOp(); + + Op(traced_p_equal, e); + EMIT_ENTRY_BLOCK(PREG,P_EQUAL_INSTINIT); + save_hb(); + if (Yap_IUnify(ARG1, ARG2) == FALSE) { + TRACED_FAIL(); + } + EMIT_SIMPLE_BLOCK(P_EQUAL_END); + PREG = NEXTOP(PREG, e); + GONext(); + ENDOp(); + + Op(traced_p_dif, l); + EMIT_ENTRY_BLOCK(PREG,P_DIF_INSTINIT); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(P_DIF_LOW_LEVEL_TRACER); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); + } +#endif /* LOW_LEVEL_TRACE */ + EMIT_SIMPLE_BLOCK_TEST(P_DIF_POST_LOW_LEVEL_TRACER); + BEGD(d0); + BEGD(d1); + d0 = ARG1; + profiled_deref_head_TEST(d0, traced_dif_unk1); + traced_dif_nvar1: + /* first argument is bound */ + EMIT_SIMPLE_BLOCK_TEST(P_DIF_DIF_NVAR1); + d1 = ARG2; + profiled_deref_head_TEST(d1, traced_dif_nvar1_unk2); + traced_dif_nvar1_nvar2: + /* both arguments are bound */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_DIF_DIF_NVAR1_NVAR2); + if (d0 == d1) { + PREG = PREG->u.l.l; + GONext(); + } + if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) { + PREG = NEXTOP(PREG, l); + GONext(); + } + { + Int opresult; +#ifdef COROUTINING + /* + * We may wake up goals during our attempt to unify the + * two terms. If we are adding to the tail of a list of + * woken goals that should be ok, but otherwise we need + * to restore LOCAL_WokenGoals to its previous value. + */ + CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals); + +#endif + /* We will have to look inside compound terms */ + register tr_fr_ptr pt0; + /* store the old value of TR for clearing bindings */ + pt0 = TR; + BEGCHO(pt1); + pt1 = B; + /* make B and HRB point to HR to guarantee all bindings will + * be trailed + */ + HBREG = HR; + B = (choiceptr) HR; + B->cp_h = HR; + SET_BB(B); + save_hb(); + opresult = Yap_IUnify(d0, d1); +#ifdef COROUTINING + /* now restore Woken Goals to its old value */ + Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals); + if (OldWokenGoals == TermNil) { + Yap_undo_signal(YAP_WAKEUP_SIGNAL); + } +#endif + /* restore B */ + B = pt1; + SET_BB(PROTECT_FROZEN_B(pt1)); +#ifdef COROUTINING + H = HRBREG; +#endif + HBREG = B->cp_h; + /* untrail all bindings made by Yap_IUnify */ + while (TR != pt0) { + BEGD(d1); + d1 = TrailTerm(--TR); + if (IsVarTerm(d1)) { +#if defined(YAPOR_SBA) && defined(YAPOR) + /* clean up the trail when we backtrack */ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { + RESET_VARIABLE(STACK_TO_SBA(d1)); + } else +#endif + { + /* normal variable */ + RESET_VARIABLE(d1); + } +#ifdef MULTI_ASSIGNMENT_VARIABLES + } else /* if (IsApplTerm(d1)) */ { + CELL *pt = RepAppl(d1); + /* AbsAppl means */ + /* multi-assignment variable */ + /* so the next cell is the old value */ +#ifdef FROZEN_STACKS + pt[0] = TrailVal(--TR); +#else + pt[0] = TrailTerm(--TR); + TR--; +#endif /* FROZEN_STACKS */ +#endif /* MULTI_ASSIGNMENT_VARIABLES */ + } + ENDD(d1); + } + if (opresult) { + /* restore B, no need to restore HRB */ + PREG = PREG->u.l.l; + GONext(); + } + /* restore B, and later HRB */ + PREG = NEXTOP(PREG, l); + ENDCHO(pt1); + } + GONext(); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_dif_unk1, traced_dif_nvar1); + EMIT_SIMPLE_BLOCK_TEST(P_DIF_DIF_UNK1); + ENDP(pt0); + /* first argument is unbound */ + PREG = PREG->u.l.l; + GONext(); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_dif_nvar1_unk2, traced_dif_nvar1_nvar2); + EMIT_SIMPLE_BLOCK_TEST(P_DIF_DIF_NVAR1_UNK2); + ENDP(pt0); + /* second argument is unbound */ + PREG = PREG->u.l.l; + GONext(); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_eq, l); + EMIT_ENTRY_BLOCK(PREG,P_EQ_INSTINIT); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(P_EQ_LOW_LEVEL_TRACER); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorSame,0)),XREGS+1); + } +#endif /* LOW_LEVEL_TRACE */ + EMIT_SIMPLE_BLOCK_TEST(P_EQ_POST_LOW_LEVEL_TRACER); + BEGD(d0); + BEGD(d1); + d0 = ARG1; + profiled_deref_head_TEST(d0, traced_p_eq_unk1); + traced_p_eq_nvar1: + /* first argument is bound */ + EMIT_SIMPLE_BLOCK_TEST(P_EQ_P_EQ_NVAR1); + d1 = ARG2; + profiled_deref_head_TEST(d1, traced_p_eq_nvar1_unk2); + traced_p_eq_nvar1_nvar2: + /* both arguments are bound */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_EQ_P_EQ_NVAR1_NVAR2); + if (d0 == d1) { + PREG = NEXTOP(PREG, l); + GONext(); + } + if (IsPairTerm(d0)) { + if (!IsPairTerm(d1)) { + PREG = PREG->u.l.l; + GONext(); + } + BEGD(d2); + always_save_pc(); + d2 = iequ_complex(RepPair(d0)-1, RepPair(d0)+1,RepPair(d1)-1); + if (d2 == FALSE) { + PREG = PREG->u.l.l; + GONext(); + } + ENDD(d2); + always_set_pc(); + PREG = NEXTOP(PREG, l); + GONext(); + } + if (IsApplTerm(d0)) { + Functor f0 = FunctorOfTerm(d0); + Functor f1; + + /* f1 must be a compound term, even if it is a suspension */ + if (!IsApplTerm(d1)) { + PREG = PREG->u.l.l; + GONext(); + } + f1 = FunctorOfTerm(d1); + + /* we now know f1 is true */ + /* deref if a compound term */ + if (IsExtensionFunctor(f0)) { + switch ((CELL)f0) { + case (CELL)FunctorDBRef: + if (d0 == d1) { + PREG = NEXTOP(PREG, l); + GONext(); + } + PREG = PREG->u.l.l; + GONext(); + case (CELL)FunctorLongInt: + if (f1 != FunctorLongInt) { + PREG = PREG->u.l.l; + GONext(); + } + if (LongIntOfTerm(d0) == LongIntOfTerm(d1)) { + PREG = NEXTOP(PREG, l); + GONext(); + } + PREG = PREG->u.l.l; + GONext(); +#ifdef USE_GMP + case (CELL)FunctorBigInt: + if (f1 != FunctorBigInt) { + PREG = PREG->u.l.l; + GONext(); + } + if (Yap_gmp_tcmp_big_big(d0,d1) == 0) { + PREG = NEXTOP(PREG, l); + GONext(); + } + PREG = PREG->u.l.l; + GONext(); +#endif + case (CELL)FunctorDouble: + if (f1 != FunctorDouble) { + PREG = PREG->u.l.l; + GONext(); + } + if (FloatOfTerm(d0) == FloatOfTerm(d1)) { + PREG = NEXTOP(PREG, l); + GONext(); + } + default: + PREG = PREG->u.l.l; + GONext(); + } + } + if (f0 != f1) { + PREG = PREG->u.l.l; + GONext(); + } + always_save_pc(); + BEGD(d2); + d2 = iequ_complex(RepAppl(d0), RepAppl(d0)+ArityOfFunctor(f0), RepAppl(d1)); + if (d2 == FALSE) { + PREG = PREG->u.l.l; + GONext(); + } + ENDD(d2); + always_set_pc(); + PREG = NEXTOP(PREG, l); + GONext(); + } + PREG = PREG->u.l.l; + GONext(); + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_p_eq_nvar1_unk2, traced_p_eq_nvar1_nvar2); + EMIT_SIMPLE_BLOCK_TEST(P_EQ_P_EQ_NVAR1_UNK2); + ENDP(pt0); + /* first argument is bound */ + /* second argument is unbound */ + /* I don't need to worry about co-routining because an + unbound variable may never be == to a constrained variable!! */ + PREG = PREG->u.l.l; + GONext(); + ENDD(d1); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_p_eq_unk1, traced_p_eq_nvar1); + EMIT_SIMPLE_BLOCK_TEST(P_EQ_P_EQ_UNK1); + BEGD(d1); + d1 = ARG2; + profiled_deref_head_TEST(d1, traced_p_eq_var1_unk2); + traced_p_eq_var1_nvar2: + /* I don't need to worry about co-routining because an + unbound variable may never be == to a constrained variable!! */ + EMIT_SIMPLE_BLOCK_TEST(P_EQ_P_EQ_VAR1_NVAR2); + PREG = PREG->u.l.l; + GONext(); + + BEGP(pt1); + profiled_deref_body(d1, pt1, traced_p_eq_var1_unk2, traced_p_eq_var1_nvar2); + /* first argument is unbound */ + /* second argument is unbound */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_EQ_P_EQ_VAR1_UNK2_END); + if (pt1 != pt0) { + PREG = PREG->u.l.l; + GONext(); + } + PREG = NEXTOP(PREG, l); + GONext(); + ENDP(pt1); + ENDD(d1); + ENDP(pt0); + + ENDD(d0); + ENDOp(); + + Op(traced_p_arg_vv, xxx); + EMIT_ENTRY_BLOCK(PREG,P_ARG_VV_INSTINIT); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK(P_ARG_VV_LOW_LEVEL_TRACER); + H[0] = XREG(PREG->u.xxx.x1); + H[1] = XREG(PREG->u.xxx.x2); + RESET_VARIABLE(HR+2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorArg,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ + EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_TEST_D0); + BEGD(d0); + d0 = XREG(PREG->u.xxx.x1); + profiled_deref_head_TEST(d0, traced_arg_arg1_unk); + traced_arg_arg1_nvar: + /* ARG1 is ok! */ + EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_ARG_ARG1_NVAR); + if (IsIntTerm(d0)) { + d0 = IntOfTerm(d0); + } else if (IsLongIntTerm(d0)) { + d0 = LongIntOfTerm(d0); + } else { + saveregs(); + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); + setregs(); + TRACED_FAIL(); + } + + /* d0 now got the argument we want */ + EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_TEST_D1); + BEGD(d1); + d1 = XREG(PREG->u.xxx.x2); + profiled_deref_head_TEST(d1, traced_arg_arg2_unk); + traced_arg_arg2_nvar: + /* d1 now got the structure we want to fetch the argument + * from */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_ARG_VV_ARG_ARG2_NVAR); + if (IsApplTerm(d1)) { + BEGP(pt0); + pt0 = RepAppl(d1); + d1 = *pt0; + if (IsExtensionFunctor((Functor) d1)) { + TRACED_FAIL(); + } + if ((Int)d0 <= 0 || + (Int)d0 > ArityOfFunctor((Functor) d1)) { + /* don't complain here for Prolog compatibility + if ((Int)d0 <= 0) { + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, + MkIntegerTerm(d0),"arg 1 of arg/3"); + setregs(); + } + */ + TRACED_FAIL(); + } + XREG(PREG->u.xxx.x) = pt0[d0]; + PREG = NEXTOP(PREG, xxx); + GONext(); + ENDP(pt0); + } + else if (IsPairTerm(d1)) { + BEGP(pt0); + pt0 = RepPair(d1); + if (d0 != 1 && d0 != 2) { + if ((Int)d0 < 0) { + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, + MkIntegerTerm(d0),"arg 1 of arg/3"); + setregs(); + } + TRACED_FAIL(); + } + XREG(PREG->u.xxx.x) = pt0[d0-1]; + PREG = NEXTOP(PREG, xxx); + GONext(); + ENDP(pt0); + } + else { + /* + don't complain here for SWI Prolog compatibility + saveregs(); + Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); + setregs(); + */ + TRACED_FAIL(); + } + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_arg_arg2_unk, traced_arg_arg2_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_ARG_ARG2_UNK); + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3");; + setregs(); + ENDP(pt0); + TRACED_FAIL(); + ENDD(d1); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_arg_arg1_unk, traced_arg_arg1_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_ARG_VV_ARG_ARG1_UNK); + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3");; + setregs(); + ENDP(pt0); + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_arg_cv, xxn); + EMIT_ENTRY_BLOCK(PREG,P_ARG_CV_INSTINIT); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(P_ARG_CV_LOW_LEVEL_TRACER); + CELL *Ho = HR; + Term t = MkIntegerTerm(PREG->u.xxn.c); + H[0] = t; + H[1] = XREG(PREG->u.xxn.xi); + RESET_VARIABLE(HR+2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorArg,0)),H); + H = HRo; + } +#endif /* LOW_LEVEL_TRACE */ + EMIT_SIMPLE_BLOCK_TEST(P_ARG_CV_TEST_D1); + BEGD(d0); + d0 = PREG->u.xxn.c; + /* d0 now got the argument we want */ + BEGD(d1); + d1 = XREG(PREG->u.xxn.xi); + profiled_deref_head_TEST(d1, traced_arg_arg2_vc_unk); + traced_arg_arg2_vc_nvar: + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_ARG_CV_ARG_ARG2_VC_NVAR); + /* d1 now got the structure we want to fetch the argument + * from */ + if (IsApplTerm(d1)) { + BEGP(pt0); + pt0 = RepAppl(d1); + d1 = *pt0; + if (IsExtensionFunctor((Functor) d1)) { + TRACED_FAIL(); + } + if ((Int)d0 <= 0 || + (Int)d0 > ArityOfFunctor((Functor) d1)) { + /* don't complain here for Prolog compatibility + if ((Int)d0 <= 0) { + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, + MkIntegerTerm(d0),"arg 1 of arg/3"); + setregs(); + } + */ + TRACED_FAIL(); + } + XREG(PREG->u.xxn.x) = pt0[d0]; + PREG = NEXTOP(PREG, xxn); + GONext(); + ENDP(pt0); + } + else if (IsPairTerm(d1)) { + BEGP(pt0); + pt0 = RepPair(d1); + if (d0 != 1 && d0 != 2) { + if ((Int)d0 < 0) { + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, + MkIntegerTerm(d0),"arg 1 of arg/3"); + setregs(); + } + TRACED_FAIL(); + } + XREG(PREG->u.xxn.x) = pt0[d0-1]; + PREG = NEXTOP(PREG, xxn); + GONext(); + ENDP(pt0); + } + else { + /* + keep SWI Prolog compatibility, just fail on trying to obtain an argument of a compound term. + saveregs(); + Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); + setregs(); + */ + TRACED_FAIL(); + } + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_arg_arg2_vc_unk, traced_arg_arg2_vc_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_ARG_CV_ARG_ARG2_VC_UNK); + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3");; + setregs(); + ENDP(pt0); + TRACED_FAIL(); + ENDD(d1); + + ENDD(d0); + ENDOp(); + + Op(traced_p_arg_y_vv, yxx); + EMIT_ENTRY_BLOCK(PREG,P_ARG_Y_VV_INSTINIT); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { + EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_LOW_LEVEL_TRACER); + H[0] = XREG(PREG->u.yxx.x1); + H[1] = XREG(PREG->u.yxx.x2); + H[2] = YREG[PREG->u.yxx.y]; + RESET_VARIABLE(HR+2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorArg,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ + EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_TEST_D0); + BEGD(d0); + d0 = XREG(PREG->u.yxx.x1); + profiled_deref_head_TEST(d0, traced_arg_y_arg1_unk); + traced_arg_y_arg1_nvar: + EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_ARG_Y_ARG1_NVAR); + /* ARG1 is ok! */ + if (IsIntTerm(d0)) { + d0 = IntOfTerm(d0); + } else if (IsLongIntTerm(d0)) { + d0 = LongIntOfTerm(d0); + } else { + saveregs(); + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); + setregs(); + TRACED_FAIL(); + } + + /* d0 now got the argument we want */ + EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_TEST_D1); + BEGD(d1); + d1 = XREG(PREG->u.yxx.x2); + profiled_deref_head_TEST(d1, traced_arg_y_arg2_unk); + traced_arg_y_arg2_nvar: + /* d1 now got the structure we want to fetch the argument + * from */ + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_ARG_Y_VV_ARG_Y_ARG2_NVAR); + if (IsApplTerm(d1)) { + BEGP(pt0); + pt0 = RepAppl(d1); + d1 = *pt0; + if (IsExtensionFunctor((Functor) d1)) { + TRACED_FAIL(); + } + if ((Int)d0 <= 0 || + (Int)d0 > ArityOfFunctor((Functor) d1)) { + /* don't complain here for Prolog compatibility + if ((Int)d0 <= 0) { + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, + MkIntegerTerm(d0),"arg 1 of arg/3"); + saveregs(); + } + */ + TRACED_FAIL(); + } + BEGP(pt1); + pt1 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt1,pt0[d0]); + ENDP(pt1); + GONext(); + ENDP(pt0); + } + else if (IsPairTerm(d1)) { + BEGP(pt0); + pt0 = RepPair(d1); + if (d0 != 1 && d0 != 2) { + if ((Int)d0 < 0) { + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, + MkIntegerTerm(d0),"arg 1 of arg/3"); + setregs(); + } + TRACED_FAIL(); + } + BEGP(pt1); + pt1 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt1,pt0[d0-1]); + GONext(); + ENDP(pt1); + ENDP(pt0); + } + else { + /* + don't complain here for SWI Prolog compatibility + saveregs(); + Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); + setregs(); + */ + TRACED_FAIL(); + } + + BEGP(pt0); + profiled_deref_body(d1, pt0, traced_arg_y_arg2_unk, traced_arg_y_arg2_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_ARG_Y_ARG2_UNK); + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3");; + setregs(); + ENDP(pt0); + TRACED_FAIL(); + ENDD(d1); + + BEGP(pt0); + profiled_deref_body(d0, pt0, traced_arg_y_arg1_unk, traced_arg_y_arg1_nvar); + EMIT_SIMPLE_BLOCK_TEST(P_ARG_Y_VV_ARG_Y_ARG1_UNK); + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); + setregs(); + ENDP(pt0); + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_arg_y_cv, yxn); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_ARG_Y_CV_INSTINIT); +///#endif +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_LOW_LEVEL_TRACER); +///#endif + CELL *Ho = HR; + Term t = MkIntegerTerm(PREG->u.yxn.c); + H[0] = t; + H[1] = XREG(PREG->u.yxn.xi); + H[2] = YREG[PREG->u.yxn.y]; + RESET_VARIABLE(HR+2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorArg,0)),H); + H = HRo; + } +#endif /* LOW_LEVEL_TRACE */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_TEST_D1); +///#endif + BEGD(d0); + d0 = PREG->u.yxn.c; + /* d0 now got the argument we want */ + BEGD(d1); + d1 = XREG(PREG->u.yxn.xi); + deref_head(d1, traced_arg_y_arg2_vc_unk); + traced_arg_y_arg2_vc_nvar: + /* d1 now got the structure we want to fetch the argument + * from */ + if (IsApplTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_D1APPL_INIT); +///#endif + BEGP(pt0); + pt0 = RepAppl(d1); + d1 = *pt0; + if (IsExtensionFunctor((Functor) d1)) { + TRACED_FAIL(); + } + if ((Int)d0 <= 0 || + (Int)d0 > ArityOfFunctor((Functor) d1)) { + /* don't complain here for Prolog compatibility + if ((Int)d0 <= 0) { + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, + MkIntegerTerm(d0),"arg 1 of arg/3"); + setregs(); + } + */ + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_D1APPL_END); +///#endif + BEGP(pt1); + pt1 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt1,pt0[d0]); + ENDP(pt1); + GONext(); + ENDP(pt0); + } + else if (IsPairTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_D1PAIR_INIT); +///#endif + BEGP(pt0); + pt0 = RepPair(d1); + if (d0 != 1 && d0 != 2) { + if ((Int)d0 < 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_D1PAIR_LESS0); +///#endif + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, + MkIntegerTerm(d0),"arg 1 of arg/3"); + setregs(); + } + TRACED_FAIL(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_D1PAIR_END); +///#endif + BEGP(pt1); + pt1 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(PREG, yxn); + INITIALIZE_PERMVAR(pt1,pt0[d0-1]); + ENDP(pt1); + GONext(); + ENDP(pt0); + } + else { + /* + don't complain here for SWI Prolog compatibility + saveregs(); + Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); + setregs(); + */ + TRACED_FAIL(); + } + + BEGP(pt0); + deref_body(d1, pt0, traced_arg_y_arg2_vc_unk, traced_arg_y_arg2_vc_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3");; + setregs(); + ENDP(pt0); + TRACED_FAIL(); + ENDD(d1); + + ENDD(d0); + ENDOp(); + + Op(traced_p_func2s_vv, xxx); + /* A1 is a variable */ +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_VV_INSTINIT); +///#endif + traced_restart_func2s: +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_LOW_LEVEL_TRACER); +///#endif + RESET_VARIABLE(HR); + H[1] = XREG(PREG->u.xxx.x1); + H[2] = XREG(PREG->u.xxx.x2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ + /* We have to build the structure */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_TEST_D0); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xxx.x1); + deref_head(d0, traced_func2s_unk); + traced_func2s_nvar: + /* we do, let's get the third argument */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_TEST_D1); +///#endif + BEGD(d1); + d1 = XREG(PREG->u.xxx.x2); + deref_head(d1, traced_func2s_unk2); + traced_func2s_nvar2: + /* Uuuff, the second and third argument are bound */ + if (IsIntegerTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_D1INT); +///#endif + d1 = IntegerOfTerm(d1); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_D1NOTINT); +///#endif + saveregs(); + if (IsBigIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_D1BIGINT); +///#endif + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_D1NOTBIGINT); +///#endif + Yap_Error(TYPE_ERROR_INTEGER, d1, "functor/3"); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_D1NOTINT_END); +///#endif + setregs(); + TRACED_FAIL(); + } + if (!IsAtomicTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_D0NOTATOMIC); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + /* We made it!!!!! we got in d0 the name, in d1 the arity and + * in pt0 the variable to bind it to. */ + if (d0 == TermDot && d1 == 2) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_FIRSTIFOK); +///#endif + RESET_VARIABLE(HR); + RESET_VARIABLE(HR+1); + d0 = AbsPair(HR); + H += 2; + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx),Osbpp),l); + GONext(); + } + else if ((Int)d1 > 0) { + /* now let's build a compound term */ + if (!IsAtomTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_SECONDIFOK_D0NOTATOM); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + BEGP(pt1); + if (!IsAtomTerm(d0)) { + TRACED_FAIL(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_SECONDIFOK_D0ATOM); +///#endif + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM); +///#endif + pt1 = HR; + *pt1++ = d0; + d0 = AbsAppl(HR); + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { + /* make sure we have something to show for our trouble */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT); +///#endif + saveregs(); + if (!Yap_gcl((1+d1)*sizeof(CELL), 0, YREG, NEXTOP(NEXTOP(PREG,xxx),Osbpp))) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK); +///#endif + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + setregs(); + JMPNext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF); +///#endif + setregs(); + } + goto traced_restart_func2s; + } + while ((Int)d1--) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE); +///#endif + RESET_VARIABLE(pt1); + pt1++; + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_SECONDIFOK_END); +///#endif + H = pt1; + /* done building the term */ + ENDP(pt1); + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx),Osbpp),l); + GONext(); + } else if ((Int)d1 == 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_THIRDIFOK); +///#endif + XREG(PREG->u.xxx.x) = d0; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx),Osbpp),l); + GONext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_ELSE); +///#endif + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); + setregs(); + TRACED_FAIL(); + } + + BEGP(pt1); + deref_body(d1, pt1, traced_func2s_unk2, traced_func2s_nvar2); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_FUNC2S_UNK2); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, third argument was unbound */ + TRACED_FAIL(); + ENDD(d1); + + BEGP(pt1); + deref_body(d0, pt1, traced_func2s_unk, traced_func2s_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VV_FUNC2S_UNK); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_func2s_cv, xxc); + /* A1 is a variable */ +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_CV_INSTINIT); +///#endif + traced_restart_func2s_cv: +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_LOW_LEVEL_TRACER); +///#endif + RESET_VARIABLE(HR); + H[1] = PREG->u.xxc.c; + H[2] = XREG(PREG->u.xxc.xi); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_TEST_D1); +///#endif + BEGD(d0); + /* We have to build the structure */ + d0 = PREG->u.xxc.c; + /* we do, let's get the third argument */ + BEGD(d1); + d1 = XREG(PREG->u.xxc.xi); + deref_head(d1, traced_func2s_unk2_cv); + traced_func2s_nvar2_cv: + /* Uuuff, the second and third argument are bound */ + if (IsIntegerTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1INT); +///#endif + d1 = IntegerOfTerm(d1); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1NOTINT); +///#endif + saveregs(); + if (IsBigIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1NOINT_D1BIGINT); +///#endif + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1NOTBIGINT); +///#endif + Yap_Error(TYPE_ERROR_INTEGER,d1,"functor/3"); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_POST_IF); +///#endif + setregs(); + TRACED_FAIL(); + } + /* We made it!!!!! we got in d0 the name, in d1 the arity and + * in pt0 the variable to bind it to. */ + if (d0 == TermDot && d1 == 2) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_FIRSTIFOK); +///#endif + RESET_VARIABLE(HR); + RESET_VARIABLE(HR+1); + d0 = AbsPair(HR); + H += 2; + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + XREG(PREG->u.xxc.x) = d0; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc),Osbpp),l); + GONext(); + } else if ((Int)d1 > 0) { + /* now let's build a compound term */ + if (!IsAtomTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1GREATER_D0NOTATOM); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + BEGP(pt1); + if (!IsAtomTerm(d0)) { + TRACED_FAIL(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1GREATER_D0ATOM); +///#endif + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1GREATER_POST_IF); +///#endif + pt1 = HR; + *pt1++ = d0; + d0 = AbsAppl(HR); + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { + /* make sure we have something to show for our trouble */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1GREATER_IFOK_INIT); +///#endif + saveregs(); + if (!Yap_gcl((1+d1)*sizeof(CELL), 0, YREG, NEXTOP(NEXTOP(PREG,xxc),Osbpp))) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1GREATER_IFOK_IFOK); +///#endif + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + setregs(); + JMPNext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1GREATER_IFOK_NOIF); +///#endif + setregs(); + } + goto traced_restart_func2s_cv; + } + while ((Int)d1--) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1GREATER_INSIDEWHILE); +///#endif + RESET_VARIABLE(pt1); + pt1++; + } + /* done building the term */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1GREATER_END); +///#endif + H = pt1; + ENDP(pt1); + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + XREG(PREG->u.xxc.x) = d0; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc),Osbpp),l); + GONext(); + } else if (d1 == 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_D1ISZERO); +///#endif + XREG(PREG->u.xxc.x) = d0; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc),Osbpp),l); + GONext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_ELSE); +///#endif + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); + setregs(); + TRACED_FAIL(); + } + + BEGP(pt1); + deref_body(d1, pt1, traced_func2s_unk2_cv, traced_func2s_nvar2_cv); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_CV_END); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, third argument was unbound */ + TRACED_FAIL(); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_func2s_vc, xxn); + /* A1 is a variable */ +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_VC_INSTINIT); +///#endif + traced_restart_func2s_vc: +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_LOW_LEVEL_TRACER); +///#endif + Term ti; + CELL *hi = HR; + + ti = MkIntegerTerm(PREG->u.xxn.c); + RESET_VARIABLE(HR); + H[1] = XREG(PREG->u.xxn.xi); + H[2] = ti; + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + H = hi; + } +#endif /* LOW_LEVEL_TRACE */ + /* We have to build the structure */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_TEST_D0); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xxn.xi); + deref_head(d0, traced_func2s_unk_vc); + traced_func2s_nvar_vc: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_FUNC2S_NVAR_VC); +///#endif + BEGD(d1); + d1 = PREG->u.xxn.c; + if (!IsAtomicTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_D0NOATOMIC); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + /* We made it!!!!! we got in d0 the name, in d1 the arity and + * in pt0 the variable to bind it to. */ + if (d0 == TermDot && d1 == 2) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_EQUALS); +///#endif + RESET_VARIABLE(HR); + RESET_VARIABLE(HR+1); + d0 = AbsPair(HR); + H += 2; + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxn),Osbpp),l); + GONext(); + } + /* now let's build a compound term */ + if (d1 == 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_D1ISZERO); +///#endif + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxn),Osbpp),l); + GONext(); + } + if (!IsAtomTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_D0NOATOM); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + BEGP(pt1); + if (!IsAtomTerm(d0)) { + TRACED_FAIL(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_D0ATOM); +///#endif + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_POST_ELSE); +///#endif + pt1 = HR; + *pt1++ = d0; + d0 = AbsAppl(HR); + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { + /* make sure we have something to show for our trouble */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_IFOK_INIT); +///#endif + saveregs(); + if (!Yap_gc(0, YREG, NEXTOP(NEXTOP(PREG,xxn),Osbpp))) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_IFOK_IFOK); +///#endif + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + setregs(); + JMPNext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_IFOK_NOIF); +///#endif + setregs(); + } + goto traced_restart_func2s_vc; + } + while ((Int)d1--) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_INSIDEWHILE); +///#endif + RESET_VARIABLE(pt1); + pt1++; + } + /* done building the term */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_END1); +///#endif + HR = pt1; + ENDP(pt1); + ENDD(d1); + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + XREG(PREG->u.xxn.x) = d0; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxn),Osbpp),l); + GONext(); + + BEGP(pt1); + deref_body(d0, pt1, traced_func2s_unk_vc, traced_func2s_nvar_vc); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_VC_END2); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_func2s_y_vv, yxx); + /* A1 is a variable */ +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_Y_VV_INSTINIT); +///#endif + traced_restart_func2s_y: +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_LOW_LEVEL_TRACER); +///#endif + RESET_VARIABLE(HR); + H[1] = XREG(PREG->u.yxx.x1); + H[2] = XREG(PREG->u.yxx.x2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ + /* We have to build the structure */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_TEST_D0); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxx.x1); + deref_head(d0, traced_func2s_y_unk); + traced_func2s_y_nvar: + /* we do, let's get the third argument */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_TEST_D1); +///#endif + BEGD(d1); + d1 = XREG(PREG->u.yxx.x2); + deref_head(d1, traced_func2s_y_unk2); + traced_func2s_y_nvar2: + /* Uuuff, the second and third argument are bound */ + if (IsIntegerTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1INT); +///#endif + d1 = IntegerOfTerm(d1); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1NOTINT); +///#endif + saveregs(); + if (IsBigIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1BIGINT); +///#endif + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1NOTBIGINT); +///#endif + Yap_Error(TYPE_ERROR_INTEGER,d1,"functor/3"); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_POST_IF); +///#endif + setregs(); + TRACED_FAIL(); + } + if (!IsAtomicTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D0NOATOMIC); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + /* We made it!!!!! we got in d0 the name, in d1 the arity and + * in pt0 the variable to bind it to. */ + if (d0 == TermDot && d1 == 2) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_EQUALS); +///#endif + RESET_VARIABLE(HR); + RESET_VARIABLE(HR+1); + d0 = AbsPair(HR); + H += 2; + BEGP(pt1); + pt1 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxx),Osbpp),l); + INITIALIZE_PERMVAR(pt1,d0); + ENDP(pt1); + GONext(); + } else if ((Int)d1 > 0) { + /* now let's build a compound term */ + if (!IsAtomTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1GREATER_D0NOATOM); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + BEGP(pt1); + if (!IsAtomTerm(d0)) { + TRACED_FAIL(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1GREATER_D0ATOM); +///#endif + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1GREATER_POST_ELSE); +///#endif + pt1 = HR; + *pt1++ = d0; + d0 = AbsAppl(HR); + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { + /* make sure we have something to show for our trouble */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT); +///#endif + saveregs(); + if (!Yap_gcl((1+d1)*sizeof(CELL), 0, YREG, NEXTOP(NEXTOP(PREG,yxx),Osbpp))) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK); +///#endif + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + setregs(); + JMPNext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF); +///#endif + setregs(); + } + goto traced_restart_func2s_y; + } + while ((Int)d1--) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE); +///#endif + RESET_VARIABLE(pt1); + pt1++; + } + /* done building the term */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1GREATER_END); +///#endif + H = pt1; + ENDP(pt1); + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + BEGP(pt1); + pt1 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxx),Osbpp),l); + INITIALIZE_PERMVAR(pt1,d0); + ENDP(pt1); + GONext(); + } else if (d1 == 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_D1ISZERO); +///#endif + BEGP(pt1); + pt1 = YREG + PREG->u.yxx.y; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxx),Osbpp),l); + INITIALIZE_PERMVAR(pt1,d0); + ENDP(pt1); + GONext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_ELSE); +///#endif + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); + setregs(); + TRACED_FAIL(); + } + + BEGP(pt1); + deref_body(d1, pt1, traced_func2s_y_unk2, traced_func2s_y_nvar2); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_END1); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, third argument was unbound */ + TRACED_FAIL(); + ENDD(d1); + + BEGP(pt1); + deref_body(d0, pt1, traced_func2s_y_unk, traced_func2s_y_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VV_END2); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_func2s_y_cv, yxn); + /* A1 is a variable */ +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_Y_CV_INSTINIT); +///#endif + traced_restart_func2s_y_cv: +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_LOW_LEVEL_TRACER); +///#endif + RESET_VARIABLE(HR); + H[1] = PREG->u.yxn.c; + H[2] = XREG(PREG->u.yxn.xi); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ + /* We have to build the structure */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_TEST_D1); +///#endif + BEGD(d0); + d0 = PREG->u.yxn.c; + /* we do, let's get the third argument */ + BEGD(d1); + d1 = XREG(PREG->u.yxn.xi); + deref_head(d1, traced_func2s_y_unk_cv); + traced_func2s_y_nvar_cv: + /* Uuuff, the second and third argument are bound */ + if (IsIntegerTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1INT); +///#endif + d1 = IntegerOfTerm(d1); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1NOTINT); +///#endif + saveregs(); + if (IsBigIntTerm(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1BIGINT); +///#endif + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1NOTBIGINT); +///#endif + Yap_Error(TYPE_ERROR_INTEGER,d1,"functor/3"); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_POST_IF); +///#endif + setregs(); + TRACED_FAIL(); + } + /* We made it!!!!! we got in d0 the name, in d1 the arity and + * in pt0 the variable to bind it to. */ + if (d0 == TermDot && d1 == 2) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_EQUALS); +///#endif + RESET_VARIABLE(HR); + RESET_VARIABLE(HR+1); + d0 = AbsPair(HR); + H += 2; + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + BEGP(pt1); + pt1 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn),Osbpp),l); + INITIALIZE_PERMVAR(pt1,d0); + ENDP(pt1); + GONext(); + } + else if ((Int)d1 > 0) { + /* now let's build a compound term */ + if (!IsAtomTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1GREATER_D0NOATOM); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + if (!IsAtomTerm(d0)) { + TRACED_FAIL(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1GREATER_D0ATOM); +///#endif + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1GREATER_POST_ELSE); +///#endif + BEGP(pt1); + pt1 = HR; + *pt1++ = d0; + d0 = AbsAppl(HR); + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { + /* make sure we have something to show for our trouble */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT); +///#endif + saveregs(); + if (!Yap_gcl((1+d1)*sizeof(CELL), 0, YREG, NEXTOP(NEXTOP(PREG,yxn),Osbpp))) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK); +///#endif + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + setregs(); + JMPNext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF); +///#endif + setregs(); + } + goto traced_restart_func2s_y_cv; + } + while ((Int)d1--) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE); +///#endif + RESET_VARIABLE(pt1); + pt1++; + } + /* done building the term */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1GREATER_END); +///#endif + H = pt1; + ENDP(pt1); + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + BEGP(pt1); + pt1 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn),Osbpp),l); + INITIALIZE_PERMVAR(pt1,d0); + ENDP(pt1); + GONext(); + } else if (d1 == 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_D1ISZERO); +///#endif + BEGP(pt1); + pt1 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn),Osbpp),l); + INITIALIZE_PERMVAR(pt1,d0); + ENDP(pt1); + GONext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_ELSE); +///#endif + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); + setregs(); + TRACED_FAIL(); + } + + BEGP(pt1); + deref_body(d1, pt1, traced_func2s_y_unk_cv, traced_func2s_y_nvar_cv); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_CV_END); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, third argument was unbound */ + TRACED_FAIL(); + ENDD(d1); + ENDD(d0); + ENDOp(); + + Op(traced_p_func2s_y_vc, yxn); + /* A1 is a variable */ +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2S_Y_VC_INSTINIT); +///#endif + traced_restart_func2s_y_vc: +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_LOW_LEVEL_TRACER); +///#endif + Term ti; + CELL *hi = HR; + + ti = MkIntegerTerm((Int)(PREG->u.yxn.c)); + RESET_VARIABLE(HR); + H[1] = XREG(PREG->u.yxn.xi); + H[2] = ti; + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + H = hi; + } +#endif /* LOW_LEVEL_TRACE */ + /* We have to build the structure */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_TEST_D0); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxn.xi); + deref_head(d0, traced_func2s_y_unk_vc); + traced_func2s_y_nvar_vc: +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC); +///#endif + BEGD(d1); + d1 = PREG->u.yxn.c; + if (!IsAtomicTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_D0NOATOMIC); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + /* We made it!!!!! we got in d0 the name, in d1 the arity and + * in pt0 the variable to bind it to. */ + if (d0 == TermDot && d1 == 2) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_EQUALS); +///#endif + RESET_VARIABLE(HR); + RESET_VARIABLE(HR+1); + d0 = AbsPair(HR); + H += 2; + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + BEGP(pt1); + pt1 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn),Osbpp),l); + INITIALIZE_PERMVAR(pt1,d0); + ENDP(pt1); + GONext(); + } + if (d1 == 0) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_D1ISZERO); +///#endif + BEGP(pt1); + pt1 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn),Osbpp),l); + INITIALIZE_PERMVAR(pt1,d0); + ENDP(pt1); + GONext(); + } + if (!IsAtomTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_D0NOATOM1); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + /* now let's build a compound term */ + if (!IsAtomTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_D0NOATOM2); +///#endif + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + BEGP(pt1); + if (!IsAtomTerm(d0)) { + TRACED_FAIL(); + } + else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_D0ATOM); +///#endif + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_POST_ELSE); +///#endif + pt1 = HR; + *pt1++ = d0; + d0 = AbsAppl(HR); + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { + /* make sure we have something to show for our trouble */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_IFOK_INIT); +///#endif + saveregs(); + if (!Yap_gcl((1+d1)*sizeof(CELL), 0, YREG, NEXTOP(NEXTOP(PREG,yxn),Osbpp))) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_IFOK_IFOK); +///#endif + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + setregs(); + JMPNext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_IFOK_NOIF); +///#endif + setregs(); + } + goto traced_restart_func2s_y_vc; + } + while ((Int)d1--) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_INSIDEWHILE); +///#endif + RESET_VARIABLE(pt1); + pt1++; + } + /* done building the term */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_END1); +///#endif + HR = pt1; + ENDP(pt1); + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + BEGP(pt1); + pt1 = YREG + PREG->u.yxn.y; + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn),Osbpp),l); + INITIALIZE_PERMVAR(pt1,d0); + ENDP(pt1); + ENDD(d1); + GONext(); + + BEGP(pt1); + deref_body(d0, pt1, traced_func2s_y_unk_vc, traced_func2s_y_nvar_vc); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2S_Y_VC_END2); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_func2f_xx, xxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2F_XX_INSTINIT); +///#endif +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_LOW_LEVEL_TRACER); +///#endif + H[0] = XREG(PREG->u.xxx.x); + RESET_VARIABLE(HR+1); + RESET_VARIABLE(HR+2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_TEST_D0); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xxx.x); + deref_head(d0, traced_func2f_xx_unk); + traced_func2f_xx_nvar: + if (IsApplTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_D0APPL); +///#endif + Functor d1 = FunctorOfTerm(d0); + if (IsExtensionFunctor(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_D0APPL_D1EXTFUNC); +///#endif + XREG(PREG->u.xxx.x1) = d0; + XREG(PREG->u.xxx.x2) = MkIntTerm(0); + PREG = NEXTOP(PREG, xxx); + GONext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_D0APPL_END); +///#endif + XREG(PREG->u.xxx.x1) = MkAtomTerm(NameOfFunctor(d1)); + XREG(PREG->u.xxx.x2) = MkIntegerTerm(ArityOfFunctor(d1)); + PREG = NEXTOP(PREG, xxx); + GONext(); + } else if (IsPairTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_D0PAIR); +///#endif + XREG(PREG->u.xxx.x1) = TermDot; + XREG(PREG->u.xxx.x2) = MkIntTerm(2); + PREG = NEXTOP(PREG, xxx); + GONext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_D0NOCOMPOUND); +///#endif + XREG(PREG->u.xxx.x1) = d0; + XREG(PREG->u.xxx.x2) = MkIntTerm(0); + PREG = NEXTOP(PREG, xxx); + GONext(); + } + + BEGP(pt1); + deref_body(d0, pt1, traced_func2f_xx_unk, traced_func2f_xx_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XX_END); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_func2f_xy, xxy); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2F_XY_INSTINIT); +///#endif +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_LOW_LEVEL_TRACER); +///#endif + H[0] = XREG(PREG->u.xxy.x); + RESET_VARIABLE(HR+1); + RESET_VARIABLE(HR+2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_TEST_D0); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.xxy.x); + deref_head(d0, traced_func2f_xy_unk); + traced_func2f_xy_nvar: + if (IsApplTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_D0APPL); +///#endif + Functor d1 = FunctorOfTerm(d0); + CELL *pt0 = YREG+PREG->u.xxy.y2; + if (IsExtensionFunctor(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_D0APPL_D1EXTFUNC); +///#endif + XREG(PREG->u.xxy.x1) = d0; + PREG = NEXTOP(PREG, xxy); + INITIALIZE_PERMVAR(pt0, MkIntTerm(0)); + GONext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_D0APPL_END); +///#endif + XREG(PREG->u.xxy.x1) = MkAtomTerm(NameOfFunctor(d1)); + PREG = NEXTOP(PREG, xxy); + INITIALIZE_PERMVAR(pt0, MkIntegerTerm(ArityOfFunctor(d1))); + GONext(); + } else if (IsPairTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_D0PAIR); +///#endif + CELL *pt0 = YREG+PREG->u.xxy.y2; + XREG(PREG->u.xxy.x1) = TermDot; + PREG = NEXTOP(PREG, xxy); + INITIALIZE_PERMVAR(pt0, MkIntTerm(2)); + GONext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_D0NOCOMPOUND); +///#endif + CELL *pt0 = YREG+PREG->u.xxy.y2; + XREG(PREG->u.xxy.x1) = d0; + PREG = NEXTOP(PREG, xxy); + INITIALIZE_PERMVAR(pt0, MkIntTerm(0)); + GONext(); + } + + BEGP(pt1); + deref_body(d0, pt1, traced_func2f_xy_unk, traced_func2f_xy_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_XY_END); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_func2f_yx, yxx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2F_YX_INSTINIT); +///#endif +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_LOW_LEVEL_TRACER); +///#endif + H[0] = XREG(PREG->u.yxx.x2); + RESET_VARIABLE(HR+1); + RESET_VARIABLE(HR+2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_TEST_D0); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yxx.x2); + deref_head(d0, traced_func2f_yx_unk); + traced_func2f_yx_nvar: + if (IsApplTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_D0APPL); +///#endif + Functor d1 = FunctorOfTerm(d0); + CELL *pt0 = YREG+PREG->u.yxx.y; + if (IsExtensionFunctor(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_D0APPL_D1EXTFUNC); +///#endif + XREG(PREG->u.yxx.x1) = MkIntTerm(0); + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0, d0); + GONext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_D0APPL_END); +///#endif + XREG(PREG->u.yxx.x1) = MkIntegerTerm(ArityOfFunctor(d1)); + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1))); + GONext(); + } else if (IsPairTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_D0PAIR); +///#endif + CELL *pt0 = YREG+PREG->u.yxx.y; + XREG(PREG->u.yxx.x1) = MkIntTerm(2); + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0 ,TermDot); + GONext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_D0NOCOMPOUND); +///#endif + CELL *pt0 = YREG+PREG->u.yxx.y; + XREG(PREG->u.yxx.x1) = MkIntTerm(0); + PREG = NEXTOP(PREG, yxx); + INITIALIZE_PERMVAR(pt0, d0); + GONext(); + } + + BEGP(pt1); + deref_body(d0, pt1, traced_func2f_yx_unk, traced_func2f_yx_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YX_END); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_func2f_yy, yyx); +///#ifdef PROFILED_ABSMI + EMIT_ENTRY_BLOCK(PREG,P_FUNC2F_YY_INSTINIT); +///#endif +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_LOW_LEVEL_TRACER); +///#endif + H[0] = XREG(PREG->u.yyx.x); + RESET_VARIABLE(HR+1); + RESET_VARIABLE(HR+2); + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),H); + } +#endif /* LOW_LEVEL_TRACE */ +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_TEST_D0); +///#endif + BEGD(d0); + d0 = XREG(PREG->u.yyx.x); + deref_head(d0, traced_func2f_yy_unk); + traced_func2f_yy_nvar: + if (IsApplTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_D0APPL); +///#endif + Functor d1 = FunctorOfTerm(d0); + CELL *pt0 = YREG+PREG->u.yyx.y1; + CELL *pt1 = YREG+PREG->u.yyx.y2; + if (IsExtensionFunctor(d1)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_D0APPL_D1EXTFUNC); +///#endif + PREG = NEXTOP(PREG, yyx); + INITIALIZE_PERMVAR(pt0, d0); + INITIALIZE_PERMVAR(pt1, MkIntTerm(0)); + GONext(); + } +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_D0APPL_END); +///#endif + PREG = NEXTOP(PREG, yyx); + INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1))); + INITIALIZE_PERMVAR(pt1, MkIntegerTerm(ArityOfFunctor(d1))); + GONext(); + } else if (IsPairTerm(d0)) { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_D0PAIR); +///#endif + CELL *pt0 = YREG+PREG->u.yyx.y1; + CELL *pt1 = YREG+PREG->u.yyx.y2; + PREG = NEXTOP(PREG, yyx); + INITIALIZE_PERMVAR(pt0, TermDot); + INITIALIZE_PERMVAR(pt1, MkIntTerm(2)); + GONext(); + } else { +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_D0NOCOMPOUND); +///#endif + CELL *pt0 = YREG+PREG->u.yyx.y1; + CELL *pt1 = YREG+PREG->u.yyx.y2; + PREG = NEXTOP(PREG, yyx); + INITIALIZE_PERMVAR(pt0, d0); + INITIALIZE_PERMVAR(pt1, MkIntTerm(0)); + GONext(); + } + + BEGP(pt1); + deref_body(d0, pt1, traced_func2f_yy_unk, traced_func2f_yy_nvar); +///#ifdef PROFILED_ABSMI + EMIT_SIMPLE_BLOCK(P_FUNC2F_YY_END); +///#endif + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + ENDD(d0); + ENDOp(); + + Op(traced_p_functor, e); + EMIT_ENTRY_BLOCK(PREG,P_FUNCTOR_INSTINIT); + EMIT_MULTIPLE_DESTINY_BLOCK_TEST(P_FUNCTOR_END); +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) + low_level_trace(enter_pred,RepPredPrOp(traced_Yap_GetPredPropByFunc(FunctorFunctor,0)),XREGS+1); +#endif /* LOW_LEVEL_TRACE */ + traced_restart_functor: + BEGD(d0); + d0 = ARG1; + deref_head(d0, traced_func_unk); + traced_func_nvar: + /* A1 is bound */ + BEGD(d1); + if (IsApplTerm(d0)) { + d1 = *RepAppl(d0); + if (IsExtensionFunctor((Functor) d1)) { + if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt ) { + d1 = MkIntTerm(0); + } else + TRACED_FAIL(); + } else { + d0 = MkAtomTerm(NameOfFunctor((Functor) d1)); + d1 = MkIntTerm(ArityOfFunctor((Functor) d1)); + } + } + else if (IsPairTerm(d0)) { + d0 = TermDot; + d1 = MkIntTerm(2); + } + else { + d1 = MkIntTerm(0); + } + /* d1 and d0 now have the two arguments */ + /* let's go and bind them */ + { + register CELL arity = d1; + + d1 = ARG2; + deref_head(d1, traced_func_nvar_unk); + traced_func_nvar_nvar: + /* A2 was bound */ + if (d0 != d1) { + TRACED_FAIL(); + } + /* I have to this here so that I don't have a jump to a closing bracket */ + d0 = arity; + goto traced_func_bind_x3; + + BEGP(pt0); + deref_body(d1, pt0, traced_func_nvar_unk, traced_func_nvar_nvar); + /* A2 is a variable, go and bind it */ + Bind(pt0, d0); + /* I have to this here so that I don't have a jump to a closing bracket */ + d0 = arity; + ENDP(pt0); + traced_func_bind_x3: + /* now let's process A3 */ + d1 = ARG3; + deref_head(d1, traced_func_nvar3_unk); + traced_func_nvar3_nvar: + /* A3 was bound */ + if (d0 != d1) { + TRACED_FAIL(); + } + /* Done */ + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e),Osbmp),l); + GONext(); + + BEGP(pt0); + deref_body(d1, pt0, traced_func_nvar3_unk, traced_func_nvar3_nvar); + /* A3 is a variable, go and bind it */ + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e),Osbmp),l); + Bind(pt0, d0); + /* Done */ + GONext(); + + + ENDP(pt0); + + } + ENDD(d1); + + BEGP(pt0); + deref_body(d0, pt0, traced_func_unk, traced_func_nvar); + /* A1 is a variable */ + /* We have to build the structure */ + d0 = ARG2; + deref_head(d0, traced_func_var_2unk); + traced_func_var_2nvar: + /* we do, let's get the third argument */ + BEGD(d1); + d1 = ARG3; + deref_head(d1, traced_func_var_3unk); + traced_func_var_3nvar: + /* Uuuff, the second and third argument are bound */ + if (IsIntTerm(d1)) + d1 = IntOfTerm(d1); + else { + saveregs(); + Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); + setregs(); + TRACED_FAIL(); + } + if (!IsAtomicTerm(d0)) { + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } /* We made it!!!!! we got in d0 the name, in d1 the arity and + * in pt0 the variable to bind it to. */ + if (d0 == TermDot && d1 == 2) { + RESET_VARIABLE(HR); + RESET_VARIABLE(HR+1); + d0 = AbsPair(HR); + H += 2; + } + else if ((Int)d1 > 0) { + /* now let's build a compound term */ + if (!IsAtomTerm(d0)) { + saveregs(); + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); + setregs(); + TRACED_FAIL(); + } + BEGP(pt1); + if (!IsAtomTerm(d0)) { + TRACED_FAIL(); + } + else + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + pt1 = HR; + *pt1++ = d0; + d0 = AbsAppl(HR); + if (pt1+d1 > ENV || pt1+d1 > (CELL *)B) { + /* make sure we have something to show for our trouble */ + saveregs(); + if (!Yap_gcl((1+d1)*sizeof(CELL), 3, YREG, NEXTOP(NEXTOP(PREG,e),Osbmp))) { + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + setregs(); + JMPNext(); + } else { + setregs(); + } + goto traced_restart_functor; /* */ + } + while ((Int)d1--) { + RESET_VARIABLE(pt1); + pt1++; + } + /* done building the term */ + H = pt1; + ENDP(pt1); + } else if ((Int)d1 < 0) { + saveregs(); + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); + setregs(); + TRACED_FAIL(); + } + /* else if arity is 0 just pass d0 through */ + /* Ding, ding, we made it */ + PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e),Osbpp),l); + Bind(pt0, d0); + GONext(); + + + BEGP(pt1); + deref_body(d1, pt1, traced_func_var_3unk, traced_func_var_3nvar); + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, third argument was unbound */ + TRACED_FAIL(); + ENDD(d1); + + BEGP(pt1); + deref_body(d0, pt1, traced_func_var_2unk, traced_func_var_2nvar); + saveregs(); + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + ENDP(pt0); + ENDD(d0); + ENDOp(); + + BOp(traced_p_execute2, Osbpp); + //printf("p_execute2!!\n"); + { + PredEntry *pen; + Term mod = ARG2; + + deref_head(mod, traced_execute2_unk0); + traced_execute2_nvar0: + if (!IsAtomTerm(mod)) { + saveregs(); + Yap_Error(TYPE_ERROR_ATOM, mod, "call/2"); + setregs(); + } + CACHE_Y_AS_ENV(YREG); + /* Try to preserve the environment */ + ENV_YREG = (CELL *) (((char *) YREG) + PREG->u.Osbpp.s); +#ifdef FROZEN_STACKS + { + choiceptr top_b = PROTECT_FROZEN_B(B); +#ifdef YAPOR_SBA + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) ENV_YREG = (CELL *) top_b; +#else + if (ENV_YREG > (CELL *) top_b) ENV_YREG = (CELL *) top_b; +#endif /* YAPOR_SBA */ + } +#else + if (ENV_YREG > (CELL *) B) { + ENV_YREG = (CELL *) B; + } +#endif /* FROZEN_STACKS */ + BEGD(d0); + d0 = ARG1; + traced_restart_execute2: + deref_head(d0, traced_execute2_unk); + traced_execute2_nvar: + if (IsApplTerm(d0)) { + Functor f = FunctorOfTerm(d0); + if (IsExtensionFunctor(f)) { + goto traced_execute2_metacall; + } + pen = RepPredProp(PredPropByFunc(f, mod)); + if (pen->PredFlags & (MetaPredFlag|GoalExPredFlag)) { + if (f == FunctorModule) { + Term tmod = ArgOfTerm(1,d0); + if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { + d0 = ArgOfTerm(2,d0); + mod = tmod; + goto execute2_nvar; + } + } else if (f == FunctorComma) { + SREG = RepAppl(d0); + BEGD(d1); + d1 = SREG[2]; + /* create an to execute2 the call */ + deref_head(d1, traced_execute2_comma_unk); + traced_execute2_comma_nvar: + if (IsAtomTerm(d1)) { + ENV_YREG[-EnvSizeInCells-2] = MkIntegerTerm((Int)PredPropByAtom(AtomOfTerm(d1),mod)); + ENV_YREG[-EnvSizeInCells-3] = mod; + } else if (IsApplTerm(d1)) { + Functor f = FunctorOfTerm(d1); + if (IsExtensionFunctor(f)) { + goto traced_execute2_metacall; + } else { + if (f == FunctorModule) goto traced_execute2_metacall; + ENV_YREG[-EnvSizeInCells-2] = MkIntegerTerm((Int)PredPropByFunc(f,mod)); + ENV_YREG[-EnvSizeInCells-3] = mod; + } + } else { + goto traced_execute2_metacall; + } + ENV_YREG[E_CP] = (CELL)NEXTOP(PREG,Osbpp); + ENV_YREG[E_CB] = (CELL)B; + ENV_YREG[E_E] = (CELL)ENV; +#ifdef DEPTH_LIMIT + ENV_YREG[E_DEPTH] = DEPTH; +#endif /* DEPTH_LIMIT */ + ENV_YREG[-EnvSizeInCells-1] = d1; + ENV = ENV_YREG; + ENV_YREG -= EnvSizeInCells+3; + PREG = COMMA_CODE; + /* for profiler */ + save_pc(); + d0 = SREG[1]; + goto traced_restart_execute2; + + BEGP(pt1); + deref_body(d1, pt1, traced_execute2_comma_unk, traced_execute2_comma_nvar); + goto traced_execute2_metacall; + ENDP(pt1); + ENDD(d1); + } else if (mod != CurrentModule) { + goto traced_execute2_metacall; + } + } + if (PRED_GOAL_EXPANSION_ALL) { + goto traced_execute2_metacall; + } + + BEGP(pt1); + pt1 = RepAppl(d0); + BEGD(d2); + for (d2 = ArityOfFunctor(f); d2; d2--) { +#ifdef YAPOR_SBA + BEGD(d1); + d1 = pt1[d2]; + if (d1 == 0) { + XREGS[d2] = (CELL)(pt1+d2); + } else { + XREGS[d2] = d1; + } +#else + XREGS[d2] = pt1[d2]; +#endif + } + ENDD(d2); + ENDP(pt1); + CACHE_A1(); + } else if (IsAtomTerm(d0)) { + if (PRED_GOAL_EXPANSION_ALL) { + goto traced_execute2_metacall; + } else { + pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), mod)); + } + } else { + goto traced_execute2_metacall; + } + + traced_execute2_end: + /* code copied from call */ +#ifndef NO_CHECKING + check_stack(traced_NoStackPExecute2, HR); +#endif + CPREG = NEXTOP(PREG, Osbpp); + ALWAYS_LOOKAHEAD(pen->OpcodeOfPred); + PREG = pen->CodeOfPred; + /* for profiler */ + save_pc(); +#ifdef DEPTH_LIMIT + if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is primitives */ + if (pen->ModuleOfPred) { + if (DEPTH == MkIntTerm(0)) { + TRACED_FAIL(); + } + else DEPTH = RESET_DEPTH(); + } + } else if (pen->ModuleOfPred) + DEPTH -= MkIntConstant(2); +#endif /* DEPTH_LIMIT */ +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) + low_level_trace(enter_pred,pen,XREGS+1); +#endif /* LOW_LEVEL_TRACER */ + WRITEBACK_Y_AS_ENV(); + /* setup GB */ + ENV_YREG[E_CB] = (CELL) B; +#ifdef YAPOR + SCH_check_requests(); +#endif /* YAPOR */ + CACHE_A1(); + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + + BEGP(pt1); + deref_body(d0, pt1, traced_execute2_unk, traced_execute2_nvar); + traced_execute2_metacall: + ARG1 = ARG3 = d0; + pen = PredMetaCall; + ARG2 = Yap_cp_as_integer(B); + if (mod) + ARG4 = mod; + else + ARG4 = TermProlog; + goto traced_execute2_end; + ENDP(pt1); + + ENDD(d0); + traced_NoStackPExecute2: + CHECK_ALARM(goto traced_execute2_end); + if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { + LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; + if (!LOCAL_ActiveSignals) + CreepFlag = CalculateStackGap(); + goto fail; + } + PP = PredMetaCall; + SREG = (CELL *) pen; + ASP = ENV_YREG; + if (ASP > (CELL *)PROTECT_FROZEN_B(B)) + ASP = (CELL *)PROTECT_FROZEN_B(B); + /* setup GB */ + WRITEBACK_Y_AS_ENV(); + YREG[E_CB] = (CELL) B; + if (LOCAL_ActiveSignals) { + goto traced_creep_pe; + } + saveregs_and_ycache(); + if (!Yap_gc(((PredEntry *)SREG)->ArityOfPE, ENV, NEXTOP(PREG, Osbpp))) { + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + } + setregs_and_ycache(); + goto traced_execute2_end; + ENDCACHE_Y_AS_ENV(); + + BEGP(pt1); + deref_body(mod, pt1, traced_execute2_unk0, traced_execute2_nvar0); + saveregs(); + Yap_Error(INSTANTIATION_ERROR, mod, "call/2"); + setregs(); + ENDP(pt1); + /* Oops, second argument was unbound too */ + TRACED_FAIL(); + } + ENDBOp(); + + BOp(traced_p_execute, Osbmp); + //printf("p_execute!!\n"); + { + PredEntry *pen; + Term mod = PREG->u.Osbmp.mod; + + CACHE_Y_AS_ENV(YREG); + /* Try to preserve the environment */ + ENV_YREG = (CELL *) (((char *) YREG) + PREG->u.Osbmp.s); +#ifdef FROZEN_STACKS + { + choiceptr top_b = PROTECT_FROZEN_B(B); +#ifdef YAPOR_SBA + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) ENV_YREG = (CELL *) top_b; +#else + if (ENV_YREG > (CELL *) top_b) ENV_YREG = (CELL *) top_b; +#endif /* YAPOR_SBA */ + } +#else + if (ENV_YREG > (CELL *) B) { + ENV_YREG = (CELL *) B; + } +#endif /* FROZEN_STACKS */ + BEGD(d0); + d0 = ARG1; + traced_restart_execute: + deref_head(d0, traced_execute_unk); + traced_execute_nvar: + if (IsApplTerm(d0)) { + Functor f = FunctorOfTerm(d0); + if (IsExtensionFunctor(f)) { + goto traced_execute_metacall; + } + pen = RepPredProp(PredPropByFunc(f, mod)); + if (pen->PredFlags & (MetaPredFlag|GoalExPredFlag)) { + if (f == FunctorModule) { + Term tmod = ArgOfTerm(1,d0); + if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { + d0 = ArgOfTerm(2,d0); + mod = tmod; + goto traced_execute_nvar; + } + } else if (f == FunctorComma) { + SREG = RepAppl(d0); + BEGD(d1); + d1 = SREG[2]; + /* create an to execute the call */ + deref_head(d1, traced_execute_comma_unk); + traced_execute_comma_nvar: + if (IsAtomTerm(d1)) { + ENV_YREG[-EnvSizeInCells-2] = MkIntegerTerm((Int)PredPropByAtom(AtomOfTerm(d1),mod)); + ENV_YREG[-EnvSizeInCells-3] = mod; + } else if (IsApplTerm(d1)) { + f = FunctorOfTerm(d1); + if (IsExtensionFunctor(f)) { + goto traced_execute_metacall; + } else { + if (f == FunctorModule) goto traced_execute_metacall; + ENV_YREG[-EnvSizeInCells-2] = MkIntegerTerm((Int)PredPropByFunc(f,mod)); + ENV_YREG[-EnvSizeInCells-3] = mod; + } + } else { + goto traced_execute_metacall; + } + ENV_YREG[E_CP] = (CELL)NEXTOP(PREG,Osbmp); + ENV_YREG[E_CB] = (CELL)B; + ENV_YREG[E_E] = (CELL)ENV; +#ifdef DEPTH_LIMIT + ENV_YREG[E_DEPTH] = DEPTH; +#endif /* DEPTH_LIMIT */ + ENV_YREG[-EnvSizeInCells-1] = d1; + ENV = ENV_YREG; + ENV_YREG -= EnvSizeInCells+3; + PREG = COMMA_CODE; + /* for profiler */ + save_pc(); + d0 = SREG[1]; + goto traced_restart_execute; + + BEGP(pt1); + deref_body(d1, pt1, traced_execute_comma_unk, traced_execute_comma_nvar); + goto traced_execute_metacall; + ENDP(pt1); + ENDD(d1); + } else if (mod != CurrentModule) { + goto traced_execute_metacall; + } + } + if (PRED_GOAL_EXPANSION_ALL) { + goto traced_execute_metacall; + } + + BEGP(pt1); + pt1 = RepAppl(d0); + BEGD(d2); + for (d2 = ArityOfFunctor(f); d2; d2--) { +#ifdef YAPOR_SBA + BEGD(d1); + d1 = pt1[d2]; + if (d1 == 0) { + XREGS[d2] = (CELL)(pt1+d2); + } else { + XREGS[d2] = d1; + } +#else + XREGS[d2] = pt1[d2]; +#endif + } + ENDD(d2); + ENDP(pt1); + CACHE_A1(); + } else if (IsAtomTerm(d0)) { + if (PRED_GOAL_EXPANSION_ALL) { + goto traced_execute_metacall; + } else { + pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), mod)); + } + } else { + goto traced_execute_metacall; + } + + traced_execute_end: + /* code copied from call */ +#ifndef NO_CHECKING + check_stack(traced_NoStackPExecute, HR); +#endif + CPREG = NEXTOP(PREG, Osbmp); + ALWAYS_LOOKAHEAD(pen->OpcodeOfPred); + PREG = pen->CodeOfPred; + /* for profiler */ + save_pc(); +#ifdef DEPTH_LIMIT + if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is primitives */ + if (pen->ModuleOfPred) { + if (DEPTH == MkIntTerm(0)) { + TRACED_FAIL(); + } + else DEPTH = RESET_DEPTH(); + } + } else if (pen->ModuleOfPred) + DEPTH -= MkIntConstant(2); +#endif /* DEPTH_LIMIT */ +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) + low_level_trace(enter_pred,pen,XREGS+1); +#endif /* LOW_LEVEL_TRACER */ + WRITEBACK_Y_AS_ENV(); + /* setup GB */ + ENV_YREG[E_CB] = (CELL) B; +#ifdef YAPOR + SCH_check_requests(); +#endif /* YAPOR */ + CACHE_A1(); + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + + BEGP(pt1); + deref_body(d0, pt1, traced_execute_unk, traced_execute_nvar); + traced_execute_metacall: + ARG1 = ARG3 = d0; + pen = PredMetaCall; + ARG2 = Yap_cp_as_integer(B); + if (mod) + ARG4 = mod; + else + ARG4 = TermProlog; + goto traced_execute_end; + ENDP(pt1); + + ENDD(d0); + traced_NoStackPExecute: + CHECK_ALARM(goto traced_execute_end); + if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { + LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; + if (!LOCAL_ActiveSignals) + CreepFlag = CalculateStackGap(); + goto fail; + } + PP = PredMetaCall; + SREG = (CELL *) pen; + ASP = ENV_YREG; + if (ASP > (CELL *)PROTECT_FROZEN_B(B)) + ASP = (CELL *)PROTECT_FROZEN_B(B); + /* setup GB */ + WRITEBACK_Y_AS_ENV(); + YREG[E_CB] = (CELL) B; + if (LOCAL_ActiveSignals) { + goto traced_creep_pe; + } + saveregs_and_ycache(); + if (!Yap_gc(((PredEntry *)SREG)->ArityOfPE, ENV, NEXTOP(PREG, Osbmp))) { + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + } + setregs_and_ycache(); + goto traced_execute_end; + ENDCACHE_Y_AS_ENV(); + } + ENDBOp(); + + traced_creep_pe: /* do creep in call */ + CPREG = NEXTOP(PREG, Osbmp); + goto creep; + + BOp(traced_p_execute_tail, Osbpp); + { + PredEntry *pen; + Term mod; + UInt arity; + + CACHE_Y_AS_ENV(YREG); + BEGP(pt0); + BEGD(d0); + d0 = ENV_YREG[-EnvSizeInCells-1]; + pen = RepPredProp((Prop)IntegerOfTerm(ENV_YREG[-EnvSizeInCells-2])); + CPREG = (yamop *) ENV_YREG[E_CP]; + pt0 = ENV_YREG; + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; +#ifdef FROZEN_STACKS + { + choiceptr top_b = PROTECT_FROZEN_B(B); + +#ifdef YAPOR_SBA + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) ENV_YREG = (CELL *) top_b; +#else + if (ENV_YREG > (CELL *) top_b) ENV_YREG = (CELL *) top_b; +#endif /* YAPOR_SBA */ + else ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size(CPREG)); + } +#else + if (ENV_YREG > (CELL *)B) { + ENV_YREG = (CELL *)B; + } else { + ENV_YREG = (CELL *) ((CELL) ENV_YREG+ ENV_Size(CPREG)); + } +#endif /* FROZEN_STACKS */ + arity = pen->ArityOfPE; + if (pen->PredFlags & (MetaPredFlag|GoalExPredFlag)) { + mod = pt0[-EnvSizeInCells-3]; + if (pen->FunctorOfPred == FunctorComma) { + SREG = RepAppl(d0); + BEGD(d1); + d1 = SREG[2]; + traced_execute_comma_comma: + /* create an to execute the call */ + deref_head(d1, traced_execute_comma_comma_unk); + traced_execute_comma_comma_nvar: + ENV_YREG[E_CB] = pt0[E_CB]; + if (IsAtomTerm(d1)) { + ENV_YREG[-EnvSizeInCells-2] = MkIntegerTerm((Int)PredPropByAtom(AtomOfTerm(d1),mod)); + } else if (IsApplTerm(d1)) { + Functor f = FunctorOfTerm(d1); + if (IsExtensionFunctor(f)) { + goto traced_execute_metacall_after_comma; + } else if (f == FunctorModule) { + Term tmod = ArgOfTerm(1, d1); + if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) + goto traced_execute_metacall_after_comma; + mod = tmod; + d1 = RepAppl(d1)[2]; + goto traced_execute_comma_comma; + } else { + ENV_YREG[-EnvSizeInCells-2] = MkIntegerTerm((Int)PredPropByFunc(f,mod)); + } + } else { + goto traced_execute_metacall_after_comma; + } + ENV_YREG[E_CP] = (CELL)CPREG; + ENV_YREG[E_E] = (CELL)ENV; +#ifdef DEPTH_LIMIT + ENV_YREG[E_DEPTH] = DEPTH; +#endif /* DEPTH_LIMIT */ + ENV_YREG[-EnvSizeInCells-1] = d1; + ENV_YREG[-EnvSizeInCells-3] = mod; + ENV = ENV_YREG; + ENV_YREG -= EnvSizeInCells+3; + d0 = SREG[1]; + CPREG = NEXTOP(COMMA_CODE,Osbpp); + traced_execute_comma_comma2: + /* create an to execute the call */ + deref_head(d0, traced_execute_comma_comma2_unk); + traced_execute_comma_comma2_nvar: + if (IsAtomTerm(d0)) { + Atom at = AtomOfTerm(d0); + arity = 0; + if (at == AtomCut) { + choiceptr cut_pt = (choiceptr)pt0[E_CB]; + SET_ASP(YREG, E_CB*sizeof(CELL)); + saveregs(); + prune(cut_pt); + setregs(); + } + pen = RepPredProp(PredPropByAtom(at, mod)); + goto traced_execute_comma; + } else if (IsApplTerm(d0)) { + Functor f = FunctorOfTerm(d0); + if (IsExtensionFunctor(f) || f == FunctorModule) { + Term tmod = ArgOfTerm(1, d0); + if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) + goto traced_execute_metacall_after_comma; + mod = tmod; + d0 = RepAppl(d0)[2]; + goto traced_execute_comma_comma2; + } else { + pen = RepPredProp(PredPropByFunc(f,mod)); + if (pen->PredFlags & (MetaPredFlag|GoalExPredFlag)) { + goto traced_execute_metacall_after_comma; + } + arity = pen->ArityOfPE; + goto traced_execute_comma; + } + } else { + if (mod != CurrentModule) + goto traced_execute_metacall_after_comma; + else { + arity = pen->ArityOfPE; + goto traced_execute_comma; + } + } + + BEGP(pt1); + deref_body(d0, pt1, traced_execute_comma_comma2_unk, traced_execute_comma_comma2_nvar); + goto traced_execute_metacall_after_comma; + ENDP(pt1); + + BEGP(pt1); + deref_body(d1, pt1, traced_execute_comma_comma_unk, traced_execute_comma_comma_nvar); + goto traced_execute_metacall_after_comma; + ENDP(pt1); + ENDD(d1); + } else { + if (mod != CurrentModule) { + traced_execute_metacall_after_comma: + ARG1 = ARG3 = d0; + pen = PredMetaCall; + ARG2 = Yap_cp_as_integer((choiceptr)pt0[E_CB]); + if (mod) + ARG4 = mod; + else + ARG4 = TermProlog; + CACHE_A1(); + goto traced_execute_after_comma; + } + } + } + traced_execute_comma: + if (arity) { + BEGP(pt1); + pt1 = RepAppl(d0); + BEGD(d2); + for (d2 = arity; d2; d2--) { +#ifdef YAPOR_SBA + BEGD(d1); + d1 = pt1[d2]; + if (d1 == 0) + XREGS[d2] = (CELL)(pt1+d2); + else + XREGS[d2] = d1; +#else + XREGS[d2] = pt1[d2]; +#endif + } + ENDD(d2); + ENDP(pt1); + CACHE_A1(); + } else if ((Atom)(pen->FunctorOfPred) == AtomCut) { + choiceptr cut_pt = (choiceptr)pt0[E_CB]; + SET_ASP(YREG, E_CB*sizeof(CELL)); + saveregs(); + prune(cut_pt); + setregs(); + } + + traced_execute_after_comma: +#ifndef NO_CHECKING + check_stack(traced_NoStackPTExecute, HR); +#endif + PREG = pen->CodeOfPred; + /* for profiler */ + save_pc(); + ALWAYS_LOOKAHEAD(pen->OpcodeOfPred); + ENV_YREG[E_CB] = (CELL)B; +#ifdef LOW_LEVEL_TRACER + if (Yap_do_low_level_trace) + low_level_trace(enter_pred,pen,XREGS+1); +#endif /* LOW_LEVEL_TRACER */ +#ifdef DEPTH_LIMIT + if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is primitives */ + if (pen->ModuleOfPred) { + if (DEPTH == MkIntTerm(0)){ + TRACED_FAIL(); + } + else DEPTH = RESET_DEPTH(); + } + } else if (pen->ModuleOfPred) { + DEPTH -= MkIntConstant(2); + } +#endif /* DEPTH_LIMIT */ + /* do deallocate */ + WRITEBACK_Y_AS_ENV(); + ALWAYS_GONext(); + ALWAYS_END_PREFETCH(); + + ENDD(d0); + ENDP(pt0); + traced_NoStackPTExecute: + CHECK_ALARM(goto traced_execute_after_comma); + if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { + LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; + if (!LOCAL_ActiveSignals) + CreepFlag = CalculateStackGap(); + goto fail; + } + PP = NULL; + WRITEBACK_Y_AS_ENV(); + SREG = (CELL *) pen; + ASP = ENV_YREG; + if (ASP > (CELL *)PROTECT_FROZEN_B(B)) + ASP = (CELL *)PROTECT_FROZEN_B(B); + LOCK(LOCAL_SignalLock); + if (LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) { + UNLOCK(LOCAL_SignalLock); + saveregs_and_ycache(); + if (!Yap_growheap(FALSE, 0, NULL)) { + Yap_NilError(OUT_OF_HEAP_ERROR, "YAP failed to grow heap: %s", LOCAL_ErrorMessage); + setregs_and_ycache(); + TRACED_FAIL(); + } + setregs_and_ycache(); + LOCK(LOCAL_SignalLock); + LOCAL_ActiveSignals &= ~YAP_CDOVF_SIGNAL; + CreepFlag = CalculateStackGap(); + if (!LOCAL_ActiveSignals) { + UNLOCK(LOCAL_SignalLock); + goto traced_execute_after_comma; + } + } + if (LOCAL_ActiveSignals & YAP_TROVF_SIGNAL) { + UNLOCK(LOCAL_SignalLock); +#ifdef SHADOW_S + S = SREG; +#endif + saveregs_and_ycache(); + if(!Yap_growtrail (0, FALSE)) { + Yap_NilError(OUT_OF_TRAIL_ERROR,"YAP failed to reserve %ld bytes in growtrail",sizeof(CELL) * K16); + setregs_and_ycache(); + TRACED_FAIL(); + } + setregs_and_ycache(); + LOCAL_ActiveSignals &= ~YAP_TROVF_SIGNAL; + CreepFlag = CalculateStackGap(); + if (!LOCAL_ActiveSignals) { + UNLOCK(LOCAL_SignalLock); + goto traced_execute_after_comma; + } + } + if (LOCAL_ActiveSignals) { + if (LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) { + UNLOCK(LOCAL_SignalLock); + SREG = YENV; + goto noheapleft; + } + UNLOCK(LOCAL_SignalLock); + goto creep; + } + UNLOCK(LOCAL_SignalLock); + saveregs_and_ycache(); + if (!Yap_gc(((PredEntry *)SREG)->ArityOfPE, ENV, NEXTOP(PREG, Osbpp))) { + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); + } + setregs_and_ycache(); + goto traced_execute_after_comma; + ENDCACHE_Y_AS_ENV(); + + } + ENDBOp(); diff --git a/JIT/HPP/yaam_basics.h b/JIT/HPP/yaam_basics.h new file mode 100644 index 000000000..45717bb07 --- /dev/null +++ b/JIT/HPP/yaam_basics.h @@ -0,0 +1,198 @@ +#define JIT_HANDLER_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG), jhc); + +#define I_R (XREGS[0]) + +#define YAAM_CHECK_TRAIL_TR { check_trail(TR); } + +#define YAAM_DEREF_BODY_D0PT0 \ + if (!IsVarTerm(d0)) { BACK(); } \ + pt0 = (CELL *)d0; \ + d0 = *(CELL *)d0; + +#define YAAM_DEREF_BODY_D0PT1 \ + if (!IsVarTerm(d0)) { BACK(); } \ + pt1 = (CELL *)d0; \ + d0 = *(CELL *)d0; + +#define YAAM_DEREF_BODY_D1PT0 \ + if (!IsVarTerm(d1)) { BACK(); } \ + pt0 = (CELL *)d1; \ + d1 = *(CELL *)d1; + +#define YAAM_DEREF_BODY_D1PT1 \ + if (!IsVarTerm(d1)) { BACK(); } \ + pt1 = (CELL *)d1; \ + d1 = *(CELL *)d1; + +#define YAAM_UNIFYBOUND \ + if (d0 == d1) { \ + GONext(); \ + } \ + else if (IsPairTerm(d0)) { \ + if (!IsPairTerm(d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + register CELL *ipt0, *ipt1; \ + ipt0 = RepPair(d0); \ + ipt1 = RepPair(d1); \ + save_hb(); \ + always_save_pc(); \ + if (IUnify_complex(ipt0-1,ipt0+1,ipt1-1)) { \ + always_set_pc(); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } \ + } \ + else if (IsApplTerm(d0)) { \ + if (!IsApplTerm(d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + register CELL *ipt0, *ipt1; \ + register Functor f; \ + ipt0 = RepAppl(d0); \ + ipt1 = RepAppl(d1); \ + f = (Functor)*ipt0; \ + if (f != (Functor)*ipt1) { \ + YAAM_FAIL; \ + } \ + else if (IsExtensionFunctor(f)) { \ + if (unify_extension(f, d0, RepAppl(d0), d1)) { \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } \ + else { \ + d0 = ArityOfFunctor(f); \ + always_save_pc(); \ + save_hb(); \ + if (IUnify_complex(ipt0, ipt0+d0, ipt1)) { \ + always_set_pc(); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } \ + } \ + } \ + else { \ + YAAM_FAIL; \ + } + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define NoStackDeallocate_Exception \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + return external_labels[8]; \ + } + +#define NoStackCall_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + return external_labels[6]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackDExecute_Exception \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + return external_labels[7]; \ + } + +#define NoStackExecute_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + return external_labels[5]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackFail_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + return external_labels[10]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackEither_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + return external_labels[4]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackCommitY_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + return external_labels[2]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackCommitX_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + return external_labels[11]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#else +#define NoStackDeallocate_Exception \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + return external_labels[8]; \ + } + +#define NoStackCall_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + return external_labels[6]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackDExecute_Exception \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + return external_labels[7]; \ + } + +#define NoStackExecute_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + return external_labels[5]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackFail_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + return external_labels[10]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackEither_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + return external_labels[4]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackCommitY_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + return external_labels[2]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackCommitX_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + return external_labels[11]; \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA && YAPOR */ + +#define YAAM_FAIL \ + FAILED = 1; diff --git a/JIT/HPP/yaam_basics_d.h b/JIT/HPP/yaam_basics_d.h new file mode 100644 index 000000000..de3cd0930 --- /dev/null +++ b/JIT/HPP/yaam_basics_d.h @@ -0,0 +1,264 @@ +#define JIT_HANDLER_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + print_main_when_head((*_PREG), ON_NATIVE); \ + (*_PREG) = NEXTOP((*_PREG), jhc); + +#define I_R (XREGS[0]) + +#define YAAM_CHECK_TRAIL_TR { check_trail(TR); } + +#define YAAM_DEREF_BODY_D0PT0 \ + if (!IsVarTerm(d0)) { BACK(); } \ + pt0 = (CELL *)d0; \ + d0 = *(CELL *)d0; + +#define YAAM_DEREF_BODY_D0PT1 \ + if (!IsVarTerm(d0)) { BACK(); } \ + pt1 = (CELL *)d0; \ + d0 = *(CELL *)d0; + +#define YAAM_DEREF_BODY_D1PT0 \ + if (!IsVarTerm(d1)) { BACK(); } \ + pt0 = (CELL *)d1; \ + d1 = *(CELL *)d1; + +#define YAAM_DEREF_BODY_D1PT1 \ + if (!IsVarTerm(d1)) { BACK(); } \ + pt1 = (CELL *)d1; \ + d1 = *(CELL *)d1; + +#define YAAM_UNIFYBOUND \ + if (d0 == d1) { \ + GONext(); \ + } \ + else if (IsPairTerm(d0)) { \ + if (!IsPairTerm(d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + register CELL *ipt0, *ipt1; \ + ipt0 = RepPair(d0); \ + ipt1 = RepPair(d1); \ + save_hb(); \ + always_save_pc(); \ + if (IUnify_complex(ipt0-1,ipt0+1,ipt1-1)) { \ + always_set_pc(); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } \ + } \ + else if (IsApplTerm(d0)) { \ + if (!IsApplTerm(d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + register CELL *ipt0, *ipt1; \ + register Functor f; \ + ipt0 = RepAppl(d0); \ + ipt1 = RepAppl(d1); \ + f = (Functor)*ipt0; \ + if (f != (Functor)*ipt1) { \ + YAAM_FAIL; \ + } \ + else if (IsExtensionFunctor(f)) { \ + if (unify_extension(f, d0, RepAppl(d0), d1)) { \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } \ + else { \ + d0 = ArityOfFunctor(f); \ + always_save_pc(); \ + save_hb(); \ + if (IUnify_complex(ipt0, ipt0+d0, ipt1)) { \ + always_set_pc(); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } \ + } \ + } \ + else { \ + YAAM_FAIL; \ + } + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define NoStackDeallocate_Exception \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[8]; \ + } + +#define NoStackCall_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[6]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackDExecute_Exception \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[7]; \ + } + +#define NoStackExecute_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[5]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackFail_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[10]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackEither_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[4]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackCommitY_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[2]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackCommitX_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[11]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#else +#define NoStackDeallocate_Exception \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[8]; \ + } + +#define NoStackCall_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[6]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackDExecute_Exception \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[7]; \ + } + +#define NoStackExecute_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[5]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackFail_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[10]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackEither_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[4]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackCommitY_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[2]; \ + } \ + ENDCACHE_Y_AS_ENV(); + +#define NoStackCommitX_Exception \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); \ + } \ + return external_labels[11]; \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA && YAPOR */ + +#define YAAM_FAIL \ + FAILED = 1; diff --git a/JIT/HPP/yaam_call.h b/JIT/HPP/yaam_call.h new file mode 100644 index 000000000..ede8266eb --- /dev/null +++ b/JIT/HPP/yaam_call.h @@ -0,0 +1,373 @@ +#define EXECUTE_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + PredEntry *pt0; \ + register CELL *ENV_YREG = (YREG); \ + pt0 = (*_PREG)->u.pp.p; + +#ifdef LOW_LEVEL_TRACER +#define EXECUTE_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,pt0,XREGS+1); +#endif + +#define EXECUTE_POST_LOW_LEVEL_TRACER \ + CACHE_A1(); \ + ALWAYS_LOOKAHEAD(pt0->OpcodeOfPred); \ + d0 = (CELL)B; + +#define EXECUTE_POST_NOCHECKING \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; + +#ifdef DEPTH_LIMIT +#define EXECUTE_DEPTH_MINOR \ + FAILED = 0; \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + YAAM_FAIL; \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define EXECUTE_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define EXECUTE_DEPTH_END \ + FAILED = 0; +#endif + +#define EXECUTE_END_END \ + BLOCK = (CELL)EXECUTE_END_END; \ + if (!FAILED) { \ + ALWAYS_GONext(); \ + } \ + +#define DEXECUTE_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define DEXECUTE_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); +#endif + +#define DEXECUTE_POST_LOW_LEVEL_TRACER \ + CACHE_Y_AS_ENV(YREG); \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; + +#ifdef DEPTH_LIMIT +#define DEXECUTE_DEPTH_MINOR \ + FAILED = 0; \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + YAAM_FAIL; \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define DEXECUTE_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define DEXECUTE_DEPTH_END \ + FAILED = 0; +#endif + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define DEXECUTE_END_END \ + BLOCK = (CELL)DEXECUTE_END_END; \ + if (!FAILED) { \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define DEXECUTE_END_END \ + BLOCK = (CELL)DEXECUTE_END_END; \ + if (!FAILED) { \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define DEXECUTE_END_END \ + BLOCK = (CELL)DEXECUTE_END_END; \ + if (!FAILED) { \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ + +#ifdef DEPTH_LIMIT +#define FCALL_INST \ + CACHE_Y_AS_ENV(YREG); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; \ + ENV_YREG[E_DEPTH] = DEPTH; \ + ENDCACHE_Y_AS_ENV(); +#else /* DEPTH_LIMIT */ +#define FCALL_INST \ + CACHE_Y_AS_ENV(YREG); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; \ + ENDCACHE_Y_AS_ENV(); +#endif /* DEPTH_LIMIT */ + +#define CALL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + if (Yap_op_from_opcode((*_PREG)->opc) == _fcall) { \ + FCALL_INST; \ + } + +#ifdef LOW_LEVEL_TRACER +#define CALL_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); +#endif + +#define CALL_POST_LOW_LEVEL_TRACER \ + register CELL *ENV_YREG = (YREG); \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); + +#define CALL_POST_NO_CHECKING \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + +#ifdef DEPTH_LIMIT +#define CALL_DEPTH_MINOR \ + FAILED = 0; \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + YAAM_FAIL; \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define CALL_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define CALL_DEPTH_END \ + FAILED = 0; +#endif + +#ifdef YAPOR +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + ALWAYS_GONext(); \ + } +#else /* YAPOR_SBA */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + ALWAYS_GONext(); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + ALWAYS_GONext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } +#else /* YAPOR_SBA */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ + +#define PROCCEED_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = (*_CPREG); \ + save_pc(); \ + ENV_YREG = ENV; + +#ifdef DEPTH_LIMIT +#define PROCCEED_DEPTH \ + DEPTH = ENV_YREG[E_DEPTH]; +#endif + +#define PROCCEED_END \ + BLOCK = (CELL)PROCCEED_END; \ + WRITEBACK_Y_AS_ENV(); \ + ENDCACHE_Y_AS_ENV(); \ + ALWAYS_GONext(); + +#define ALLOCATE_INSTINIT \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; + +#ifdef DEPTH_LIMIT +#define ALLOCATE_DEPTH \ + ENV_YREG[E_DEPTH] = DEPTH; +#endif + +#define ALLOCATE_END \ + ENV = ENV_YREG; \ + ENDCACHE_Y_AS_ENV(); \ + GONext(); + +#define DEALLOCATE_INSTINIT + +#define DEALLOCATE_POST_CHECK \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; + +#ifdef DEPTH_LIMIT +#define DEALLOCATE_DEPTH \ + DEPTH = ENV_YREG[E_DEPTH]; +#endif + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define DEALLOCATE_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size(CPREG)); +#else /* YAPOR_SBA */ +#define DEALLOCATE_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size(CPREG)); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define DEALLOCATE_FROZEN \ + if (ENV_YREG > (CELL *) B) \ + ENV_YREG = (CELL *) B; \ + else \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size(CPREG)); +#endif /* FROZEN_STACKS */ + +#define DEALLOCATE_POST_FROZEN \ + WRITEBACK_Y_AS_ENV(); + +#define DEALLOCATE_END \ + ENDCACHE_Y_AS_ENV(); \ + GONext(); + diff --git a/JIT/HPP/yaam_call_count.h b/JIT/HPP/yaam_call_count.h new file mode 100644 index 000000000..788cd8735 --- /dev/null +++ b/JIT/HPP/yaam_call_count.h @@ -0,0 +1,1251 @@ +#define COUNT_CALL_INSTINIT \ + LOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG)->u.p.p->StatisticsForPred.NOfEntries++; \ + UNLOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + LOCAL_ReductionsCounter--; + +#define COUNT_CALL_MIDDLE \ + if (LOCAL_ReductionsCounter == 0 && LOCAL_ReductionsCounterOn) { \ + saveregs(); \ + Yap_NilError(CALL_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + else { \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + } + +#define COUNT_CALL_END \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); + +#define COUNT_RETRY_INSTINIT \ + LOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG)->u.p.p->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + LOCAL_RetriesCounter--; + +#define COUNT_RETRY_MIDDLE \ + if (LOCAL_RetriesCounter == 0 && LOCAL_RetriesCounterOn) { \ + ENV = B->cp_env; \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + else { \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { \ + ENV = B->cp_env; \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + } + +#define COUNT_RETRY_END \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); + +#define COUNT_RETRY_ME_INSTINIT \ + CACHE_Y(B); \ + restore_yaam_regs((*_PREG)->u.Otapl.d); \ + restore_args((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define COUNT_RETRY_ME_MIDDLE \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + ((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.NOfRetries++; \ + UNLOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0 && LOCAL_RetriesCounterOn) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_RETRY_ME_MIDDLE \ + set_cut(S_YREG, B_YREG->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + ((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.NOfRetries++; \ + UNLOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0 && LOCAL_RetriesCounterOn) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ + +#define COUNT_RETRY_ME_END \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#define COUNT_TRUST_ME_INSTINIT \ + CACHE_Y(B); + +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define COUNT_TRUST_ME_MIDDLE \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_ME_MIDDLE \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define COUNT_TRUST_ME_MIDDLE \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_ME_MIDDLE \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ + +#define COUNT_TRUST_ME_END \ + LOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + ((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.NOfRetries++; \ + UNLOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#ifdef THREADS +#ifdef FROZEN_STACKS +#define COUNT_RETRY_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + YAAM_CHECK_TRAIL_TR; \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + PP = (*_PREG)->u.OtaLl.d->ClPred; \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); +#else /* FROZEN_STACKS */ +#define COUNT_RETRY_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + YAAM_CHECK_TRAIL_TR; \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + PP = (*_PREG)->u.OtaLl.d->ClPred; \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; \ + set_cut(S_YREG, B_YREG->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); +#endif /* FROZEN_STACKS */ +#else /* THREADS */ +#ifdef FROZEN_STACKS +#define COUNT_RETRY_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + YAAM_CHECK_TRAIL_TR; \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); +#else /* FROZEN_STACKS */ +#define COUNT_RETRY_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + YAAM_CHECK_TRAIL_TR; \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; \ + set_cut(S_YREG, B_YREG->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); +#endif /* FROZEN_STACKS */ +#endif /* THREADS */ + +#define COUNT_RETRY_LOGICAL_END \ + BLOCK = (CELL)COUNT_RETRY_LOGICAL_END; + +#if MULTIPLE_STACKS +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(2, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + --B->cp_tr; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(2, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + --B->cp_tr; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(2, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + --B->cp_tr; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(2, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + --B->cp_tr; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#else /* MULTIPLE_STACKS */ +#if FROZEN_STACKS +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#endif /* MULTIPLE_STACKS */ + +#define COUNT_TRUST_LOGICAL_END \ + BLOCK = (CELL)COUNT_TRUST_LOGICAL_END; + diff --git a/JIT/HPP/yaam_call_count_d.h b/JIT/HPP/yaam_call_count_d.h new file mode 100644 index 000000000..3f672e6aa --- /dev/null +++ b/JIT/HPP/yaam_call_count_d.h @@ -0,0 +1,1271 @@ +#define COUNT_CALL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + LOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG)->u.p.p->StatisticsForPred.NOfEntries++; \ + UNLOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + LOCAL_ReductionsCounter--; + +#define COUNT_CALL_MIDDLE \ + if (LOCAL_ReductionsCounter == 0 && LOCAL_ReductionsCounterOn) { \ + saveregs(); \ + Yap_NilError(CALL_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + else { \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + } + +#define COUNT_CALL_END \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); + +#define COUNT_RETRY_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + LOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + (*_PREG)->u.p.p->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.p.p->StatisticsForPred.lock); \ + LOCAL_RetriesCounter--; + +#define COUNT_RETRY_MIDDLE \ + if (LOCAL_RetriesCounter == 0 && LOCAL_RetriesCounterOn) { \ + ENV = B->cp_env; \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + else { \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { \ + ENV = B->cp_env; \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + } + +#define COUNT_RETRY_END \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); + +#define COUNT_RETRY_ME_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_Y(B); \ + restore_yaam_regs((*_PREG)->u.Otapl.d); \ + restore_args((*_PREG)->u.Otapl.s); + +#ifdef FROZEN_STACKS +#define COUNT_RETRY_ME_MIDDLE \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + ((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.NOfRetries++; \ + UNLOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0 && LOCAL_RetriesCounterOn) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_RETRY_ME_MIDDLE \ + set_cut(S_YREG, B_YREG->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + ((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.NOfRetries++; \ + UNLOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0 && LOCAL_RetriesCounterOn) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0 && LOCAL_PredEntriesCounterOn) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ + +#define COUNT_RETRY_ME_END \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#define COUNT_TRUST_ME_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_Y(B); + +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define COUNT_TRUST_ME_MIDDLE \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_ME_MIDDLE \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B->cp_b); \ + } \ + else \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define COUNT_TRUST_ME_MIDDLE \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_ME_MIDDLE \ + { \ + pop_yaam_regs(); \ + pop_args((*_PREG)->u.Otapl.s); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ + +#define COUNT_TRUST_ME_END \ + LOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + ((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.NOfRetries++; \ + UNLOCK(((PredEntry *)((*_PREG)->u.Otapl.p))->StatisticsForPred.lock); \ + (*_PREG) = NEXTOP((*_PREG), Otapl); \ + GONext(); + +#ifdef THREADS +#ifdef FROZEN_STACKS +#define COUNT_RETRY_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + YAAM_CHECK_TRAIL_TR; \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + PP = (*_PREG)->u.OtaLl.d->ClPred; \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); +#else /* FROZEN_STACKS */ +#define COUNT_RETRY_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + YAAM_CHECK_TRAIL_TR; \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + PP = (*_PREG)->u.OtaLl.d->ClPred; \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; \ + set_cut(S_YREG, B_YREG->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); +#endif /* FROZEN_STACKS */ +#else /* THREADS */ +#ifdef FROZEN_STACKS +#define COUNT_RETRY_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + YAAM_CHECK_TRAIL_TR; \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); +#else /* FROZEN_STACKS */ +#define COUNT_RETRY_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + YAAM_CHECK_TRAIL_TR; \ + { \ + UInt timestamp; \ + CACHE_Y(B); \ + timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[(*_PREG)->u.OtaLl.s]); \ + if (!VALID_TIMESTAMP(timestamp, (*_PREG)->u.OtaLl.d)) { \ + (*_PREG)=(*_PREG)->u.OtaLl.n; \ + JMPNext(); \ + } \ + restore_yaam_regs((*_PREG)->u.OtaLl.n); \ + restore_args((*_PREG)->u.OtaLl.s); \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.NOfRetries++; \ + UNLOCK((*_PREG)->u.OtaLl.d->ClPred->StatisticsForPred.lock); \ + (*_PREG) = (*_PREG)->u.OtaLl.d->ClCode; \ + set_cut(S_YREG, B_YREG->cp_b); \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + } \ + JMPNext(); +#endif /* FROZEN_STACKS */ +#endif /* THREADS */ + +#define COUNT_RETRY_LOGICAL_END \ + BLOCK = (CELL)COUNT_RETRY_LOGICAL_END; + +#if MULTIPLE_STACKS +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(2, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + --B->cp_tr; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(2, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + --B->cp_tr; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(2, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + --B->cp_tr; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + PELOCK(2, ap); \ + PP = ap; \ + DEC_CLREF_COUNT(cl); \ + --B->cp_tr; \ + TR = B->cp_tr; \ + if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1) { \ + INC_CLREF_COUNT(lcl); \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#else /* MULTIPLE_STACKS */ +#if FROZEN_STACKS +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + if (B->cp_tr > TR_FZ) \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#else /* FROZEN_STACKS */ +#ifdef YAPOR +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + if (SCH_top_shared_cp(B)) { \ + SCH_last_alternative((*_PREG), B_YREG); \ + restore_args(ap->ArityOfPE); \ + S_YREG++; \ + set_cut(S_YREG, B->cp_b); \ + } else \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG); \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#else /* FROZEN_STACKS */ +#define COUNT_TRUST_LOGICAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y(B); \ + { \ + LogUpdIndex *cl = (*_PREG)->u.OtILl.block; \ + PredEntry *ap = cl->ClPred; \ + LogUpdClause *lcl = (*_PREG)->u.OtILl.d; \ + UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]); \ + if (!VALID_TIMESTAMP(timestamp, lcl)) { \ + (*_PREG) = FAILCODE; \ + } else { \ + LOCAL_RetriesCounter--; \ + if (LOCAL_RetriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(RETRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCAL_PredEntriesCounter--; \ + if (LOCAL_PredEntriesCounter == 0) { \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); \ + } \ + LOCK(ap->StatisticsForPred.lock); \ + ap->StatisticsForPred.NOfRetries++; \ + UNLOCK(ap->StatisticsForPred.lock); \ + (*_PREG) = lcl->ClCode; \ + } \ + if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) && \ + B->cp_tr != B->cp_b->cp_tr) { \ + cl->ClFlags &= ~InUseMask; \ + --B->cp_tr; \ + { \ + TR = B->cp_tr; \ + } if (cl->ClFlags & (ErasedMask|DirtyMask)) { \ + if ((*_PREG) != FAILCODE) { \ + if (lcl->ClRefCount == 1 && !(lcl->ClFlags & InUseMask)) { \ + lcl->ClFlags |= InUseMask; \ + TRAIL_CLREF(lcl); \ + } \ + } \ + if (cl->ClFlags & ErasedMask) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + save_pc(); \ + } \ + } \ + { \ + pop_yaam_regs(); \ + pop_args(ap->ArityOfPE); \ + S_YREG--; \ + set_cut(S_YREG, B); \ + } \ + SET_BB(B_YREG); \ + ENDCACHE_Y(); \ + JMPNext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ +#endif /* FROZEN_STACKS */ +#endif /* MULTIPLE_STACKS */ + +#define COUNT_TRUST_LOGICAL_END \ + BLOCK = (CELL)COUNT_TRUST_LOGICAL_END; + diff --git a/JIT/HPP/yaam_call_d.h b/JIT/HPP/yaam_call_d.h new file mode 100644 index 000000000..b81595cb6 --- /dev/null +++ b/JIT/HPP/yaam_call_d.h @@ -0,0 +1,379 @@ +#define EXECUTE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + PredEntry *pt0; \ + register CELL *ENV_YREG = (YREG); \ + pt0 = (*_PREG)->u.pp.p; + +#ifdef LOW_LEVEL_TRACER +#define EXECUTE_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,pt0,XREGS+1); +#endif + +#define EXECUTE_POST_LOW_LEVEL_TRACER \ + CACHE_A1(); \ + ALWAYS_LOOKAHEAD(pt0->OpcodeOfPred); \ + d0 = (CELL)B; + +#define EXECUTE_POST_NOCHECKING \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; + +#ifdef DEPTH_LIMIT +#define EXECUTE_DEPTH_MINOR \ + FAILED = 0; \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + YAAM_FAIL; \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define EXECUTE_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define EXECUTE_DEPTH_END \ + FAILED = 0; +#endif + +#define EXECUTE_END_END \ + BLOCK = (CELL)EXECUTE_END_END; \ + if (!FAILED) { \ + ALWAYS_GONext(); \ + } \ + +#define DEXECUTE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define DEXECUTE_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); +#endif + +#define DEXECUTE_POST_LOW_LEVEL_TRACER \ + CACHE_Y_AS_ENV(YREG); \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.pp.p; + +#ifdef DEPTH_LIMIT +#define DEXECUTE_DEPTH_MINOR \ + FAILED = 0; \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + YAAM_FAIL; \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define DEXECUTE_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define DEXECUTE_DEPTH_END \ + FAILED = 0; +#endif + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define DEXECUTE_END_END \ + BLOCK = (CELL)DEXECUTE_END_END; \ + if (!FAILED) { \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* YAPOR_SBA */ +#define DEXECUTE_END_END \ + BLOCK = (CELL)DEXECUTE_END_END; \ + if (!FAILED) { \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define DEXECUTE_END_END \ + BLOCK = (CELL)DEXECUTE_END_END; \ + if (!FAILED) { \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + else { \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* FROZEN_STACKS */ + +#ifdef DEPTH_LIMIT +#define FCALL_INST \ + CACHE_Y_AS_ENV(YREG); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; \ + ENV_YREG[E_DEPTH] = DEPTH; \ + ENDCACHE_Y_AS_ENV(); +#else /* DEPTH_LIMIT */ +#define FCALL_INST \ + CACHE_Y_AS_ENV(YREG); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; \ + ENDCACHE_Y_AS_ENV(); +#endif /* DEPTH_LIMIT */ + +#define CALL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + if (Yap_op_from_opcode((*_PREG)->opc) == _fcall) { \ + FCALL_INST; \ + } + +#ifdef LOW_LEVEL_TRACER +#define CALL_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); +#endif + +#define CALL_POST_LOW_LEVEL_TRACER \ + register CELL *ENV_YREG = (YREG); \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); + +#define CALL_POST_NO_CHECKING \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); \ + +#ifdef DEPTH_LIMIT +#define CALL_DEPTH_MINOR \ + FAILED = 0; \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)){ \ + YAAM_FAIL; \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define CALL_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define CALL_DEPTH_END \ + FAILED = 0; +#endif + +#ifdef YAPOR +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + ALWAYS_GONext(); \ + } +#else /* YAPOR_SBA */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + ALWAYS_GONext(); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + SCH_check_requests(); \ + ALWAYS_GONext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* YAPOR */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } +#else /* YAPOR_SBA */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) { \ + ENV_YREG = (CELL *) top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + if (ENV_YREG > (CELL *) B) { \ + ENV_YREG = (CELL *) B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL) B; \ + ALWAYS_GONext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* YAPOR */ + +#define PROCCEED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = (*_CPREG); \ + save_pc(); \ + ENV_YREG = ENV; + +#ifdef DEPTH_LIMIT +#define PROCCEED_DEPTH \ + DEPTH = ENV_YREG[E_DEPTH]; +#endif + +#define PROCCEED_END \ + BLOCK = (CELL)PROCCEED_END; \ + WRITEBACK_Y_AS_ENV(); \ + ENDCACHE_Y_AS_ENV(); \ + ALWAYS_GONext(); + +#define ALLOCATE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + ENV_YREG[E_CP] = (CELL) (*_CPREG); \ + ENV_YREG[E_E] = (CELL) ENV; + +#ifdef DEPTH_LIMIT +#define ALLOCATE_DEPTH \ + ENV_YREG[E_DEPTH] = DEPTH; +#endif + +#define ALLOCATE_END \ + ENV = ENV_YREG; \ + ENDCACHE_Y_AS_ENV(); \ + GONext(); + +#define DEALLOCATE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#define DEALLOCATE_POST_CHECK \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; + +#ifdef DEPTH_LIMIT +#define DEALLOCATE_DEPTH \ + DEPTH = ENV_YREG[E_DEPTH]; +#endif + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define DEALLOCATE_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size(CPREG)); +#else /* YAPOR_SBA */ +#define DEALLOCATE_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *) top_b) \ + ENV_YREG = (CELL *) top_b; \ + else \ + ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size(CPREG)); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define DEALLOCATE_FROZEN \ + if (ENV_YREG > (CELL *) B) \ + ENV_YREG = (CELL *) B; \ + else \ + ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size(CPREG)); +#endif /* FROZEN_STACKS */ + +#define DEALLOCATE_POST_FROZEN \ + WRITEBACK_Y_AS_ENV(); + +#define DEALLOCATE_END \ + ENDCACHE_Y_AS_ENV(); \ + GONext(); + diff --git a/JIT/HPP/yaam_cpred.h b/JIT/HPP/yaam_cpred.h new file mode 100644 index 000000000..5f80dbb57 --- /dev/null +++ b/JIT/HPP/yaam_cpred.h @@ -0,0 +1,323 @@ +#define CALL_CPRED_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define CALL_CPRED_TEST_STACK \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { return external_labels[6]; } \ + ENDCACHE_Y_AS_ENV(); \ + } +#else +#define CALL_CPRED_TEST_STACK \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { return external_labels[6]; } \ + ENDCACHE_Y_AS_ENV(); \ + } +#endif + +#ifdef FROZEN_STACKS +#define CALL_CPRED_FROZEN_INIT \ + choiceptr top_b = PROTECT_FROZEN_B(B); + +#ifdef YAPOR_SBA +#define CALL_CPRED_TOPB \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); +#else /* YAPOR_SBA */ +#define CALL_CPRED_TOPB \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); +#endif /* YAPOR_SBA */ + +#else +#define CALL_CPRED_NOFROZEN \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); +#endif + +#ifdef LOW_LEVEL_TRACER +#define CALL_CPRED_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); +#endif + +#define CALL_CPRED_POST_LOW_LEVEL_TRACER \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); + +#ifdef SHADOW_S +#define CALL_CPRED_SETSREG \ + (*_SREG) = Yap_REGS.S_; +#endif + +#define CALL_CPRED_END \ + BLOCK = (CELL)CALL_CPRED_END; \ + FAILED = 0; \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + CACHE_A1(); \ + JMPNext(); \ + } + +#define EXECUTE_CPRED_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#define EXECUTE_CPRED_POST_CHECK_TRAIL \ + PredEntry *pt0; \ + CELL d0; \ + CACHE_Y_AS_ENV(YREG); + +#ifdef FROZEN_STACKS +#define EXECUTE_CPRED_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); + +#ifdef YAPOR_SBA +#define EXECUTE_CPRED_TOPB \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } +#else +#define EXECUTE_CPRED_TOPB \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } +#endif + +#else +#define EXECUTE_CPRED_NOFROZEN \ + SET_ASP(YREG, E_CB*sizeof(CELL)); +#endif + +#define EXECUTE_CPRED_POST_FROZEN \ + pt0 = (*_PREG)->u.pp.p; + +#ifdef LOW_LEVEL_TRACER +#define EXECUTE_CPRED_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,pt0,XREGS+1); +#endif + +#define EXECUTE_CPRED_POST_LOW_LEVEL_TRACER \ + CACHE_A1(); \ + register CELL d0; \ + d0 = (CELL)B; + +#define EXECUTE_CPRED_SAVE_PC \ + save_pc(); \ + ENV_YREG[E_CB] = d0; + +#ifdef DEPTH_LIMIT +#define EXECUTE_CPRED_DEPTH_MINOR \ + FAILED = 0; \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + YAAM_FAIL; \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define EXECUTE_CPRED_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define EXECUTE_CPRED_DEPTH_END \ + FAILED = 0; +#endif + +#ifdef SHADOW_S +#ifdef DEPTH_LIMIT +#define EXECUTE_CPRED_END \ + BLOCK = (CELL)EXECUTE_CPRED_END; \ + if (!FAILED) { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + JMPNext(); \ + } \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* DEPTH_LIMIT */ +#define EXECUTE_CPRED_END \ + BLOCK = (CELL)EXECUTE_CPRED_END; \ + if (!FAILED) { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + JMPNext(); \ + } \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* DEPTH_LIMIT */ +#else /* SHADOW_S */ +#ifdef DEPTH_LIMIT +#define EXECUTE_CPRED_END \ + BLOCK = (CELL)EXECUTE_CPRED_END; \ + if (!FAILED) { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + JMPNext(); \ + } \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* DEPTH_LIMIT */ +#define EXECUTE_CPRED_END \ + BLOCK = (CELL)EXECUTE_CPRED_END; \ + if (!FAILED) { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + JMPNext(); \ + } \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* DEPTH_LIMIT */ +#endif /* SHADOW_S */ + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define CALL_USERCPRED_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { return external_labels[6]; } \ + ENDCACHE_Y_AS_ENV(); +#else +#define CALL_USERCPRED_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { return external_labels[6]; } \ + ENDCACHE_Y_AS_ENV(); +#endif + +#ifdef LOW_LEVEL_TRACER +#define CALL_USERCPRED_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); +#endif + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define CALL_USERCPRED_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *) top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); +#else /* YAPOR_SBA */ +#define CALL_USERCPRED_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *) top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define CALL_USERCPRED_FROZEN \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); +#endif /* FROZEN_STACKS */ + +#define CALL_USERCPRED_POST_FROZEN \ + yamop *savedP; \ + Yap_StartSlots( PASS_REGS1 ); \ + LOCAL_PrologMode = UserCCallMode; \ + { \ + PredEntry *p = (*_PREG)->u.Osbpp.p; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + savedP = (*_PREG); \ + saveregs(); \ + save_machine_regs(); \ + (*_SREG) = (CELL *) YAP_Execute(p, p->cs.f_code); \ + } \ + Yap_CloseSlots( PASS_REGS1 ); \ + setregs(); \ + LOCAL_PrologMode = UserMode; \ + restore_machine_regs(); \ + (*_PREG) = savedP; + +#define CALL_USERCPRED_END \ + BLOCK = (CELL)CALL_USERCPRED_END; \ + FAILED = 0; \ + if (EX) { \ + struct DB_TERM *exp = EX; \ + EX = NULL; \ + Yap_JumpToEnv(Yap_PopTermFromDB(exp)); \ + } \ + if (!(*_SREG)) { \ + YAAM_FAIL; \ + } \ + else { \ + YENV = ENV; \ + YREG = ENV; \ + JMPNext(); \ + } diff --git a/JIT/HPP/yaam_cpred_d.h b/JIT/HPP/yaam_cpred_d.h new file mode 100644 index 000000000..88281d8c2 --- /dev/null +++ b/JIT/HPP/yaam_cpred_d.h @@ -0,0 +1,327 @@ +#define CALL_CPRED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define CALL_CPRED_TEST_STACK \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { return external_labels[6]; } \ + ENDCACHE_Y_AS_ENV(); \ + } +#else +#define CALL_CPRED_TEST_STACK \ + if (!((*_PREG)->u.Osbpp.p->PredFlags & (SafePredFlag|HiddenPredFlag))) { \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { return external_labels[6]; } \ + ENDCACHE_Y_AS_ENV(); \ + } +#endif + +#ifdef FROZEN_STACKS +#define CALL_CPRED_FROZEN_INIT \ + choiceptr top_b = PROTECT_FROZEN_B(B); + +#ifdef YAPOR_SBA +#define CALL_CPRED_TOPB \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); +#else /* YAPOR_SBA */ +#define CALL_CPRED_TOPB \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *)top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); +#endif /* YAPOR_SBA */ + +#else +#define CALL_CPRED_NOFROZEN \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); +#endif + +#ifdef LOW_LEVEL_TRACER +#define CALL_CPRED_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); +#endif + +#define CALL_CPRED_POST_LOW_LEVEL_TRACER \ + CPredicate f = (*_PREG)->u.Osbpp.p->cs.f_code; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); + +#ifdef SHADOW_S +#define CALL_CPRED_SETSREG \ + (*_SREG) = Yap_REGS.S_; +#endif + +#define CALL_CPRED_END \ + BLOCK = (CELL)CALL_CPRED_END; \ + FAILED = 0; \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + CACHE_A1(); \ + JMPNext(); \ + } + +#define EXECUTE_CPRED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#define EXECUTE_CPRED_POST_CHECK_TRAIL \ + PredEntry *pt0; \ + CELL d0; \ + CACHE_Y_AS_ENV(YREG); + +#ifdef FROZEN_STACKS +#define EXECUTE_CPRED_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); + +#ifdef YAPOR_SBA +#define EXECUTE_CPRED_TOPB \ + if (YREG > (CELL *) top_b || YREG < HR) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } +#else +#define EXECUTE_CPRED_TOPB \ + if (YREG > (CELL *) top_b) { \ + ASP = (CELL *)top_b; \ + } \ + else { \ + ASP = YREG+E_CB; \ + } +#endif + +#else +#define EXECUTE_CPRED_NOFROZEN \ + SET_ASP(YREG, E_CB*sizeof(CELL)); +#endif + +#define EXECUTE_CPRED_POST_FROZEN \ + pt0 = (*_PREG)->u.pp.p; + +#ifdef LOW_LEVEL_TRACER +#define EXECUTE_CPRED_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,pt0,XREGS+1); +#endif + +#define EXECUTE_CPRED_POST_LOW_LEVEL_TRACER \ + CACHE_A1(); \ + register CELL d0; \ + d0 = (CELL)B; + +#define EXECUTE_CPRED_SAVE_PC \ + save_pc(); \ + ENV_YREG[E_CB] = d0; + +#ifdef DEPTH_LIMIT +#define EXECUTE_CPRED_DEPTH_MINOR \ + FAILED = 0; \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + YAAM_FAIL; \ + } \ + else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define EXECUTE_CPRED_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define EXECUTE_CPRED_DEPTH_END \ + FAILED = 0; +#endif + +#ifdef SHADOW_S +#ifdef DEPTH_LIMIT +#define EXECUTE_CPRED_END \ + BLOCK = (CELL)EXECUTE_CPRED_END; \ + if (!FAILED) { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + JMPNext(); \ + } \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* DEPTH_LIMIT */ +#define EXECUTE_CPRED_END \ + BLOCK = (CELL)EXECUTE_CPRED_END; \ + if (!FAILED) { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + (*_SREG) = Yap_REGS.S_; \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + JMPNext(); \ + } \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* DEPTH_LIMIT */ +#else /* SHADOW_S */ +#ifdef DEPTH_LIMIT +#define EXECUTE_CPRED_END \ + BLOCK = (CELL)EXECUTE_CPRED_END; \ + if (!FAILED) { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + DEPTH = ENV_YREG[E_DEPTH]; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + JMPNext(); \ + } \ + } \ + ENDCACHE_Y_AS_ENV(); +#else /* DEPTH_LIMIT */ +#define EXECUTE_CPRED_END \ + BLOCK = (CELL)EXECUTE_CPRED_END; \ + if (!FAILED) { \ + CPredicate f = (*_PREG)->u.pp.p->cs.f_code; \ + yamop *oldPREG = (*_PREG); \ + saveregs(); \ + d0 = (f)(PASS_REGS1); \ + setregs(); \ + if (!d0) { \ + YAAM_FAIL; \ + } \ + else { \ + if (oldPREG == (*_PREG)) { \ + (*_PREG) = (*_CPREG); \ + ENV_YREG = ENV; \ + WRITEBACK_Y_AS_ENV(); \ + } else { \ + CACHE_A1(); \ + } \ + JMPNext(); \ + } \ + } \ + ENDCACHE_Y_AS_ENV(); +#endif /* DEPTH_LIMIT */ +#endif /* SHADOW_S */ + +#if (defined(YAPOR_SBA) && defined(YAPOR)) || defined(TABLING) +#define CALL_USERCPRED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect( ((Int)(Unsigned(YOUNGEST_CP((choiceptr)ENV_YREG,B_FZ)) - Unsigned(YOUNGEST_H(H_FZ,H))) < CreepFlag), 0) ) { return external_labels[6]; } \ + ENDCACHE_Y_AS_ENV(); +#else +#define CALL_USERCPRED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y_AS_ENV(YREG); \ + if (__builtin_expect(((Int)(Unsigned(ENV_YREG) - Unsigned(HR)) < CreepFlag ), 0) ) { return external_labels[6]; } \ + ENDCACHE_Y_AS_ENV(); +#endif + +#ifdef LOW_LEVEL_TRACER +#define CALL_USERCPRED_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); +#endif + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define CALL_USERCPRED_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b || YREG < HR) \ + ASP = (CELL *) top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); +#else /* YAPOR_SBA */ +#define CALL_USERCPRED_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (YREG > (CELL *) top_b) \ + ASP = (CELL *) top_b; \ + else \ + ASP = (CELL *)(((char *)YREG) + (*_PREG)->u.Osbpp.s); +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define CALL_USERCPRED_FROZEN \ + SET_ASP(YREG, (*_PREG)->u.Osbpp.s); +#endif /* FROZEN_STACKS */ + +#define CALL_USERCPRED_POST_FROZEN \ + yamop *savedP; \ + Yap_StartSlots( PASS_REGS1 ); \ + LOCAL_PrologMode = UserCCallMode; \ + { \ + PredEntry *p = (*_PREG)->u.Osbpp.p; \ + (*_PREG) = NEXTOP((*_PREG), Osbpp); \ + savedP = (*_PREG); \ + saveregs(); \ + save_machine_regs(); \ + (*_SREG) = (CELL *) YAP_Execute(p, p->cs.f_code); \ + } \ + Yap_CloseSlots( PASS_REGS1 ); \ + setregs(); \ + LOCAL_PrologMode = UserMode; \ + restore_machine_regs(); \ + (*_PREG) = savedP; + +#define CALL_USERCPRED_END \ + BLOCK = (CELL)CALL_USERCPRED_END; \ + FAILED = 0; \ + if (EX) { \ + struct DB_TERM *exp = EX; \ + EX = NULL; \ + Yap_JumpToEnv(Yap_PopTermFromDB(exp)); \ + } \ + if (!(*_SREG)) { \ + YAAM_FAIL; \ + } \ + else { \ + YENV = ENV; \ + YREG = ENV; \ + JMPNext(); \ + } diff --git a/JIT/HPP/yaam_cut.h b/JIT/HPP/yaam_cut.h new file mode 100644 index 000000000..bf8da05ab --- /dev/null +++ b/JIT/HPP/yaam_cut.h @@ -0,0 +1,135 @@ +#define CUT_INSTINIT + +#ifdef COROUTINING +#define CUT_COROUTINING \ + if (FALSE) { \ + NoStackCut_Exception; \ + } +#endif + +#define CUT_NOCOROUTINING \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + saveregs(); \ + prune((choiceptr)YREG[E_CB]); \ + setregs(); \ + GONext(); + +#define CUT_T_INSTINIT + +#ifdef COROUTINING +#define CUT_T_COROUTINING \ + if (FALSE) { \ + NoStackCutT_Exception; \ + } +#endif + +#define CUT_T_NOCOROUTINING \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + saveregs(); \ + prune((choiceptr)YREG[E_CB]); \ + setregs(); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + GONext(); + +#define CUT_E_INSTINIT + +#ifdef COROUTINING +#define CUT_E_COROUTINING \ + if (FALSE) { \ + NoStackCutE_Exception; \ + } +#endif + +#define CUT_E_NOCOROUTINING \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + saveregs(); \ + prune((choiceptr)(*_SREG)[E_CB]); \ + setregs(); \ + GONext(); + +#define SAVE_B_X_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.x.x; + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define SAVE_B_X_YSBA_FROZEN \ + XREG(d0) = MkIntegerTerm((Int)B); +#else +#define SAVE_B_X_NOYSBA_NOFROZEN \ + XREG(d0) = MkIntegerTerm(LCL0-(CELL *) (B)); +#endif + +#define SAVE_B_X_END \ + (*_PREG) = NEXTOP((*_PREG), x); \ + GONext(); + +#define SAVE_B_Y_INSTINIT + +#if defined(YAPOR_SBA) +#define SAVE_B_Y_YSBA \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.y.y,MkIntegerTerm((Int)B)); +#else +#define SAVE_B_Y_NOYSBA \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.y.y,MkIntegerTerm(LCL0-(CELL *)(B))); +#endif + +#define SAVE_B_Y_END \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONext(); + +#define COMMIT_B_X_INSTINIT \ + register CELL d0; \ + register CELL *pt1; + +#define COMMIT_B_X_DO_COMMIT_B_X \ + d0 = XREG((*_PREG)->u.xps.x); + +#define COMMIT_B_X_COMMIT_B_X_NVAR \ + SET_ASP(YREG, (*_PREG)->u.xps.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xps),Osbpp),l); \ + choiceptr pt0; + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define COMMIT_B_X_YSBA_FROZEN \ + pt0 = (choiceptr)IntegerOfTerm(d0); +#else +#define COMMIT_B_X_NOYSBA_NOFROZEN \ + pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0)); +#endif + +#define COMMIT_B_X_POST_YSBA_FROZEN \ + saveregs(); \ + prune(pt0); \ + setregs(); \ + GONext(); + +#define COMMIT_B_X_END + +#define COMMIT_B_Y_INSTINIT \ + register CELL d0; \ + register CELL *pt1; + +#define COMMIT_B_Y_DO_COMMIT_B_Y \ + d0 = YREG[(*_PREG)->u.yps.y]; + +#define COMMIT_B_Y_COMMIT_B_Y_NVAR \ + SET_ASP(YREG, (*_PREG)->u.yps.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yps),Osbpp),l); \ + choiceptr pt0; + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define COMMIT_B_Y_YSBA_FROZEN \ + pt0 = (choiceptr)IntegerOfTerm(d0); +#else +#define COMMIT_B_Y_NOYSBA_NOFROZEN \ + pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0)); +#endif + +#define COMMIT_B_Y_POST_YSBA_FROZEN \ + saveregs(); \ + prune(pt0); \ + setregs(); \ + GONext(); + diff --git a/JIT/HPP/yaam_cut_d.h b/JIT/HPP/yaam_cut_d.h new file mode 100644 index 000000000..c24305d30 --- /dev/null +++ b/JIT/HPP/yaam_cut_d.h @@ -0,0 +1,141 @@ +#define CUT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef COROUTINING +#define CUT_COROUTINING \ + if (FALSE) { \ + NoStackCut_Exception; \ + } +#endif + +#define CUT_NOCOROUTINING \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + saveregs(); \ + prune((choiceptr)YREG[E_CB]); \ + setregs(); \ + GONext(); + +#define CUT_T_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef COROUTINING +#define CUT_T_COROUTINING \ + if (FALSE) { \ + NoStackCutT_Exception; \ + } +#endif + +#define CUT_T_NOCOROUTINING \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + saveregs(); \ + prune((choiceptr)YREG[E_CB]); \ + setregs(); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + GONext(); + +#define CUT_E_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef COROUTINING +#define CUT_E_COROUTINING \ + if (FALSE) { \ + NoStackCutE_Exception; \ + } +#endif + +#define CUT_E_NOCOROUTINING \ + SET_ASP(YREG, (*_PREG)->u.s.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), s),Osbpp),l); \ + saveregs(); \ + prune((choiceptr)(*_SREG)[E_CB]); \ + setregs(); \ + GONext(); + +#define SAVE_B_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_PREG)->u.x.x; + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define SAVE_B_X_YSBA_FROZEN \ + XREG(d0) = MkIntegerTerm((Int)B); +#else +#define SAVE_B_X_NOYSBA_NOFROZEN \ + XREG(d0) = MkIntegerTerm(LCL0-(CELL *) (B)); +#endif + +#define SAVE_B_X_END \ + (*_PREG) = NEXTOP((*_PREG), x); \ + GONext(); + +#define SAVE_B_Y_INSTINIT + +#if defined(YAPOR_SBA) +#define SAVE_B_Y_YSBA \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.y.y,MkIntegerTerm((Int)B)); +#else +#define SAVE_B_Y_NOYSBA \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.y.y,MkIntegerTerm(LCL0-(CELL *)(B))); +#endif + +#define SAVE_B_Y_END \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONext(); + +#define COMMIT_B_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt1; + +#define COMMIT_B_X_DO_COMMIT_B_X \ + d0 = XREG((*_PREG)->u.xps.x); + +#define COMMIT_B_X_COMMIT_B_X_NVAR \ + SET_ASP(YREG, (*_PREG)->u.xps.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xps),Osbpp),l); \ + choiceptr pt0; + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define COMMIT_B_X_YSBA_FROZEN \ + pt0 = (choiceptr)IntegerOfTerm(d0); +#else +#define COMMIT_B_X_NOYSBA_NOFROZEN \ + pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0)); +#endif + +#define COMMIT_B_X_POST_YSBA_FROZEN \ + saveregs(); \ + prune(pt0); \ + setregs(); \ + GONext(); + +#define COMMIT_B_X_END + +#define COMMIT_B_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt1; + +#define COMMIT_B_Y_DO_COMMIT_B_Y \ + d0 = YREG[(*_PREG)->u.yps.y]; + +#define COMMIT_B_Y_COMMIT_B_Y_NVAR \ + SET_ASP(YREG, (*_PREG)->u.yps.s); \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yps),Osbpp),l); \ + choiceptr pt0; + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define COMMIT_B_Y_YSBA_FROZEN \ + pt0 = (choiceptr)IntegerOfTerm(d0); +#else +#define COMMIT_B_Y_NOYSBA_NOFROZEN \ + pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0)); +#endif + +#define COMMIT_B_Y_POST_YSBA_FROZEN \ + saveregs(); \ + prune(pt0); \ + setregs(); \ + GONext(); + diff --git a/JIT/HPP/yaam_failure.h b/JIT/HPP/yaam_failure.h new file mode 100644 index 000000000..bd3bc48ee --- /dev/null +++ b/JIT/HPP/yaam_failure.h @@ -0,0 +1,1379 @@ +#define TRUST_FAIL_INSTINIT + +#ifdef CUT_C +#define TRUST_FAIL_CUT_C \ + while (POP_CHOICE_POINT(B->cp_b)) \ + POP_EXECUTE(); +#endif + +#ifdef YAPOR +#define TRUST_FAIL_YAPOR \ + choiceptr cut_pt; \ + cut_pt = B->cp_b; \ + CUT_prune_to(cut_pt); \ + B = cut_pt; +#else +#define TRUST_FAIL_NOYAPOR \ + B = B->cp_b; \ + return external_labels[0]; +#endif + +#ifdef YAPOR +#define LBL_SHARED_FAIL \ + B = Get_LOCAL_top_cp(); \ + SET_BB(PROTECT_FROZEN_B(B)); +#endif + +#define OP_FAIL_INSTINIT \ + if (PP) { \ + UNLOCK(PP->PELock); \ + PP = NULL; \ + } + +#ifdef LOW_LEVEL_TRACER +#if defined(YAPOR) || defined(THREADS) +#define LBL_FAIL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + register tr_fr_ptr pt0 = TR; \ + if (PP) { \ + UNLOCK(PP->PELock); \ + PP = NULL; \ + } \ + (*_PREG) = B->cp_ap; \ + save_pc(); \ + CACHE_TR(B->cp_tr); \ + PREFETCH_OP((*_PREG)); \ + while (1) { \ + if (pt0 == S_TR) { \ + SP = SP0; \ + LBL_FAIL_LOW_LEVEL_TRACER +#else +#define LBL_FAIL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + register tr_fr_ptr pt0 = TR; \ + (*_PREG) = B->cp_ap; \ + save_pc(); \ + CACHE_TR(B->cp_tr); \ + PREFETCH_OP((*_PREG)); \ + while (1) { \ + if (pt0 == S_TR) { \ + SP = SP0; \ + LBL_FAIL_LOW_LEVEL_TRACER +#endif +#else /* LOW_LEVEL_TRACER */ +#if defined(YAPOR) || defined(THREADS) +#define LBL_FAIL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + register tr_fr_ptr pt0 = TR; \ + if (PP) { \ + UNLOCK(PP->PELock); \ + PP = NULL; \ + } \ + (*_PREG) = B->cp_ap; \ + save_pc(); \ + CACHE_TR(B->cp_tr); \ + PREFETCH_OP((*_PREG)); \ + while (1) { \ + if (pt0 == S_TR) { \ + SP = SP0; \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#else +#define LBL_FAIL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + register tr_fr_ptr pt0 = TR; \ + (*_PREG) = B->cp_ap; \ + save_pc(); \ + CACHE_TR(B->cp_tr); \ + PREFETCH_OP((*_PREG)); \ + while (1) { \ + if (pt0 == S_TR) { \ + SP = SP0; \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#endif +#endif /* LOW_LEVEL_TRACER */ + +#ifdef LOW_LEVEL_TRACER +#ifdef TABLING +#ifdef THREADS_CONSUMER_SHARING +#ifdef DETERMINISTIC_TABLING +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_(*_PREG)); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _table_load_answer: \ + { \ + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _table_try_answer: \ + case _table_retry_me: \ + case _table_trust_me: \ + case _table_retry: \ + case _table_trust: \ + case _table_completion: \ + case _table_answer_resolution_completion: \ + if (IS_DET_GEN_CP(B)) { \ + low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry, NULL); \ + } else \ + { \ + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); \ + } \ + break; \ + case _table_answer_resolution: \ + { \ + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _trie_trust_var: \ + case _trie_retry_var: \ + case _trie_trust_var_in_pair: \ + case _trie_retry_var_in_pair: \ + case _trie_trust_val: \ + case _trie_retry_val: \ + case _trie_trust_val_in_pair: \ + case _trie_retry_val_in_pair: \ + case _trie_trust_atom: \ + case _trie_retry_atom: \ + case _trie_trust_atom_in_pair: \ + case _trie_retry_atom_in_pair: \ + case _trie_trust_null: \ + case _trie_retry_null: \ + case _trie_trust_null_in_pair: \ + case _trie_retry_null_in_pair: \ + case _trie_trust_pair: \ + case _trie_retry_pair: \ + case _trie_trust_appl: \ + case _trie_retry_appl: \ + case _trie_trust_appl_in_pair: \ + case _trie_retry_appl_in_pair: \ + case _trie_trust_extension: \ + case _trie_retry_extension: \ + case _trie_trust_double: \ + case _trie_retry_double: \ + case _trie_trust_longint: \ + case _trie_retry_longint: \ + case _trie_trust_gterm: \ + case _trie_retry_gterm: \ + { \ + low_level_trace(retry_table_loader, UndefCode, NULL); \ + break; \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#else /* DETERMINISTIC_TABLING */ +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_PREG); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _table_load_answer: \ + { \ + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _table_try_answer: \ + case _table_retry_me: \ + case _table_trust_me: \ + case _table_retry: \ + case _table_trust: \ + case _table_completion: \ + case _table_answer_resolution_completion: \ + { \ + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); \ + } \ + break; \ + case _table_answer_resolution: \ + { \ + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _trie_trust_var: \ + case _trie_retry_var: \ + case _trie_trust_var_in_pair: \ + case _trie_retry_var_in_pair: \ + case _trie_trust_val: \ + case _trie_retry_val: \ + case _trie_trust_val_in_pair: \ + case _trie_retry_val_in_pair: \ + case _trie_trust_atom: \ + case _trie_retry_atom: \ + case _trie_trust_atom_in_pair: \ + case _trie_retry_atom_in_pair: \ + case _trie_trust_null: \ + case _trie_retry_null: \ + case _trie_trust_null_in_pair: \ + case _trie_retry_null_in_pair: \ + case _trie_trust_pair: \ + case _trie_retry_pair: \ + case _trie_trust_appl: \ + case _trie_retry_appl: \ + case _trie_trust_appl_in_pair: \ + case _trie_retry_appl_in_pair: \ + case _trie_trust_extension: \ + case _trie_retry_extension: \ + case _trie_trust_double: \ + case _trie_retry_double: \ + case _trie_trust_longint: \ + case _trie_retry_longint: \ + case _trie_trust_gterm: \ + case _trie_retry_gterm: \ + { \ + low_level_trace(retry_table_loader, UndefCode, NULL); \ + break; \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#endif /* DETERMINISTIC_TABLING */ +#else /* THREADS_CONSUMER_SHARING */ +#ifdef DETERMINISTIC_TABLING +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_PREG); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _table_load_answer: \ + { \ + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _table_try_answer: \ + case _table_retry_me: \ + case _table_trust_me: \ + case _table_retry: \ + case _table_trust: \ + case _table_completion: \ + if (IS_DET_GEN_CP(B)) { \ + low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry, NULL); \ + } else \ + { \ + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); \ + } \ + break; \ + case _table_answer_resolution: \ + { \ + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _trie_trust_var: \ + case _trie_retry_var: \ + case _trie_trust_var_in_pair: \ + case _trie_retry_var_in_pair: \ + case _trie_trust_val: \ + case _trie_retry_val: \ + case _trie_trust_val_in_pair: \ + case _trie_retry_val_in_pair: \ + case _trie_trust_atom: \ + case _trie_retry_atom: \ + case _trie_trust_atom_in_pair: \ + case _trie_retry_atom_in_pair: \ + case _trie_trust_null: \ + case _trie_retry_null: \ + case _trie_trust_null_in_pair: \ + case _trie_retry_null_in_pair: \ + case _trie_trust_pair: \ + case _trie_retry_pair: \ + case _trie_trust_appl: \ + case _trie_retry_appl: \ + case _trie_trust_appl_in_pair: \ + case _trie_retry_appl_in_pair: \ + case _trie_trust_extension: \ + case _trie_retry_extension: \ + case _trie_trust_double: \ + case _trie_retry_double: \ + case _trie_trust_longint: \ + case _trie_retry_longint: \ + case _trie_trust_gterm: \ + case _trie_retry_gterm: \ + { \ + low_level_trace(retry_table_loader, UndefCode, NULL); \ + break; \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#else /* DETERMINISTIC_TABLING */ +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_PREG); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _table_load_answer: \ + { \ + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _table_try_answer: \ + case _table_retry_me: \ + case _table_trust_me: \ + case _table_retry: \ + case _table_trust: \ + case _table_completion: \ + { \ + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); \ + } \ + break; \ + case _table_answer_resolution: \ + { \ + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _trie_trust_var: \ + case _trie_retry_var: \ + case _trie_trust_var_in_pair: \ + case _trie_retry_var_in_pair: \ + case _trie_trust_val: \ + case _trie_retry_val: \ + case _trie_trust_val_in_pair: \ + case _trie_retry_val_in_pair: \ + case _trie_trust_atom: \ + case _trie_retry_atom: \ + case _trie_trust_atom_in_pair: \ + case _trie_retry_atom_in_pair: \ + case _trie_trust_null: \ + case _trie_retry_null: \ + case _trie_trust_null_in_pair: \ + case _trie_retry_null_in_pair: \ + case _trie_trust_pair: \ + case _trie_retry_pair: \ + case _trie_trust_appl: \ + case _trie_retry_appl: \ + case _trie_trust_appl_in_pair: \ + case _trie_retry_appl_in_pair: \ + case _trie_trust_extension: \ + case _trie_retry_extension: \ + case _trie_trust_double: \ + case _trie_retry_double: \ + case _trie_trust_longint: \ + case _trie_retry_longint: \ + case _trie_trust_gterm: \ + case _trie_retry_gterm: \ + { \ + low_level_trace(retry_table_loader, UndefCode, NULL); \ + break; \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#endif /* DETERMINISTIC_TABLING */ +#endif /* THREADS_CONSUMER_SHARING */ +#endif /* TABLING */ +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_PREG); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _or_else: \ + case _or_last: \ + { \ + low_level_trace(retry_or, (PredEntry *)ipc, &(B->cp_a1)); \ + break; \ + } \ + case _retry2: \ + case _retry3: \ + case _retry4: \ + { \ + ipc = NEXTOP(ipc,l); \ + go_on = TRUE; \ + break; \ + } \ + case _jump: \ + { \ + ipc = ipc->u.l.l; \ + go_on = TRUE; \ + break; \ + } \ + case _retry_c: \ + case _retry_userc: \ + { \ + low_level_trace(retry_pred, ipc->u.OtapFs.p, B->cp_args); \ + break; \ + } \ + case _retry_profiled: \ + case _count_retry: \ + { \ + ipc = NEXTOP(ipc,p); \ + go_on = TRUE; \ + break; \ + } \ + case _retry_me: \ + case _trust_me: \ + case _count_retry_me: \ + case _count_trust_me: \ + case _profiled_retry_me: \ + case _profiled_trust_me: \ + case _retry_and_mark: \ + case _profiled_retry_and_mark: \ + case _retry: \ + case _trust: \ + { \ + low_level_trace(retry_pred, ipc->u.Otapl.p, B->cp_args); \ + break; \ + } \ + case _try_logical: \ + case _retry_logical: \ + case _profiled_retry_logical: \ + case _count_retry_logical: \ + case _trust_logical: \ + case _profiled_trust_logical: \ + case _count_trust_logical: \ + { \ + low_level_trace(retry_pred, ipc->u.OtILl.d->ClPred, B->cp_args); \ + break; \ + } \ + case _Nstop: \ + case _Ystop: \ + { \ + low_level_trace(retry_pred, NULL, B->cp_args); \ + break; \ + } \ + default: \ + break; \ + } \ + } \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#endif /* LOW_LEVEL_TRACER */ + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_POST_LOW_LEVEL_TRACER \ + if (pt0 < TR_FZ || pt0 > (ADDR)CurrentTrailTop+MinTrailGap) \ + { \ + TR = TR_FZ; \ + TRAIL_LINK(pt0); \ + } else \ + { \ + RESTORE_TR(); \ + } \ + GONext(); \ + break; \ + } \ + register CELL d1; \ + d1 = TrailTerm(pt0-1); \ + pt0--; \ + LBL_FAIL_VARTERM +#else /* YAPOR_SBA */ +#define LBL_FAIL_POST_LOW_LEVEL_TRACER \ + if (pt0 < TR_FZ) \ + { \ + TR = TR_FZ; \ + TRAIL_LINK(pt0); \ + } else \ + { \ + RESTORE_TR(); \ + } \ + break; \ + } \ + register CELL d1; \ + d1 = TrailTerm(pt0-1); \ + pt0--; \ + LBL_FAIL_VARTERM +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_POST_LOW_LEVEL_TRACER \ + { \ + RESTORE_TR(); \ + } \ + break; \ + } \ + register CELL d1; \ + d1 = TrailTerm(pt0-1); \ + pt0--; \ + LBL_FAIL_VARTERM +#endif /* FROZEN_STACKS */ + +#if defined(YAPOR_SBA) && defined(YAPOR) +#define LBL_FAIL_VARTERM \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_INIT +#else /* defined(YAPOR_SBA) && defined(YAPOR) */ +#define LBL_FAIL_VARTERM \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_INIT +#endif /* defined(YAPOR_SBA) && defined(YAPOR) */ + +#if defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || defined(MULTI_ASSIGNMENT_VARIABLES) +#ifdef LIMIT_TABLING +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if ( \ + (ADDR) pt1 >= HeapTop \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#else /* YAPOR_SBA */ +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if ( \ + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop+MinTrailGap) \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* FROZEN_STACKS */ +#else /* LIMIT_TABLING */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ( \ + (ADDR) pt1 >= HeapTop \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#else /* YAPOR_SBA */ +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ( \ + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop+MinTrailGap) \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* FROZEN_STACKS */ +#endif /* LIMIT_TABLING */ +#else /* defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || defined(MULTI_ASSIGNMENT_VARIABLES) */ +#ifdef LIMIT_TABLING +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if ( \ + (ADDR) pt1 >= HeapTop \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#else /* YAPOR_SBA */ +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if ( \ + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop+MinTrailGap) \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* FROZEN_STACKS */ +#else /* LIMIT_TABLING */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ( \ + (ADDR) pt1 >= HeapTop \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#else /* YAPOR_SBA */ +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ( \ + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop+MinTrailGap) \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* FROZEN_STACKS */ +#endif /* LIMIT_TABLING */ +#endif /* defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || defined(MULTI_ASSIGNMENT_VARIABLES) */ + +#if MULTIPLE_STACKS +#if PARALLEL_YAP +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + --pt0; \ + pt[0] = TrailVal(pt0); \ + pt[0] = TrailTerm(pt0-1); \ + pt0 -= 2; \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(pt0-1); \ + pt0 -= 2; \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#else /* PARALLEL_YAP */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + --pt0; \ + pt[0] = TrailVal(pt0); \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(pt0-1); \ + pt0 -= 2; \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#endif /* PARALLEL_YAP */ +#else /* MULTIPLE_STACKS */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + ResetFlag(InUseMask, flags); \ + *pt1 = flags; \ + if (FlagOn((ErasedMask|DirtyMask), flags)) { \ + if (FlagOn(DBClMask, flags)) { \ + saveregs(); \ + Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); \ + setregs(); \ + } else { \ + saveregs(); \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + if (FlagOn(ErasedMask, flags)) { \ + Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } else { \ + Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } \ + } else { \ + Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1)); \ + } \ + } else { \ + Yap_ErCl(ClauseFlagsToDynamicClause(pt1)); \ + } \ + setregs(); \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + --pt0; \ + pt[0] = TrailVal(pt0); \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + ResetFlag(InUseMask, flags); \ + *pt1 = flags; \ + if (FlagOn((ErasedMask|DirtyMask), flags)) { \ + if (FlagOn(DBClMask, flags)) { \ + saveregs(); \ + Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); \ + setregs(); \ + } else { \ + saveregs(); \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + if (FlagOn(ErasedMask, flags)) { \ + Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } else { \ + Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } \ + } else { \ + Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1)); \ + } \ + } else { \ + Yap_ErCl(ClauseFlagsToDynamicClause(pt1)); \ + } \ + setregs(); \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(pt0-1); \ + pt0 -= 2; \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + ResetFlag(InUseMask, flags); \ + *pt1 = flags; \ + if (FlagOn((ErasedMask|DirtyMask), flags)) { \ + if (FlagOn(DBClMask, flags)) { \ + saveregs(); \ + Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); \ + setregs(); \ + } else { \ + saveregs(); \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + if (FlagOn(ErasedMask, flags)) { \ + Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } else { \ + Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } \ + } else { \ + Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1)); \ + } \ + } else { \ + Yap_ErCl(ClauseFlagsToDynamicClause(pt1)); \ + } \ + setregs(); \ + } \ + } \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#endif /* MULTIPLE_STACKS */ + +#define LBL_FAIL_END \ + BLOCK = (CELL)LBL_FAIL_END; diff --git a/JIT/HPP/yaam_failure_d.h b/JIT/HPP/yaam_failure_d.h new file mode 100644 index 000000000..6aa7b9e4e --- /dev/null +++ b/JIT/HPP/yaam_failure_d.h @@ -0,0 +1,1400 @@ +#define TRUST_FAIL_INSTINIT + +#ifdef CUT_C +#define TRUST_FAIL_CUT_C \ + while (POP_CHOICE_POINT(B->cp_b)) \ + POP_EXECUTE(); +#endif + +#ifdef YAPOR +#define TRUST_FAIL_YAPOR \ + choiceptr cut_pt; \ + cut_pt = B->cp_b; \ + CUT_prune_to(cut_pt); \ + B = cut_pt; +#else +#define TRUST_FAIL_NOYAPOR \ + B = B->cp_b; \ + return external_labels[0]; +#endif + +#ifdef YAPOR +#define LBL_SHARED_FAIL \ + B = Get_LOCAL_top_cp(); \ + SET_BB(PROTECT_FROZEN_B(B)); +#endif + +#define OP_FAIL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + if (PP) { \ + UNLOCK(PP->PELock); \ + PP = NULL; \ + } + +#ifdef LOW_LEVEL_TRACER +#if defined(YAPOR) || defined(THREADS) +#define LBL_FAIL_INSTINIT \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_backtrack != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_backtrack != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_backtrack); \ + } \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + register tr_fr_ptr pt0 = TR; \ + if (PP) { \ + UNLOCK(PP->PELock); \ + PP = NULL; \ + } \ + (*_PREG) = B->cp_ap; \ + save_pc(); \ + CACHE_TR(B->cp_tr); \ + PREFETCH_OP((*_PREG)); \ + while (1) { \ + if (pt0 == S_TR) { \ + SP = SP0; \ + LBL_FAIL_LOW_LEVEL_TRACER +#else +#define LBL_FAIL_INSTINIT \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_backtrack != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_backtrack != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_backtrack); \ + } \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + register tr_fr_ptr pt0 = TR; \ + (*_PREG) = B->cp_ap; \ + save_pc(); \ + CACHE_TR(B->cp_tr); \ + PREFETCH_OP((*_PREG)); \ + while (1) { \ + if (pt0 == S_TR) { \ + SP = SP0; \ + LBL_FAIL_LOW_LEVEL_TRACER +#endif +#else /* LOW_LEVEL_TRACER */ +#if defined(YAPOR) || defined(THREADS) +#define LBL_FAIL_INSTINIT \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_backtrack != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_backtrack != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_backtrack); \ + } \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + register tr_fr_ptr pt0 = TR; \ + if (PP) { \ + UNLOCK(PP->PELock); \ + PP = NULL; \ + } \ + (*_PREG) = B->cp_ap; \ + save_pc(); \ + CACHE_TR(B->cp_tr); \ + PREFETCH_OP((*_PREG)); \ + while (1) { \ + if (pt0 == S_TR) { \ + SP = SP0; \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#else +#define LBL_FAIL_INSTINIT \ + if ((char*)ExpEnv.debug_struc.pprint_me.native_backtrack != 0 && (char*)ExpEnv.debug_struc.pprint_me.native_backtrack != (char*)0x1) { \ + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \ + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.native_backtrack); \ + } \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + register tr_fr_ptr pt0 = TR; \ + (*_PREG) = B->cp_ap; \ + save_pc(); \ + CACHE_TR(B->cp_tr); \ + PREFETCH_OP((*_PREG)); \ + while (1) { \ + if (pt0 == S_TR) { \ + SP = SP0; \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#endif +#endif /* LOW_LEVEL_TRACER */ + +#ifdef LOW_LEVEL_TRACER +#ifdef TABLING +#ifdef THREADS_CONSUMER_SHARING +#ifdef DETERMINISTIC_TABLING +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_(*_PREG)); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _table_load_answer: \ + { \ + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _table_try_answer: \ + case _table_retry_me: \ + case _table_trust_me: \ + case _table_retry: \ + case _table_trust: \ + case _table_completion: \ + case _table_answer_resolution_completion: \ + if (IS_DET_GEN_CP(B)) { \ + low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry, NULL); \ + } else \ + { \ + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); \ + } \ + break; \ + case _table_answer_resolution: \ + { \ + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _trie_trust_var: \ + case _trie_retry_var: \ + case _trie_trust_var_in_pair: \ + case _trie_retry_var_in_pair: \ + case _trie_trust_val: \ + case _trie_retry_val: \ + case _trie_trust_val_in_pair: \ + case _trie_retry_val_in_pair: \ + case _trie_trust_atom: \ + case _trie_retry_atom: \ + case _trie_trust_atom_in_pair: \ + case _trie_retry_atom_in_pair: \ + case _trie_trust_null: \ + case _trie_retry_null: \ + case _trie_trust_null_in_pair: \ + case _trie_retry_null_in_pair: \ + case _trie_trust_pair: \ + case _trie_retry_pair: \ + case _trie_trust_appl: \ + case _trie_retry_appl: \ + case _trie_trust_appl_in_pair: \ + case _trie_retry_appl_in_pair: \ + case _trie_trust_extension: \ + case _trie_retry_extension: \ + case _trie_trust_double: \ + case _trie_retry_double: \ + case _trie_trust_longint: \ + case _trie_retry_longint: \ + case _trie_trust_gterm: \ + case _trie_retry_gterm: \ + { \ + low_level_trace(retry_table_loader, UndefCode, NULL); \ + break; \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#else /* DETERMINISTIC_TABLING */ +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_PREG); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _table_load_answer: \ + { \ + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _table_try_answer: \ + case _table_retry_me: \ + case _table_trust_me: \ + case _table_retry: \ + case _table_trust: \ + case _table_completion: \ + case _table_answer_resolution_completion: \ + { \ + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); \ + } \ + break; \ + case _table_answer_resolution: \ + { \ + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _trie_trust_var: \ + case _trie_retry_var: \ + case _trie_trust_var_in_pair: \ + case _trie_retry_var_in_pair: \ + case _trie_trust_val: \ + case _trie_retry_val: \ + case _trie_trust_val_in_pair: \ + case _trie_retry_val_in_pair: \ + case _trie_trust_atom: \ + case _trie_retry_atom: \ + case _trie_trust_atom_in_pair: \ + case _trie_retry_atom_in_pair: \ + case _trie_trust_null: \ + case _trie_retry_null: \ + case _trie_trust_null_in_pair: \ + case _trie_retry_null_in_pair: \ + case _trie_trust_pair: \ + case _trie_retry_pair: \ + case _trie_trust_appl: \ + case _trie_retry_appl: \ + case _trie_trust_appl_in_pair: \ + case _trie_retry_appl_in_pair: \ + case _trie_trust_extension: \ + case _trie_retry_extension: \ + case _trie_trust_double: \ + case _trie_retry_double: \ + case _trie_trust_longint: \ + case _trie_retry_longint: \ + case _trie_trust_gterm: \ + case _trie_retry_gterm: \ + { \ + low_level_trace(retry_table_loader, UndefCode, NULL); \ + break; \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#endif /* DETERMINISTIC_TABLING */ +#else /* THREADS_CONSUMER_SHARING */ +#ifdef DETERMINISTIC_TABLING +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_PREG); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _table_load_answer: \ + { \ + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _table_try_answer: \ + case _table_retry_me: \ + case _table_trust_me: \ + case _table_retry: \ + case _table_trust: \ + case _table_completion: \ + if (IS_DET_GEN_CP(B)) { \ + low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry, NULL); \ + } else \ + { \ + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); \ + } \ + break; \ + case _table_answer_resolution: \ + { \ + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _trie_trust_var: \ + case _trie_retry_var: \ + case _trie_trust_var_in_pair: \ + case _trie_retry_var_in_pair: \ + case _trie_trust_val: \ + case _trie_retry_val: \ + case _trie_trust_val_in_pair: \ + case _trie_retry_val_in_pair: \ + case _trie_trust_atom: \ + case _trie_retry_atom: \ + case _trie_trust_atom_in_pair: \ + case _trie_retry_atom_in_pair: \ + case _trie_trust_null: \ + case _trie_retry_null: \ + case _trie_trust_null_in_pair: \ + case _trie_retry_null_in_pair: \ + case _trie_trust_pair: \ + case _trie_retry_pair: \ + case _trie_trust_appl: \ + case _trie_retry_appl: \ + case _trie_trust_appl_in_pair: \ + case _trie_retry_appl_in_pair: \ + case _trie_trust_extension: \ + case _trie_retry_extension: \ + case _trie_trust_double: \ + case _trie_retry_double: \ + case _trie_trust_longint: \ + case _trie_retry_longint: \ + case _trie_trust_gterm: \ + case _trie_retry_gterm: \ + { \ + low_level_trace(retry_table_loader, UndefCode, NULL); \ + break; \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#else /* DETERMINISTIC_TABLING */ +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_PREG); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _table_load_answer: \ + { \ + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _table_try_answer: \ + case _table_retry_me: \ + case _table_trust_me: \ + case _table_retry: \ + case _table_trust: \ + case _table_completion: \ + { \ + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); \ + } \ + break; \ + case _table_answer_resolution: \ + { \ + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); \ + break; \ + } \ + case _trie_trust_var: \ + case _trie_retry_var: \ + case _trie_trust_var_in_pair: \ + case _trie_retry_var_in_pair: \ + case _trie_trust_val: \ + case _trie_retry_val: \ + case _trie_trust_val_in_pair: \ + case _trie_retry_val_in_pair: \ + case _trie_trust_atom: \ + case _trie_retry_atom: \ + case _trie_trust_atom_in_pair: \ + case _trie_retry_atom_in_pair: \ + case _trie_trust_null: \ + case _trie_retry_null: \ + case _trie_trust_null_in_pair: \ + case _trie_retry_null_in_pair: \ + case _trie_trust_pair: \ + case _trie_retry_pair: \ + case _trie_trust_appl: \ + case _trie_retry_appl: \ + case _trie_trust_appl_in_pair: \ + case _trie_retry_appl_in_pair: \ + case _trie_trust_extension: \ + case _trie_retry_extension: \ + case _trie_trust_double: \ + case _trie_retry_double: \ + case _trie_trust_longint: \ + case _trie_retry_longint: \ + case _trie_trust_gterm: \ + case _trie_retry_gterm: \ + { \ + low_level_trace(retry_table_loader, UndefCode, NULL); \ + break; \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#endif /* DETERMINISTIC_TABLING */ +#endif /* THREADS_CONSUMER_SHARING */ +#endif /* TABLING */ +#define LBL_FAIL_LOW_LEVEL_TRACER \ + if (Yap_do_low_level_trace) { \ + int go_on = TRUE; \ + yamop *ipc = (*_PREG); \ + while (go_on) { \ + op_numbers opnum = Yap_op_from_opcode(ipc->opc); \ + go_on = FALSE; \ + switch (opnum) { \ + case _or_else: \ + case _or_last: \ + { \ + low_level_trace(retry_or, (PredEntry *)ipc, &(B->cp_a1)); \ + break; \ + } \ + case _retry2: \ + case _retry3: \ + case _retry4: \ + { \ + ipc = NEXTOP(ipc,l); \ + go_on = TRUE; \ + break; \ + } \ + case _jump: \ + { \ + ipc = ipc->u.l.l; \ + go_on = TRUE; \ + break; \ + } \ + case _retry_c: \ + case _retry_userc: \ + { \ + low_level_trace(retry_pred, ipc->u.OtapFs.p, B->cp_args); \ + break; \ + } \ + case _retry_profiled: \ + case _count_retry: \ + { \ + ipc = NEXTOP(ipc,p); \ + go_on = TRUE; \ + break; \ + } \ + case _retry_me: \ + case _trust_me: \ + case _count_retry_me: \ + case _count_trust_me: \ + case _profiled_retry_me: \ + case _profiled_trust_me: \ + case _retry_and_mark: \ + case _profiled_retry_and_mark: \ + case _retry: \ + case _trust: \ + { \ + low_level_trace(retry_pred, ipc->u.Otapl.p, B->cp_args); \ + break; \ + } \ + case _try_logical: \ + case _retry_logical: \ + case _profiled_retry_logical: \ + case _count_retry_logical: \ + case _trust_logical: \ + case _profiled_trust_logical: \ + case _count_trust_logical: \ + { \ + low_level_trace(retry_pred, ipc->u.OtILl.d->ClPred, B->cp_args); \ + break; \ + } \ + case _Nstop: \ + case _Ystop: \ + { \ + low_level_trace(retry_pred, NULL, B->cp_args); \ + break; \ + } \ + default: \ + break; \ + } \ + } \ + } \ + LBL_FAIL_POST_LOW_LEVEL_TRACER +#endif /* LOW_LEVEL_TRACER */ + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_POST_LOW_LEVEL_TRACER \ + if (pt0 < TR_FZ || pt0 > (ADDR)CurrentTrailTop+MinTrailGap) \ + { \ + TR = TR_FZ; \ + TRAIL_LINK(pt0); \ + } else \ + { \ + RESTORE_TR(); \ + } \ + GONext(); \ + break; \ + } \ + register CELL d1; \ + d1 = TrailTerm(pt0-1); \ + pt0--; \ + LBL_FAIL_VARTERM +#else /* YAPOR_SBA */ +#define LBL_FAIL_POST_LOW_LEVEL_TRACER \ + if (pt0 < TR_FZ) \ + { \ + TR = TR_FZ; \ + TRAIL_LINK(pt0); \ + } else \ + { \ + RESTORE_TR(); \ + } \ + break; \ + } \ + register CELL d1; \ + d1 = TrailTerm(pt0-1); \ + pt0--; \ + LBL_FAIL_VARTERM +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_POST_LOW_LEVEL_TRACER \ + { \ + RESTORE_TR(); \ + } \ + break; \ + } \ + register CELL d1; \ + d1 = TrailTerm(pt0-1); \ + pt0--; \ + LBL_FAIL_VARTERM +#endif /* FROZEN_STACKS */ + +#if defined(YAPOR_SBA) && defined(YAPOR) +#define LBL_FAIL_VARTERM \ + if (IsVarTerm(d1)) { \ + if (Unsigned((Int)(d1)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + RESET_VARIABLE(STACK_TO_SBA(d1)); \ + } else \ + { \ + RESET_VARIABLE(d1); \ + } \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_INIT +#else /* defined(YAPOR_SBA) && defined(YAPOR) */ +#define LBL_FAIL_VARTERM \ + if (IsVarTerm(d1)) { \ + { \ + RESET_VARIABLE(d1); \ + } \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_INIT +#endif /* defined(YAPOR_SBA) && defined(YAPOR) */ + +#if defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || defined(MULTI_ASSIGNMENT_VARIABLES) +#ifdef LIMIT_TABLING +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if ( \ + (ADDR) pt1 >= HeapTop \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#else /* YAPOR_SBA */ +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if ( \ + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop+MinTrailGap) \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* FROZEN_STACKS */ +#else /* LIMIT_TABLING */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ( \ + (ADDR) pt1 >= HeapTop \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#else /* YAPOR_SBA */ +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ( \ + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop+MinTrailGap) \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_INIT \ + if (IsPairTerm(d1)) \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* FROZEN_STACKS */ +#endif /* LIMIT_TABLING */ +#else /* defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || defined(MULTI_ASSIGNMENT_VARIABLES) */ +#ifdef LIMIT_TABLING +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if ( \ + (ADDR) pt1 >= HeapTop \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#else /* YAPOR_SBA */ +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if ( \ + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop+MinTrailGap) \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ((ADDR) pt1 == LOCAL_TrailBase) { \ + sg_fr_ptr sg_fr = (sg_fr_ptr) TrailVal(pt0); \ + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); \ + SgFr_state(sg_fr)--; \ + insert_into_global_sg_fr_list(sg_fr); \ + continue; \ + } \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* FROZEN_STACKS */ +#else /* LIMIT_TABLING */ +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ( \ + (ADDR) pt1 >= HeapTop \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#else /* YAPOR_SBA */ +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if ( \ + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop+MinTrailGap) \ + ) \ + { \ + pt0 = (tr_fr_ptr) pt1; \ + continue; \ + } else \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + if (pt0 < TR_FZ) { \ + continue; \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_INIT \ + { \ + register CELL flags; \ + CELL *pt1 = RepPair(d1); \ + if (IN_BETWEEN(H0,pt1,H)) { \ + if (IsAttVar(pt1)) { \ + continue; \ + } else if (*pt1 == (CELL)FunctorBigInt) { \ + Yap_CleanOpaqueVariable(pt1); \ + } \ + } \ + LBL_FAIL_PAIRTERM_END_APPL +#endif /* FROZEN_STACKS */ +#endif /* LIMIT_TABLING */ +#endif /* defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || defined(MULTI_ASSIGNMENT_VARIABLES) */ + +#if MULTIPLE_STACKS +#if PARALLEL_YAP +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + --pt0; \ + pt[0] = TrailVal(pt0); \ + pt[0] = TrailTerm(pt0-1); \ + pt0 -= 2; \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(pt0-1); \ + pt0 -= 2; \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PredEntry *ap = cl->ClPred; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#else /* PARALLEL_YAP */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + --pt0; \ + pt[0] = TrailVal(pt0); \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(pt0-1); \ + pt0 -= 2; \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + if (FlagOn(DBClMask, flags)) { \ + DBRef dbr = DBStructFlagsToDBStruct(pt1); \ + int erase; \ + LOCK(dbr->lock); \ + DEC_DBREF_COUNT(dbr); \ + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); \ + UNLOCK(dbr->lock); \ + if (erase) { \ + saveregs(); \ + Yap_ErDBE(dbr); \ + setregs(); \ + } \ + } else { \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); \ + int erase; \ + PELOCK(8,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdIndex(cl); \ + setregs(); \ + } else if (cl->ClFlags & DirtyMask) { \ + saveregs(); \ + Yap_CleanUpIndex(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } else { \ + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); \ + int erase; \ + PELOCK(9,ap); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + if (erase) { \ + saveregs(); \ + Yap_ErLogUpdCl(cl); \ + setregs(); \ + } \ + UNLOCK(ap->PELock); \ + } \ + } else { \ + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); \ + int erase; \ + LOCK(cl->ClLock); \ + DEC_CLREF_COUNT(cl); \ + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); \ + UNLOCK(cl->ClLock); \ + if (erase) { \ + saveregs(); \ + Yap_ErCl(cl); \ + setregs(); \ + } \ + } \ + } \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#endif /* PARALLEL_YAP */ +#else /* MULTIPLE_STACKS */ +#ifdef MULTI_ASSIGNMENT_VARIABLES +#ifdef FROZEN_STACKS +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + ResetFlag(InUseMask, flags); \ + *pt1 = flags; \ + if (FlagOn((ErasedMask|DirtyMask), flags)) { \ + if (FlagOn(DBClMask, flags)) { \ + saveregs(); \ + Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); \ + setregs(); \ + } else { \ + saveregs(); \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + if (FlagOn(ErasedMask, flags)) { \ + Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } else { \ + Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } \ + } else { \ + Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1)); \ + } \ + } else { \ + Yap_ErCl(ClauseFlagsToDynamicClause(pt1)); \ + } \ + setregs(); \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + --pt0; \ + pt[0] = TrailVal(pt0); \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#else /* FROZEN_STACKS */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + ResetFlag(InUseMask, flags); \ + *pt1 = flags; \ + if (FlagOn((ErasedMask|DirtyMask), flags)) { \ + if (FlagOn(DBClMask, flags)) { \ + saveregs(); \ + Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); \ + setregs(); \ + } else { \ + saveregs(); \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + if (FlagOn(ErasedMask, flags)) { \ + Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } else { \ + Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } \ + } else { \ + Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1)); \ + } \ + } else { \ + Yap_ErCl(ClauseFlagsToDynamicClause(pt1)); \ + } \ + setregs(); \ + } \ + } \ + continue; \ + } \ + else { \ + CELL *pt = RepAppl(d1); \ + pt[0] = TrailTerm(pt0-1); \ + pt0 -= 2; \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* FROZEN_STACKS */ +#else /* MULTI_ASSIGNMENT_VARIABLES */ +#define LBL_FAIL_PAIRTERM_END_APPL \ + flags = *pt1; \ + ResetFlag(InUseMask, flags); \ + *pt1 = flags; \ + if (FlagOn((ErasedMask|DirtyMask), flags)) { \ + if (FlagOn(DBClMask, flags)) { \ + saveregs(); \ + Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); \ + setregs(); \ + } else { \ + saveregs(); \ + if (flags & LogUpdMask) { \ + if (flags & IndexMask) { \ + if (FlagOn(ErasedMask, flags)) { \ + Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } else { \ + Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); \ + } \ + } else { \ + Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1)); \ + } \ + } else { \ + Yap_ErCl(ClauseFlagsToDynamicClause(pt1)); \ + } \ + setregs(); \ + } \ + } \ + continue; \ + } \ + ENDCACHE_TR(); \ + } \ + } +#endif /* MULTI_ASSIGNMENT_VARIABLES */ +#endif /* MULTIPLE_STACKS */ + +#define LBL_FAIL_END \ + BLOCK = (CELL)LBL_FAIL_END; diff --git a/JIT/HPP/yaam_get.h b/JIT/HPP/yaam_get.h new file mode 100644 index 000000000..b9815b209 --- /dev/null +++ b/JIT/HPP/yaam_get.h @@ -0,0 +1,838 @@ +#define GET_X_VAR_INSTINIT \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.xx.xr); \ + XREG((*_PREG)->u.xx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONext(); + +#define GET_Y_VAR_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + d0 = XREG((*_PREG)->u.yx.x); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define GET_YY_VAR_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + CACHE_Y(YREG); \ + pt0 = S_YREG + (*_PREG)->u.yyxx.y1; \ + d0 = XREG((*_PREG)->u.yyxx.x1); \ + pt1 = S_YREG + (*_PREG)->u.yyx.y2; \ + d1 = XREG((*_PREG)->u.yyxx.x2); \ + (*_PREG) = NEXTOP((*_PREG), yyxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + INITIALIZE_PERMVAR(pt1,d1); \ + ENDCACHE_Y(); \ + GONext(); + +#define GET_X_VAL_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xx.xl); + +#define GET_X_VAL_GVALX_NONVAR \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GET_X_VAL_GVALX_NONVAR_NONVAR \ + BLOCK = (CELL)GET_X_VAL_GVALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + YAAM_UNIFYBOUND; + +#define GET_X_VAL_GVALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt0, d0); \ + GONext(); + +#define GET_X_VAL_GVALX_UNK \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GET_X_VAL_GVALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_X_VAL_GVALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + UnifyCells(pt0, pt1); \ + GONext(); + +#define GET_Y_VAL_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + d0 = *pt0; + +#define GET_Y_VAL_GVALY_NONVAR \ + d1 = XREG((*_PREG)->u.yx.x); + +#define GET_Y_VAL_GVALY_NONVAR_NONVAR \ + BLOCK = (CELL)GET_Y_VAL_GVALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + YAAM_UNIFYBOUND; + +#define GET_Y_VAL_GVALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind(pt1, d0); \ + GONext(); + +#define GET_Y_VAL_GVALY_UNK \ + d1 = XREG((*_PREG)->u.yx.x); + +#define GET_Y_VAL_GVALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_Y_VAL_GVALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + UnifyCells(pt0, pt1); \ + GONext(); + +#define GET_ATOM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xc.x); \ + d1 = (*_PREG)->u.xc.c; + +#define GET_ATOM_GATOM_NONVAR \ + BLOCK = (CELL)GET_ATOM_GATOM_NONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), xc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_ATOM_GATOM_UNK \ + (*_PREG) = NEXTOP((*_PREG), xc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_2ATOMS_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_2ATOMS_GATOM_2UNK \ + Bind(pt0, (*_PREG)->u.cc.c1); + +#define GET_2ATOMS_GATOM_2B \ + d0 = ARG2; \ + d1 = (*_PREG)->u.cc.c2; + +#define GET_2ATOMS_GATOM_2BNONVAR \ + BLOCK = (CELL)GET_2ATOMS_GATOM_2BNONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), cc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_2ATOMS_GATOM_2BUNK \ + (*_PREG) = NEXTOP((*_PREG), cc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_3ATOMS_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_3ATOMS_GATOM_3UNK \ + Bind(pt0, (*_PREG)->u.ccc.c1); + +#define GET_3ATOMS_GATOM_3B \ + d0 = ARG2; + +#define GET_3ATOMS_GATOM_3BUNK \ + Bind(pt0, (*_PREG)->u.ccc.c2); + +#define GET_3ATOMS_GATOM_3C \ + d0 = ARG3; \ + d1 = (*_PREG)->u.ccc.c3; + +#define GET_3ATOMS_GATOM_3CNONVAR \ + BLOCK = (CELL)GET_3ATOMS_GATOM_3CNONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), ccc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_3ATOMS_GATOM_3CUNK \ + (*_PREG) = NEXTOP((*_PREG), ccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_4ATOMS_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_4ATOMS_GATOM_4UNK \ + Bind(pt0, (*_PREG)->u.cccc.c1); + +#define GET_4ATOMS_GATOM_4B \ + d0 = ARG2; + +#define GET_4ATOMS_GATOM_4BUNK \ + Bind(pt0, (*_PREG)->u.cccc.c2); + +#define GET_4ATOMS_GATOM_4C \ + d0 = ARG3; + +#define GET_4ATOMS_GATOM_4CUNK \ + Bind(pt0, (*_PREG)->u.cccc.c3); + +#define GET_4ATOMS_GATOM_4D \ + d0 = ARG4; \ + d1 = (*_PREG)->u.cccc.c4; + +#define GET_4ATOMS_GATOM_4DNONVAR \ + BLOCK = (CELL)GET_4ATOMS_GATOM_4DNONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), cccc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_4ATOMS_GATOM_4DUNK \ + (*_PREG) = NEXTOP((*_PREG), cccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_5ATOMS_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_5ATOMS_GATOM_5UNK \ + Bind(pt0, (*_PREG)->u.ccccc.c1); + +#define GET_5ATOMS_GATOM_5B \ + d0 = ARG2; + +#define GET_5ATOMS_GATOM_5BUNK \ + Bind(pt0, (*_PREG)->u.ccccc.c2); + +#define GET_5ATOMS_GATOM_5C \ + d0 = ARG3; + +#define GET_5ATOMS_GATOM_5CUNK \ + Bind(pt0, (*_PREG)->u.ccccc.c3); + +#define GET_5ATOMS_GATOM_5D \ + d0 = ARG4; + +#define GET_5ATOMS_GATOM_5DUNK \ + Bind(pt0, (*_PREG)->u.ccccc.c4); + +#define GET_5ATOMS_GATOM_5E \ + d0 = ARG5; \ + d1 = (*_PREG)->u.ccccc.c5; + +#define GET_5ATOMS_GATOM_5ENONVAR \ + BLOCK = (CELL)GET_5ATOMS_GATOM_5ENONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), ccccc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_5ATOMS_GATOM_5EUNK \ + (*_PREG) = NEXTOP((*_PREG), ccccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_6ATOMS_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_6ATOMS_GATOM_6UNK \ + Bind(pt0, (*_PREG)->u.cccccc.c1); + +#define GET_6ATOMS_GATOM_6B \ + d0 = ARG2; + +#define GET_6ATOMS_GATOM_6BUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c2); + +#define GET_6ATOMS_GATOM_6C \ + d0 = ARG3; + +#define GET_6ATOMS_GATOM_6CUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c3); + +#define GET_6ATOMS_GATOM_6D \ + d0 = ARG4; + +#define GET_6ATOMS_GATOM_6DUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c4); + +#define GET_6ATOMS_GATOM_6E \ + d0 = ARG5; + +#define GET_6ATOMS_GATOM_6EUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c5); + +#define GET_6ATOMS_GATOM_6F \ + d0 = ARG6; \ + d1 = (*_PREG)->u.cccccc.c6; + +#define GET_6ATOMS_GATOM_6FNONVAR \ + BLOCK = (CELL)GET_6ATOMS_GATOM_6FNONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), cccccc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_6ATOMS_GATOM_6FUNK \ + (*_PREG) = NEXTOP((*_PREG), cccccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_LIST_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.x.x); + +#define GET_LIST_GLIST_NONVAR \ + BLOCK = (CELL)GET_LIST_GLIST_NONVAR; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), x); \ + (*_SREG) = RepPair(d0); \ + GONext(); \ + } + +#define GET_LIST_GLIST_UNK \ + CACHE_S(); \ + S_SREG = HR; \ + START_PREFETCH_W(x); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + d0 = AbsPair(S_SREG); \ + Bind(pt0, d0); \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG); \ + GONextW(); \ + END_PREFETCH_W(); \ + ENDCACHE_S(); + +#define GET_STRUCT_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xfa.x); + +#define GET_STRUCT_GSTRUCT_NONVAR \ + BLOCK = (CELL)GET_STRUCT_GSTRUCT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + register CELL * S_SREG; \ + S_SREG = RepAppl(d0); \ + d0 = (CELL) ((*_PREG)->u.xfa.f); \ + if (*S_SREG != d0) { \ + YAAM_FAIL; \ + } \ + else { \ + WRITEBACK_S(S_SREG+1); \ + (*_PREG) = NEXTOP((*_PREG), xfa); \ + GONext(); \ + } \ + } + +#define GET_STRUCT_GSTRUCT_UNK \ + START_PREFETCH_W(xfa); \ + d1 = AbsAppl(HR); \ + Bind(pt0, d1); \ + pt0 = HR; \ + d0 = (CELL) ((*_PREG)->u.xfa.f); \ + *pt0++ = d0; \ + HR = pt0 + (*_PREG)->u.xfa.a; \ + (*_PREG) = NEXTOP((*_PREG), xfa); \ + (*_SREG) = pt0; \ + GONextW(); \ + END_PREFETCH_W(); + +#define GET_FLOAT_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xd.x); + +#if SIZEOF_DOUBLE == 2*SIZEOF_INT_P +#define GET_FLOAT_GFLOAT_NONVAR \ + BLOCK = (CELL)GET_FLOAT_GFLOAT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorDouble) { \ + YAAM_FAIL; \ + } \ + else { \ + pt1 = (*_PREG)->u.xd.d; \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + if ( \ + pt1[1] != pt0[1] \ + || pt1[2] != pt0[2] \ + ) { \ + YAAM_FAIL; \ + } \ + else { \ + GONext(); \ + } \ + } \ + } +#else /* SIZEOF_DOUBLE == 2*SIZEOF_INT_P */ +#define GET_FLOAT_GFLOAT_NONVAR \ + BLOCK = (CELL)GET_FLOAT_GFLOAT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorDouble) { \ + YAAM_FAIL; \ + } \ + else { \ + pt1 = (*_PREG)->u.xd.d; \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + if ( \ + pt1[1] != pt0[1] \ + ) { \ + YAAM_FAIL; \ + } \ + else { \ + GONext(); \ + } \ + } \ + } +#endif /* SIZEOF_DOUBLE == 2*SIZEOF_INT_P */ + +#define GET_FLOAT_GFLOAT_UNK \ + START_PREFETCH(xc); \ + d1 = AbsAppl((*_PREG)->u.xd.d); \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); + +#define GET_LONGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xi.x); + +#define GET_LONGINT_GLONGINT_NONVAR \ + BLOCK = (CELL)GET_LONGINT_GLONGINT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorLongInt) { \ + YAAM_FAIL; \ + } \ + if ((*_PREG)->u.xi.i[1] != (CELL)pt0[1]) { \ + YAAM_FAIL; \ + } \ + } \ + if (!FAILED) { \ + (*_PREG) = NEXTOP((*_PREG), xi); \ + GONext(); \ + } + +#define GET_LONGINT_GLONGINT_UNK \ + START_PREFETCH(xi); \ + d1 = AbsAppl((*_PREG)->u.xi.i); \ + (*_PREG) = NEXTOP((*_PREG), xi); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); + +#ifdef USE_GMP +#define GET_BIGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xN.x); + +#define GET_BIGINT_GBIGINT_NONVAR \ + BLOCK = (CELL)GET_BIGINT_GBIGINT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorBigInt) { \ + YAAM_FAIL; \ + } \ + if (Yap_gmp_tcmp_big_big(d0,(*_PREG)->u.xN.b)) { \ + YAAM_FAIL; \ + } \ + } \ + if (!FAILED) { \ + (*_PREG) = NEXTOP((*_PREG), xN); \ + GONext(); \ + } + +#define GET_BIGINT_GBIGINT_UNK \ + START_PREFETCH(xN); \ + d1 = (*_PREG)->u.xN.b; \ + (*_PREG) = NEXTOP((*_PREG), xN); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); +#endif + +#define GET_DBTERM_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xD.x); + +#define GET_DBTERM_GDBTERM_NONVAR \ + BLOCK = (CELL)GET_DBTERM_GDBTERM_NONVAR; \ + d1 = (*_PREG)->u.xD.D; \ + (*_PREG) = NEXTOP((*_PREG), xD); \ + YAAM_UNIFYBOUND; + +#define GET_DBTERM_GDBTERM_UNK \ + START_PREFETCH(xD); \ + d1 = (*_PREG)->u.xD.D; \ + (*_PREG) = NEXTOP((*_PREG), xD); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); + +#define GLIST_VALX_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xx.xl); \ + if (!IsVarTerm(d0)) { \ + printf("Oops!\n"); \ + exit(1); \ + } + +#define GLIST_VALX_GLIST_VALX_READ \ + BLOCK = (CELL)GLIST_VALX_GLIST_VALX_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0); \ + (*_SREG) = pt0 + 1; \ + d0 = *pt0; \ + } + +#define GLIST_VALX_GLIST_VALX_NONVAR \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GLIST_VALX_GLIST_VALX_NONVAR_NONVAR \ + BLOCK = (CELL)GLIST_VALX_GLIST_VALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + YAAM_UNIFYBOUND; + +#define GLIST_VALX_GLIST_VALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt1, d0); \ + GONext(); + +#define GLIST_VALX_GLIST_VALX_UNK \ + d0 = XREG((*_PREG)->u.xx.xr); + +#define GLIST_VALX_GLIST_VALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind_Global(pt0, d0); \ + GONext(); + +#define GLIST_VALX_GLIST_VALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); \ + +#define GLIST_VALX_GLIST_VALX_WRITE \ + CACHE_S(); \ + S_SREG = HR; \ + d1 = XREG((*_PREG)->u.xx.xr); \ + d0 = AbsPair(S_SREG); \ + S_SREG[0] = d1; \ + ALWAYS_START_PREFETCH_W(xx); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG+1); \ + Bind(pt0, d0); \ + ALWAYS_GONextW(); \ + ALWAYS_END_PREFETCH_W(); \ + ENDCACHE_S(); + +#define GLIST_VALY_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yx.x); + +#define GLIST_VALY_GLIST_VALY_READ \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + START_PREFETCH(yx); \ + pt0 = RepPair(d0); \ + (*_SREG) = pt0 + 1; \ + d0 = *pt0; + +#define GLIST_VALY_GLIST_VALY_NONVAR \ + pt1 = YREG + (*_PREG)->u.yx.y; \ + d1 = *pt1; \ + (*_PREG) = NEXTOP((*_PREG), yx); + +#define GLIST_VALY_GLIST_VALY_NONVAR_NONVAR \ + BLOCK = (CELL)GLIST_VALY_GLIST_VALY_NONVAR_NONVAR; \ + (*_SREG) = pt0 + 1; \ + YAAM_UNIFYBOUND; + +#define GLIST_VALY_GLIST_VALY_NONVAR_UNK \ + Bind(pt1, d0); \ + GONext(); + +#define GLIST_VALY_GLIST_VALY_UNK \ + pt1 = YREG+(*_PREG)->u.yx.y; \ + d1 = *pt1; + +#define GLIST_VALY_GLIST_VALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define GLIST_VALY_GLIST_VALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); \ + END_PREFETCH(); + +#define GLIST_VALY_GLIST_VALY_WRITE \ + START_PREFETCH_W(yx); \ + pt1 = HR; \ + d0 = AbsPair(pt1); \ + Bind(pt0, d0); \ + d0 = YREG[(*_PREG)->u.yx.y]; \ + pt1[0] = d0; \ + HR = pt1 + 2; \ + (*_SREG) = pt1 + 1; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONextW(); \ + END_PREFETCH_W(); + +#define GL_VOID_VARX_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xx.xl); + +#define GL_VOID_VARX_GLIST_VOID_VARX_READ \ + BLOCK = (CELL)GL_VOID_VARX_GLIST_VOID_VARX_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0); \ + d0 = pt0[1]; \ + XREG((*_PREG)->u.xx.xr) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + ALWAYS_GONext(); \ + } + +#define GL_VOID_VARX_GLIST_VOID_VAR_WRITE \ + pt1 = HR; \ + XREG((*_PREG)->u.xx.xr) = \ + Unsigned(pt1 + 1); \ + RESET_VARIABLE(pt1); \ + RESET_VARIABLE(pt1+1); \ + HR = pt1 + 2; \ + d0 = AbsPair(pt1); \ + Bind(pt0, d0); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONext(); + +#define GL_VOID_VARY_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yx.x); + +#define GL_VOID_VARY_GLIST_VOID_VARY_READ \ + BLOCK = (CELL)GL_VOID_VARY_GLIST_VOID_VARY_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0); \ + d0 = pt0[1]; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.yx.y,d0); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); \ + } + +#define GL_VOID_VARY_GLIST_VOID_VARY_WRITE \ + pt1 = HR; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.yx.y,Unsigned(pt1 + 1)); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + RESET_VARIABLE(pt1); \ + RESET_VARIABLE(pt1+1); \ + d0 = AbsPair(pt1); \ + HR = pt1 + 2; \ + Bind(pt0, d0); \ + GONext(); + +#define GL_VOID_VALX_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xx.xl); + +#define GL_VOID_VALX_GLIST_VOID_VALX_READ \ + BLOCK = (CELL)GL_VOID_VALX_GLIST_VOID_VALX_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0)+1; \ + d0 = *pt0; \ + } + +#define GL_VOID_VALX_GLIST_VOID_VALX_NONVAR \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR \ + BLOCK = (CELL)GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + YAAM_UNIFYBOUND; + +#define GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt1, d0); \ + GONext(); + +#define GL_VOID_VALX_GLIST_VOID_VALX_UNK \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define GL_VOID_VALX_GLIST_VOID_VALX_WRITE \ + pt1 = HR; \ + d0 = AbsPair(pt1); \ + Bind(pt0, d0); \ + pt1 = HR; \ + d0 = XREG((*_PREG)->u.xx.xr); \ + RESET_VARIABLE(pt1); \ + pt1[1] = d0; \ + HR = pt1 + 2; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONext(); + +#define GL_VOID_VALY_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yx.x); + +#define GL_VOID_VALY_GLIST_VOID_VALY_READ \ + BLOCK = (CELL)GL_VOID_VALY_GLIST_VOID_VALY_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0)+1; \ + d0 = *pt0; \ + } + +#define GL_VOID_VALY_GLIST_VOID_VALY_NONVAR \ + pt1 = YREG+(*_PREG)->u.yx.y; \ + d1 = *pt1; + +#define GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR \ + BLOCK = (CELL)GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + YAAM_UNIFYBOUND; + +#define GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind(pt1, d0); \ + GONext(); + +#define GL_VOID_VALY_GLIST_VOID_VALY_UNK \ + pt1 = YREG+(*_PREG)->u.yx.y; \ + d1 = *pt1; + +#define GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define GL_VOID_VALY_GLIST_VOID_VALY_WRITE \ + CACHE_S(); \ + S_SREG = HR; \ + d0 = AbsPair(S_SREG); \ + Bind(pt0, d0); \ + S_SREG = HR; \ + d1 = YREG[(*_PREG)->u.yx.y]; \ + RESET_VARIABLE(S_SREG); \ + S_SREG[1] = d1; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + HR = S_SREG + 2; \ + ENDCACHE_S(); \ + GONext(); + diff --git a/JIT/HPP/yaam_get_d.h b/JIT/HPP/yaam_get_d.h new file mode 100644 index 000000000..0bcbf9e2c --- /dev/null +++ b/JIT/HPP/yaam_get_d.h @@ -0,0 +1,861 @@ +#define GET_X_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.xx.xr); \ + XREG((*_PREG)->u.xx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONext(); + +#define GET_Y_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + d0 = XREG((*_PREG)->u.yx.x); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define GET_YY_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + CACHE_Y(YREG); \ + pt0 = S_YREG + (*_PREG)->u.yyxx.y1; \ + d0 = XREG((*_PREG)->u.yyxx.x1); \ + pt1 = S_YREG + (*_PREG)->u.yyx.y2; \ + d1 = XREG((*_PREG)->u.yyxx.x2); \ + (*_PREG) = NEXTOP((*_PREG), yyxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + INITIALIZE_PERMVAR(pt1,d1); \ + ENDCACHE_Y(); \ + GONext(); + +#define GET_X_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xx.xl); + +#define GET_X_VAL_GVALX_NONVAR \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GET_X_VAL_GVALX_NONVAR_NONVAR \ + BLOCK = (CELL)GET_X_VAL_GVALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + YAAM_UNIFYBOUND; + +#define GET_X_VAL_GVALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt0, d0); \ + GONext(); + +#define GET_X_VAL_GVALX_UNK \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GET_X_VAL_GVALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_X_VAL_GVALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + UnifyCells(pt0, pt1); \ + GONext(); + +#define GET_Y_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + d0 = *pt0; + +#define GET_Y_VAL_GVALY_NONVAR \ + d1 = XREG((*_PREG)->u.yx.x); + +#define GET_Y_VAL_GVALY_NONVAR_NONVAR \ + BLOCK = (CELL)GET_Y_VAL_GVALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + YAAM_UNIFYBOUND; + +#define GET_Y_VAL_GVALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind(pt1, d0); \ + GONext(); + +#define GET_Y_VAL_GVALY_UNK \ + d1 = XREG((*_PREG)->u.yx.x); + +#define GET_Y_VAL_GVALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_Y_VAL_GVALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + UnifyCells(pt0, pt1); \ + GONext(); + +#define GET_ATOM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xc.x); \ + d1 = (*_PREG)->u.xc.c; + +#define GET_ATOM_GATOM_NONVAR \ + BLOCK = (CELL)GET_ATOM_GATOM_NONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), xc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_ATOM_GATOM_UNK \ + (*_PREG) = NEXTOP((*_PREG), xc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_2ATOMS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_2ATOMS_GATOM_2UNK \ + Bind(pt0, (*_PREG)->u.cc.c1); + +#define GET_2ATOMS_GATOM_2B \ + d0 = ARG2; \ + d1 = (*_PREG)->u.cc.c2; + +#define GET_2ATOMS_GATOM_2BNONVAR \ + BLOCK = (CELL)GET_2ATOMS_GATOM_2BNONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), cc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_2ATOMS_GATOM_2BUNK \ + (*_PREG) = NEXTOP((*_PREG), cc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_3ATOMS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_3ATOMS_GATOM_3UNK \ + Bind(pt0, (*_PREG)->u.ccc.c1); + +#define GET_3ATOMS_GATOM_3B \ + d0 = ARG2; + +#define GET_3ATOMS_GATOM_3BUNK \ + Bind(pt0, (*_PREG)->u.ccc.c2); + +#define GET_3ATOMS_GATOM_3C \ + d0 = ARG3; \ + d1 = (*_PREG)->u.ccc.c3; + +#define GET_3ATOMS_GATOM_3CNONVAR \ + BLOCK = (CELL)GET_3ATOMS_GATOM_3CNONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), ccc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_3ATOMS_GATOM_3CUNK \ + (*_PREG) = NEXTOP((*_PREG), ccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_4ATOMS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_4ATOMS_GATOM_4UNK \ + Bind(pt0, (*_PREG)->u.cccc.c1); + +#define GET_4ATOMS_GATOM_4B \ + d0 = ARG2; + +#define GET_4ATOMS_GATOM_4BUNK \ + Bind(pt0, (*_PREG)->u.cccc.c2); + +#define GET_4ATOMS_GATOM_4C \ + d0 = ARG3; + +#define GET_4ATOMS_GATOM_4CUNK \ + Bind(pt0, (*_PREG)->u.cccc.c3); + +#define GET_4ATOMS_GATOM_4D \ + d0 = ARG4; \ + d1 = (*_PREG)->u.cccc.c4; + +#define GET_4ATOMS_GATOM_4DNONVAR \ + BLOCK = (CELL)GET_4ATOMS_GATOM_4DNONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), cccc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_4ATOMS_GATOM_4DUNK \ + (*_PREG) = NEXTOP((*_PREG), cccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_5ATOMS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_5ATOMS_GATOM_5UNK \ + Bind(pt0, (*_PREG)->u.ccccc.c1); + +#define GET_5ATOMS_GATOM_5B \ + d0 = ARG2; + +#define GET_5ATOMS_GATOM_5BUNK \ + Bind(pt0, (*_PREG)->u.ccccc.c2); + +#define GET_5ATOMS_GATOM_5C \ + d0 = ARG3; + +#define GET_5ATOMS_GATOM_5CUNK \ + Bind(pt0, (*_PREG)->u.ccccc.c3); + +#define GET_5ATOMS_GATOM_5D \ + d0 = ARG4; + +#define GET_5ATOMS_GATOM_5DUNK \ + Bind(pt0, (*_PREG)->u.ccccc.c4); + +#define GET_5ATOMS_GATOM_5E \ + d0 = ARG5; \ + d1 = (*_PREG)->u.ccccc.c5; + +#define GET_5ATOMS_GATOM_5ENONVAR \ + BLOCK = (CELL)GET_5ATOMS_GATOM_5ENONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), ccccc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_5ATOMS_GATOM_5EUNK \ + (*_PREG) = NEXTOP((*_PREG), ccccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_6ATOMS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = ARG1; + +#define GET_6ATOMS_GATOM_6UNK \ + Bind(pt0, (*_PREG)->u.cccccc.c1); + +#define GET_6ATOMS_GATOM_6B \ + d0 = ARG2; + +#define GET_6ATOMS_GATOM_6BUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c2); + +#define GET_6ATOMS_GATOM_6C \ + d0 = ARG3; + +#define GET_6ATOMS_GATOM_6CUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c3); + +#define GET_6ATOMS_GATOM_6D \ + d0 = ARG4; + +#define GET_6ATOMS_GATOM_6DUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c4); + +#define GET_6ATOMS_GATOM_6E \ + d0 = ARG5; + +#define GET_6ATOMS_GATOM_6EUNK \ + Bind(pt0, (*_PREG)->u.cccccc.c5); + +#define GET_6ATOMS_GATOM_6F \ + d0 = ARG6; \ + d1 = (*_PREG)->u.cccccc.c6; + +#define GET_6ATOMS_GATOM_6FNONVAR \ + BLOCK = (CELL)GET_6ATOMS_GATOM_6FNONVAR; \ + FAILED = 0; \ + if (d0 == d1) { \ + (*_PREG) = NEXTOP((*_PREG), cccccc); \ + GONext(); \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define GET_6ATOMS_GATOM_6FUNK \ + (*_PREG) = NEXTOP((*_PREG), cccccc); \ + Bind(pt0, d1); \ + GONext(); + +#define GET_LIST_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.x.x); + +#define GET_LIST_GLIST_NONVAR \ + BLOCK = (CELL)GET_LIST_GLIST_NONVAR; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), x); \ + (*_SREG) = RepPair(d0); \ + GONext(); \ + } + +#define GET_LIST_GLIST_UNK \ + CACHE_S(); \ + S_SREG = HR; \ + START_PREFETCH_W(x); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + d0 = AbsPair(S_SREG); \ + Bind(pt0, d0); \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG); \ + GONextW(); \ + END_PREFETCH_W(); \ + ENDCACHE_S(); + +#define GET_STRUCT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xfa.x); + +#define GET_STRUCT_GSTRUCT_NONVAR \ + BLOCK = (CELL)GET_STRUCT_GSTRUCT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + register CELL * S_SREG; \ + S_SREG = RepAppl(d0); \ + d0 = (CELL) ((*_PREG)->u.xfa.f); \ + if (*S_SREG != d0) { \ + YAAM_FAIL; \ + } \ + else { \ + WRITEBACK_S(S_SREG+1); \ + (*_PREG) = NEXTOP((*_PREG), xfa); \ + GONext(); \ + } \ + } + +#define GET_STRUCT_GSTRUCT_UNK \ + START_PREFETCH_W(xfa); \ + d1 = AbsAppl(HR); \ + Bind(pt0, d1); \ + pt0 = HR; \ + d0 = (CELL) ((*_PREG)->u.xfa.f); \ + *pt0++ = d0; \ + HR = pt0 + (*_PREG)->u.xfa.a; \ + (*_PREG) = NEXTOP((*_PREG), xfa); \ + (*_SREG) = pt0; \ + GONextW(); \ + END_PREFETCH_W(); + +#define GET_FLOAT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xd.x); + +#if SIZEOF_DOUBLE == 2*SIZEOF_INT_P +#define GET_FLOAT_GFLOAT_NONVAR \ + BLOCK = (CELL)GET_FLOAT_GFLOAT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorDouble) { \ + YAAM_FAIL; \ + } \ + else { \ + pt1 = (*_PREG)->u.xd.d; \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + if ( \ + pt1[1] != pt0[1] \ + || pt1[2] != pt0[2] \ + ) { \ + YAAM_FAIL; \ + } \ + else { \ + GONext(); \ + } \ + } \ + } +#else /* SIZEOF_DOUBLE == 2*SIZEOF_INT_P */ +#define GET_FLOAT_GFLOAT_NONVAR \ + BLOCK = (CELL)GET_FLOAT_GFLOAT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorDouble) { \ + YAAM_FAIL; \ + } \ + else { \ + pt1 = (*_PREG)->u.xd.d; \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + if ( \ + pt1[1] != pt0[1] \ + ) { \ + YAAM_FAIL; \ + } \ + else { \ + GONext(); \ + } \ + } \ + } +#endif /* SIZEOF_DOUBLE == 2*SIZEOF_INT_P */ + +#define GET_FLOAT_GFLOAT_UNK \ + START_PREFETCH(xc); \ + d1 = AbsAppl((*_PREG)->u.xd.d); \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); + +#define GET_LONGINT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xi.x); + +#define GET_LONGINT_GLONGINT_NONVAR \ + BLOCK = (CELL)GET_LONGINT_GLONGINT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorLongInt) { \ + YAAM_FAIL; \ + } \ + if ((*_PREG)->u.xi.i[1] != (CELL)pt0[1]) { \ + YAAM_FAIL; \ + } \ + } \ + if (!FAILED) { \ + (*_PREG) = NEXTOP((*_PREG), xi); \ + GONext(); \ + } + +#define GET_LONGINT_GLONGINT_UNK \ + START_PREFETCH(xi); \ + d1 = AbsAppl((*_PREG)->u.xi.i); \ + (*_PREG) = NEXTOP((*_PREG), xi); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); + +#ifdef USE_GMP +#define GET_BIGINT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xN.x); + +#define GET_BIGINT_GBIGINT_NONVAR \ + BLOCK = (CELL)GET_BIGINT_GBIGINT_NONVAR; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepAppl(d0); \ + if (*pt0 != (CELL)FunctorBigInt) { \ + YAAM_FAIL; \ + } \ + if (Yap_gmp_tcmp_big_big(d0,(*_PREG)->u.xN.b)) { \ + YAAM_FAIL; \ + } \ + } \ + if (!FAILED) { \ + (*_PREG) = NEXTOP((*_PREG), xN); \ + GONext(); \ + } + +#define GET_BIGINT_GBIGINT_UNK \ + START_PREFETCH(xN); \ + d1 = (*_PREG)->u.xN.b; \ + (*_PREG) = NEXTOP((*_PREG), xN); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); +#endif + +#define GET_DBTERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xD.x); + +#define GET_DBTERM_GDBTERM_NONVAR \ + BLOCK = (CELL)GET_DBTERM_GDBTERM_NONVAR; \ + d1 = (*_PREG)->u.xD.D; \ + (*_PREG) = NEXTOP((*_PREG), xD); \ + YAAM_UNIFYBOUND; + +#define GET_DBTERM_GDBTERM_UNK \ + START_PREFETCH(xD); \ + d1 = (*_PREG)->u.xD.D; \ + (*_PREG) = NEXTOP((*_PREG), xD); \ + Bind(pt0, d1); \ + GONext(); \ + END_PREFETCH(); + +#define GLIST_VALX_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xx.xl); \ + if (!IsVarTerm(d0)) { \ + printf("Oops!\n"); \ + exit(1); \ + } + +#define GLIST_VALX_GLIST_VALX_READ \ + BLOCK = (CELL)GLIST_VALX_GLIST_VALX_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0); \ + (*_SREG) = pt0 + 1; \ + d0 = *pt0; \ + } + +#define GLIST_VALX_GLIST_VALX_NONVAR \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GLIST_VALX_GLIST_VALX_NONVAR_NONVAR \ + BLOCK = (CELL)GLIST_VALX_GLIST_VALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + YAAM_UNIFYBOUND; + +#define GLIST_VALX_GLIST_VALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt1, d0); \ + GONext(); + +#define GLIST_VALX_GLIST_VALX_UNK \ + d0 = XREG((*_PREG)->u.xx.xr); + +#define GLIST_VALX_GLIST_VALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind_Global(pt0, d0); \ + GONext(); + +#define GLIST_VALX_GLIST_VALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); \ + +#define GLIST_VALX_GLIST_VALX_WRITE \ + CACHE_S(); \ + S_SREG = HR; \ + d1 = XREG((*_PREG)->u.xx.xr); \ + d0 = AbsPair(S_SREG); \ + S_SREG[0] = d1; \ + ALWAYS_START_PREFETCH_W(xx); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG+1); \ + Bind(pt0, d0); \ + ALWAYS_GONextW(); \ + ALWAYS_END_PREFETCH_W(); \ + ENDCACHE_S(); + +#define GLIST_VALY_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yx.x); + +#define GLIST_VALY_GLIST_VALY_READ \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + START_PREFETCH(yx); \ + pt0 = RepPair(d0); \ + (*_SREG) = pt0 + 1; \ + d0 = *pt0; + +#define GLIST_VALY_GLIST_VALY_NONVAR \ + pt1 = YREG + (*_PREG)->u.yx.y; \ + d1 = *pt1; \ + (*_PREG) = NEXTOP((*_PREG), yx); + +#define GLIST_VALY_GLIST_VALY_NONVAR_NONVAR \ + BLOCK = (CELL)GLIST_VALY_GLIST_VALY_NONVAR_NONVAR; \ + (*_SREG) = pt0 + 1; \ + YAAM_UNIFYBOUND; + +#define GLIST_VALY_GLIST_VALY_NONVAR_UNK \ + Bind(pt1, d0); \ + GONext(); + +#define GLIST_VALY_GLIST_VALY_UNK \ + pt1 = YREG+(*_PREG)->u.yx.y; \ + d1 = *pt1; + +#define GLIST_VALY_GLIST_VALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define GLIST_VALY_GLIST_VALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); \ + END_PREFETCH(); + +#define GLIST_VALY_GLIST_VALY_WRITE \ + START_PREFETCH_W(yx); \ + pt1 = HR; \ + d0 = AbsPair(pt1); \ + Bind(pt0, d0); \ + d0 = YREG[(*_PREG)->u.yx.y]; \ + pt1[0] = d0; \ + HR = pt1 + 2; \ + (*_SREG) = pt1 + 1; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONextW(); \ + END_PREFETCH_W(); + +#define GL_VOID_VARX_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xx.xl); + +#define GL_VOID_VARX_GLIST_VOID_VARX_READ \ + BLOCK = (CELL)GL_VOID_VARX_GLIST_VOID_VARX_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0); \ + d0 = pt0[1]; \ + XREG((*_PREG)->u.xx.xr) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + ALWAYS_GONext(); \ + } + +#define GL_VOID_VARX_GLIST_VOID_VAR_WRITE \ + pt1 = HR; \ + XREG((*_PREG)->u.xx.xr) = \ + Unsigned(pt1 + 1); \ + RESET_VARIABLE(pt1); \ + RESET_VARIABLE(pt1+1); \ + HR = pt1 + 2; \ + d0 = AbsPair(pt1); \ + Bind(pt0, d0); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONext(); + +#define GL_VOID_VARY_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yx.x); + +#define GL_VOID_VARY_GLIST_VOID_VARY_READ \ + BLOCK = (CELL)GL_VOID_VARY_GLIST_VOID_VARY_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0); \ + d0 = pt0[1]; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.yx.y,d0); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); \ + } + +#define GL_VOID_VARY_GLIST_VOID_VARY_WRITE \ + pt1 = HR; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.yx.y,Unsigned(pt1 + 1)); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + RESET_VARIABLE(pt1); \ + RESET_VARIABLE(pt1+1); \ + d0 = AbsPair(pt1); \ + HR = pt1 + 2; \ + Bind(pt0, d0); \ + GONext(); + +#define GL_VOID_VALX_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xx.xl); + +#define GL_VOID_VALX_GLIST_VOID_VALX_READ \ + BLOCK = (CELL)GL_VOID_VALX_GLIST_VOID_VALX_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0)+1; \ + d0 = *pt0; \ + } + +#define GL_VOID_VALX_GLIST_VOID_VALX_NONVAR \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR \ + BLOCK = (CELL)GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + YAAM_UNIFYBOUND; + +#define GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind(pt1, d0); \ + GONext(); + +#define GL_VOID_VALX_GLIST_VOID_VALX_UNK \ + d1 = XREG((*_PREG)->u.xx.xr); + +#define GL_VOID_VALX_GLIST_VOID_VALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define GL_VOID_VALX_GLIST_VOID_VALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define GL_VOID_VALX_GLIST_VOID_VALX_WRITE \ + pt1 = HR; \ + d0 = AbsPair(pt1); \ + Bind(pt0, d0); \ + pt1 = HR; \ + d0 = XREG((*_PREG)->u.xx.xr); \ + RESET_VARIABLE(pt1); \ + pt1[1] = d0; \ + HR = pt1 + 2; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONext(); + +#define GL_VOID_VALY_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yx.x); + +#define GL_VOID_VALY_GLIST_VOID_VALY_READ \ + BLOCK = (CELL)GL_VOID_VALY_GLIST_VOID_VALY_READ; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt0 = RepPair(d0)+1; \ + d0 = *pt0; \ + } + +#define GL_VOID_VALY_GLIST_VOID_VALY_NONVAR \ + pt1 = YREG+(*_PREG)->u.yx.y; \ + d1 = *pt1; + +#define GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR \ + BLOCK = (CELL)GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + YAAM_UNIFYBOUND; + +#define GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind(pt1, d0); \ + GONext(); + +#define GL_VOID_VALY_GLIST_VOID_VALY_UNK \ + pt1 = YREG+(*_PREG)->u.yx.y; \ + d1 = *pt1; + +#define GL_VOID_VALY_GLIST_VOID_VALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define GL_VOID_VALY_GLIST_VOID_VALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define GL_VOID_VALY_GLIST_VOID_VALY_WRITE \ + CACHE_S(); \ + S_SREG = HR; \ + d0 = AbsPair(S_SREG); \ + Bind(pt0, d0); \ + S_SREG = HR; \ + d1 = YREG[(*_PREG)->u.yx.y]; \ + RESET_VARIABLE(S_SREG); \ + S_SREG[1] = d1; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + HR = S_SREG + 2; \ + ENDCACHE_S(); \ + GONext(); + diff --git a/JIT/HPP/yaam_macros.hh b/JIT/HPP/yaam_macros.hh new file mode 100644 index 000000000..0372aad5e --- /dev/null +++ b/JIT/HPP/yaam_macros.hh @@ -0,0 +1,1309 @@ +typedef enum { + #include "Yap_BasicBlocks.h" +} YAP_BBs; + +#ifndef _NATIVE + +#include "lastop.h" +#include "sprintblock.h" + +static inline Int +set_last_deeply(BlocksContext* b, BlocksContext** last) { + BlocksContext *last1, *last2; + while (b) { + if (b->blockty == MULTIPLE_DESTINY && b->thisp == BLOCKADDRESS && b->u.mdb.id == BLOCK) { + *last = b; + return 1; + } + if (b->blockty == CONDITIONAL_HEADER) { + Int _if = set_last_deeply(b->u.kb._if, &last1); + Int _else = set_last_deeply(b->u.kb._else, &last2); + if (_if || _else) { + if (_if) *last = last1; + else *last = last2; + return 1; + } + } + b = (BlocksContext*)b->next; + } + *last = NULL; + return 0; +} + +#ifdef USE_GMP +#define FUNCTOR_LARGE_INT "(CELL)f0 == (CELL)FunctorLongInt || (CELL)f0 == (CELL)FunctorBigInt" +#else +#define FUNCTOR_LARGE_INT "(CELL)f0 == (CELL)FunctorLongInt" +#endif + +#define SET_DEPTH(yaam_block) \ + { \ + inst_depth = 0; \ + if (yaam_block == GET_X_VAL_INSTINIT) { \ + inst_depth = 2; \ + } \ + } + +#define BACK_TO_HEADER() \ + { \ + while (curblock->prev) { \ + curblock = (BlocksContext*)curblock->prev; \ + } \ + curblock = (BlocksContext*)curblock->u.xb.header; \ + } + +#define FREE(N) \ + { \ + int j; \ + for (j = 0; j < N; j++) { \ + free(cexp[j]); \ + } \ + free(cexp); \ + free(condty); \ + } + +#define YAAM_BLOCK_IS_DEEPB_MULTIPLE_DESTINY(yaam_block) \ + yaam_block == GL_VOID_VALX_GLIST_VOID_VALX_NONVAR_NONVAR || \ + yaam_block == GL_VOID_VALX_GLIST_VOID_VALX_READ || \ + yaam_block == GL_VOID_VALY_GLIST_VOID_VALY_NONVAR_NONVAR || \ + yaam_block == GL_VOID_VALY_GLIST_VOID_VALY_READ || \ + yaam_block == UNIFY_X_VAL_UVALX_NONVAR_NONVAR || \ + yaam_block == UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR || \ + +#define EMIT_CONDITIONAL2_BLOCK(yaam_block, EXP1, EXP2, F1, F2) \ + if (first_valid_conditional) { \ + EMIT_2DEEP_BLOCK_TEST(yaam_block, EXP1, EXP2, F1, F2); \ + first_valid_conditional = 0; \ + } \ + else { \ + EMIT_DEEPFK_BLOCK_TEST(yaam_block); \ + } + +#define EMIT_CONDITIONAL1_BLOCK(yaam_block, EXP1, F1) \ + if (first_valid_conditional) { \ + EMIT_1DEEP_BLOCK_TEST(yaam_block, EXP1, F1); \ + first_valid_conditional = 0; \ + } \ + else { \ + EMIT_DEEPFK_BLOCK_TEST(yaam_block); \ + } + +#if defined(YAPOR) || defined(THREADS) +#define YAAM_BLOCK_IS_SIMPLEB_MULTIPLE_DESTINY(yaam_block) \ + yaam_block == YAAM_UNIFYBOUND || \ + yaam_block == PROFILED_RETRY_LOGICAL_END || \ + yaam_block == PROFILED_TRUST_LOGICAL_END || \ + yaam_block == COUNT_RETRY_LOGICAL_END || \ + yaam_block == COUNT_TRUST_LOGICAL_END || \ + yaam_block == LOCK_LU_END || \ + yaam_block == TRY_AND_MARK_YAPOR_THREADS_NOYAPOR_IF || \ +#else /* defined(YAPOR) || defined(THREADS) */ +#define YAAM_BLOCK_IS_SIMPLEB_MULTIPLE_DESTINY(yaam_block) \ + yaam_block == YAAM_UNIFYBOUND || \ + yaam_block == PROFILED_RETRY_LOGICAL_END || \ + yaam_block == PROFILED_TRUST_LOGICAL_END || \ + yaam_block == COUNT_RETRY_LOGICAL_END || \ + yaam_block == COUNT_TRUST_LOGICAL_END || \ + yaam_block == LOCK_LU_END +#endif + +#if YAP_DBG_PREDS +#define PRINT_BLOCK_MAC(yaam_block) print_block(yaam_block, ON_PROFILED_INTERPRETER); +#else /* YAP_DBG_PREDS */ +#define PRINT_BLOCK_MAC(yaam_block) +#endif /* YAP_DBG_PREDS */ + +#if YAP_STAT_PREDS +#define INIT_SPENT_PROF_TIME_FOR_HEAD(i) \ + struct rusage rustart, ruend; \ + struct timeval timstart, timend; \ + getrusage(RUSAGE_SELF, &rustart); + +#define COMPLETE_SPENT_PROF_TIME_FOR_HEAD(i) \ + getrusage(RUSAGE_SELF, &ruend); \ + timstart = rustart.ru_utime; \ + timend = ruend.ru_utime; \ + double spenttime = ((double)timend.tv_sec - (double)timstart.tv_sec) + ((double)timend.tv_usec - (double)timstart.tv_usec) / 1000000.0; \ + IntermediatecodeArea->area.profiling_time[i] += spenttime; + +#define INIT_SPENT_PROF_TIME() \ + struct rusage rustart, ruend; \ + struct timeval timstart, timend; \ + getrusage(RUSAGE_SELF, &rustart); + +#define COMPLETE_SPENT_PROF_TIME() \ + getrusage(RUSAGE_SELF, &ruend); \ + timstart = rustart.ru_utime; \ + timend = ruend.ru_utime; \ + double spenttime = ((double)timend.tv_sec - (double)timstart.tv_sec) + ((double)timend.tv_usec - (double)timstart.tv_usec) / 1000000.0; \ + IntermediatecodeArea->area.profiling_time[i] += spenttime; + +#else /* YAP_STAT_PREDS */ +#define INIT_SPENT_PROF_TIME_FOR_HEAD(i) + +#define COMPLETE_SPENT_PROF_TIME_FOR_HEAD(i) + +#define INIT_SPENT_PROF_TIME() + +#define COMPLETE_SPENT_PROF_TIME() + +#endif /* YAP_STAT_PREDS */ + +static void EMIT_MULTIPLE_DESTINY_BLOCK_TEST(YAP_BBs); + +static void +EMIT_MULTIPLE_DESTINY_BLOCK_TEST(YAP_BBs yaam_block) { + if (IntermediatecodeArea->n) { + PRINT_BLOCK_MAC(yaam_block); + int i; + for (i = 0; i < IntermediatecodeArea->n; i++) { + if (IntermediatecodeArea->area.t && + IntermediatecodeArea->area.ok && + IntermediatecodeArea->area.isactive && + IntermediatecodeArea->area.isactive[i]) + { + INIT_SPENT_PROF_TIME(); + curtrace = &IntermediatecodeArea->area.t[i]; + BlocksContext *curblock; + if (!globalcurblock) curblock = (*curtrace)->bc; + else curblock = globalcurblock[i]; + while (curblock->next) { + if ( (curblock->blockty == SIMPLE && curblock->thisp == (CELL)curpreg && curblock->u.sb.id == (UInt)yaam_block) || + (curblock->blockty == MULTIPLE_DESTINY && curblock->thisp == (CELL)curpreg && curblock->u.mdb.id == (UInt)yaam_block) ) + { break; } + curblock = (BlocksContext*)curblock->next; + } + if (!curblock->next && + (curblock->blockty != SIMPLE || curblock->thisp != (CELL)curpreg || curblock->u.sb.id != (UInt)yaam_block) && + (curblock->blockty != MULTIPLE_DESTINY || curblock->thisp != (CELL)curpreg || curblock->u.mdb.id != (UInt)yaam_block) + ) { + BlocksContext* t = (BlocksContext*)malloc(sizeof(BlocksContext)); + t->thisp = (CELL)curpreg; + t->next = 0; + t->prev = (CELL)curblock; + t->blockty = MULTIPLE_DESTINY; + t->u.mdb.id = (UInt)yaam_block; + t->u.mdb.ndest = 0; + t->u.mdb.nfaillabels = 0; + t->u.mdb.destiny.p = NULL; + t->u.mdb.destiny.labels = NULL; + t->u.mdb.faildestiny.p = NULL; + t->u.mdb.faildestiny.labels = NULL; + (*curtrace)->n += 1; + curblock->next = (CELL)t; + IntermediatecodeArea->area.lastblock[i] = t; + } + else { + IntermediatecodeArea->area.lastblock[i] = curblock; + } + COMPLETE_SPENT_PROF_TIME(); + } + } + } +} + +static void EMIT_SIMPLE_BLOCK_TEST(YAP_BBs); + +static void +EMIT_SIMPLE_BLOCK_TEST(YAP_BBs yaam_block) { + if (IntermediatecodeArea->n) { + PRINT_BLOCK_MAC(yaam_block); + int i; + for (i = 0; i < IntermediatecodeArea->n; i++) { + if (IntermediatecodeArea->area.t && + IntermediatecodeArea->area.ok && + IntermediatecodeArea->area.isactive && + IntermediatecodeArea->area.isactive[i]) + { + INIT_SPENT_PROF_TIME(); + curtrace = &IntermediatecodeArea->area.t[i]; + BlocksContext *curblock; + if (!globalcurblock) curblock = (*curtrace)->bc; + else curblock = globalcurblock[i]; + while (curblock->next) { + if ( (curblock->blockty == SIMPLE && curblock->thisp == (CELL)curpreg && curblock->u.sb.id == (UInt)yaam_block) || + (curblock->blockty == MULTIPLE_DESTINY && curblock->thisp == (CELL)curpreg && curblock->u.mdb.id == (UInt)yaam_block) ) + { break; } + curblock = (BlocksContext*)curblock->next; + } + if (!curblock->next && + (curblock->blockty != SIMPLE || curblock->thisp != (CELL)curpreg || curblock->u.sb.id != (UInt)yaam_block) && + (curblock->blockty != MULTIPLE_DESTINY || curblock->thisp != (CELL)curpreg || curblock->u.mdb.id != (UInt)yaam_block) + ) { + BlocksContext* t = (BlocksContext*)malloc(sizeof(BlocksContext)); + t->thisp = (CELL)curpreg; + t->next = 0; + t->prev = (CELL)curblock; + t->blockty = SIMPLE; + t->u.sb.id = (UInt)yaam_block; + t->u.sb.label_destiny = NULL; + (*curtrace)->n += 1; + curblock->next = (CELL)t; + IntermediatecodeArea->area.lastblock[i] = t; + } + else { + IntermediatecodeArea->area.lastblock[i] = curblock; + } + COMPLETE_SPENT_PROF_TIME(); + } + } + } +} + +#define EMIT_3DEEP_BLOCK(yaam_block, EXP1, EXP2, EXP3, N1, N2, N3) \ + if (IntermediatecodeArea->n) { \ + char *tmp = (char*) malloc(2048*sizeof(char)); \ + sprint_block((YAP_BBs)yaam_block, &tmp); \ + fprintf(stderr, "OOps!! Encontrei um bloco não instrumentado corretamente -- %s\n", tmp); \ + free(tmp); \ + exit(1); \ + } + +#define EMIT_2DEEP_BLOCK(yaam_block, EXP1, EXP2, N1, N2) \ + if (IntermediatecodeArea->n) { \ + char *tmp = (char*) malloc(2048*sizeof(char)); \ + sprint_block((YAP_BBs)yaam_block, &tmp); \ + fprintf(stderr, "OOps!! Encontrei um bloco não instrumentado corretamente -- %s\n", tmp); \ + free(tmp); \ + exit(1); \ + } + +#define EMIT_1DEEP_BLOCK(yaam_block, EXP, N) \ + if (IntermediatecodeArea->n) { \ + char *tmp = (char*) malloc(2048*sizeof(char)); \ + sprint_block((YAP_BBs)yaam_block, &tmp); \ + fprintf(stderr, "OOps!! Encontrei um bloco não instrumentado corretamente -- %s\n", tmp); \ + free(tmp); \ + exit(1); \ + } + +#define EMIT_SIMPLE_BLOCK(yaam_block) \ + if (IntermediatecodeArea->n) { \ + char *tmp = (char*) malloc(2048*sizeof(char)); \ + sprint_block((YAP_BBs)yaam_block, &tmp); \ + fprintf(stderr, "OOps!! Encontrei um bloco não instrumentado corretamente -- %s\n", tmp); \ + } + + +#define REDEFINE_DESTINY(A, B) \ + if ((A)->blockty == SIMPLE_ENTRY) { \ + strcpy((A)->u.eb.label_destiny, B->u.eb.label_entry); \ + } \ + else if ((A)->blockty == SIMPLE) { \ + strcpy((A)->u.sb.label_destiny, B->u.eb.label_entry); \ + } + +#define SET_FAILDESTINY_AS_MULTIPLE(B, i) \ + int k = 0; \ + while (k < IntermediatecodeArea->area.lastblock[i]->u.mdb.nfaillabels) { \ + if (!strcmp(IntermediatecodeArea->area.lastblock[i]->u.mdb.faildestiny.labels[k], (B)->u.eb.label_entry)) break; \ + k++; \ + } \ + if (k == IntermediatecodeArea->area.lastblock[i]->u.mdb.nfaillabels) { \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.nfaillabels++; \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.faildestiny.p = (UInt*)realloc(IntermediatecodeArea->area.lastblock[i]->u.mdb.faildestiny.p, IntermediatecodeArea->area.lastblock[i]->u.mdb.nfaillabels*sizeof(UInt)); \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.faildestiny.p[IntermediatecodeArea->area.lastblock[i]->u.mdb.nfaillabels-1] = (B)->thisp; \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.faildestiny.labels = (char**)realloc(IntermediatecodeArea->area.lastblock[i]->u.mdb.faildestiny.labels, IntermediatecodeArea->area.lastblock[i]->u.mdb.nfaillabels*sizeof(char*)); \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.faildestiny.labels[IntermediatecodeArea->area.lastblock[i]->u.mdb.nfaillabels-1] = (char*)malloc(1024*sizeof(char)); \ + strcpy(IntermediatecodeArea->area.lastblock[i]->u.mdb.faildestiny.labels[IntermediatecodeArea->area.lastblock[i]->u.mdb.nfaillabels-1], (B)->u.eb.label_entry); \ + } + +#define SET_DESTINY_AS_MULTIPLE(B, i) \ + int k = 0; \ + while (k < IntermediatecodeArea->area.lastblock[i]->u.mdb.ndest) { \ + if (!strcmp(IntermediatecodeArea->area.lastblock[i]->u.mdb.destiny.labels[k], (B)->u.eb.label_entry)) break; \ + k++; \ + } \ + if (k == IntermediatecodeArea->area.lastblock[i]->u.mdb.ndest) { \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.ndest++; \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.destiny.p = (UInt*)realloc(IntermediatecodeArea->area.lastblock[i]->u.mdb.destiny.p, IntermediatecodeArea->area.lastblock[i]->u.mdb.ndest*sizeof(UInt)); \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.destiny.p[IntermediatecodeArea->area.lastblock[i]->u.mdb.ndest-1] = (B)->thisp; \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.destiny.labels = (char**)realloc(IntermediatecodeArea->area.lastblock[i]->u.mdb.destiny.labels, IntermediatecodeArea->area.lastblock[i]->u.mdb.ndest*sizeof(char*)); \ + IntermediatecodeArea->area.lastblock[i]->u.mdb.destiny.labels[IntermediatecodeArea->area.lastblock[i]->u.mdb.ndest-1] = (char*)malloc(1024*sizeof(char)); \ + strcpy(IntermediatecodeArea->area.lastblock[i]->u.mdb.destiny.labels[IntermediatecodeArea->area.lastblock[i]->u.mdb.ndest-1], (B)->u.eb.label_entry); \ + } + +#define SET_DESTINY(yaam_block, B, i) \ + if (IntermediatecodeArea->area.lastblock[i]) { \ + if (IntermediatecodeArea->area.lastblock[i]->blockty == MULTIPLE_DESTINY) { \ + if (yaam_block == LBL_FAIL_INSTINIT) { \ + SET_FAILDESTINY_AS_MULTIPLE((B), i); \ + } \ + else { \ + SET_DESTINY_AS_MULTIPLE((B), i); \ + } \ + } \ + if (IntermediatecodeArea->area.lastblock[i]->blockty == SIMPLE_ENTRY) { \ + if (!IntermediatecodeArea->area.lastblock[i]->u.eb.label_destiny) { \ + IntermediatecodeArea->area.lastblock[i]->u.eb.label_destiny = (char*)malloc(1024*sizeof(char)); \ + strcpy(IntermediatecodeArea->area.lastblock[i]->u.eb.label_destiny, (B)->u.eb.label_entry); \ + } \ + } \ + else if (IntermediatecodeArea->area.lastblock[i]->blockty == SIMPLE) { \ + if (IntermediatecodeArea->area.lastblock[i]->u.sb.id != NoStackExecute_Exception) { \ + if (!IntermediatecodeArea->area.lastblock[i]->u.sb.label_destiny) { \ + IntermediatecodeArea->area.lastblock[i]->u.sb.label_destiny = (char*)malloc(1024*sizeof(char)); \ + strcpy(IntermediatecodeArea->area.lastblock[i]->u.sb.label_destiny, (B)->u.eb.label_entry); \ + } \ + } \ + } \ + } + +static void EMIT_HEAD_BLOCK(yamop*); + +static void +EMIT_HEAD_BLOCK(yamop* __P) { + INIT_SPENT_PROF_TIME_FOR_HEAD(__P->u.jhc.jh->caa.taddress); + if (curtrace) { + curpreg = __P; + if (curpreg == headoftrace && curtrace && (*curtrace)->n) { + SET_DESTINY(JIT_HANDLER_INSTINIT, (*curtrace)->bc, __P->u.jhc.jh->caa.taddress); + } + else { + (*curtrace)->bc = (BlocksContext*)malloc(sizeof(BlocksContext)); + (*curtrace)->bc->blockty = SIMPLE_ENTRY; + (*curtrace)->bc->thisp = (CELL)curpreg; + (*curtrace)->bc->next = 0; + (*curtrace)->bc->prev = 0; + (*curtrace)->bc->u.eb.id = (UInt)JIT_HANDLER_INSTINIT; + (*curtrace)->bc->u.eb.label_destiny = NULL; + (*curtrace)->bc->u.eb.label_entry = (char*)malloc(1024*sizeof(char)); + strcpy((*curtrace)->bc->u.eb.label_entry, "LBL_JIT_HANDLER_INSTINIT"); + char *hex = (char*)malloc(33*sizeof(char)); + sprintf(hex, "_%lX", (UInt)curpreg); + strcat((*curtrace)->bc->u.eb.label_entry, hex); + (*curtrace)->n = 1; + } + } + COMPLETE_SPENT_PROF_TIME_FOR_HEAD(__P->u.jhc.jh->caa.taddress); +} + +static void EMIT_ENTRY_BLOCK(yamop*, YAP_BBs); + +static void +EMIT_ENTRY_BLOCK(yamop* __P, YAP_BBs yaam_block) { + if (IntermediatecodeArea->n) { + PRINT_BLOCK_MAC(yaam_block); + if (globalcurblock) { + free(globalcurblock); + globalcurblock = NULL; + } + int i; + for (i = 0; i < IntermediatecodeArea->n; i++) { + if (IntermediatecodeArea->area.t && + IntermediatecodeArea->area.ok && + IntermediatecodeArea->area.isactive && + IntermediatecodeArea->area.isactive[i]) + { + INIT_SPENT_PROF_TIME(); + curtrace = &IntermediatecodeArea->area.t[i]; + curpreg = __P; + BlocksContext *curblock = (*curtrace)->bc; + while (curblock->next) { + if (curblock->blockty == SIMPLE_ENTRY && curblock->thisp == (CELL)curpreg && curblock->u.eb.id == (UInt)yaam_block) { + break; + } + curblock = (BlocksContext*)curblock->next; + } + if (!curblock->next && + (curblock->blockty != SIMPLE_ENTRY || curblock->thisp != (CELL)curpreg || curblock->u.eb.id != (UInt)yaam_block) + ) { + BlocksContext* t = (BlocksContext*)malloc(sizeof(BlocksContext)); + t = (BlocksContext*)malloc(sizeof(BlocksContext)); + t->blockty = SIMPLE_ENTRY; + t->thisp = (CELL)curpreg; + t->next = 0; + t->prev = (CELL)curblock; + t->u.eb.id = (UInt)yaam_block; + t->u.eb.label_destiny = NULL; + t->u.eb.label_entry = (char*)malloc(1024*sizeof(char)); + { + strcpy(t->u.eb.label_entry, "LBL_"); + char *tmp = (char*)malloc(2048*sizeof(char)); + linear_sprint_block(yaam_block, &tmp); + strcat(t->u.eb.label_entry, tmp); + char* hex = (char*)malloc(33*sizeof(char)); + sprintf(hex, "_%lX", (UInt)t->thisp); + strcat(t->u.eb.label_entry, hex); + } + SET_DESTINY(yaam_block, t, i); + if (ineedredefinedest) { + REDEFINE_DESTINY(IntermediatecodeArea->area.lastblock[i], t); + ineedredefinedest = 0; + } + (*curtrace)->n += 1; + curblock->next = (CELL)t; + IntermediatecodeArea->area.lastblock[i] = t; + } + else { + SET_DESTINY(yaam_block, curblock, i); + IntermediatecodeArea->area.lastblock[i] = curblock; + } + COMPLETE_SPENT_PROF_TIME(); + } + } + } +} + +#define EMIT_CONDITIONAL_FAIL(EXP) \ + if (IntermediatecodeArea->n) { \ + int i; \ + BlocksContext** temp_globalcurblock = (BlocksContext**)malloc(IntermediatecodeArea->n * sizeof(BlocksContext*)); \ + for (i = 0; i < IntermediatecodeArea->n; i++) { \ + if (IntermediatecodeArea->area.t && \ + IntermediatecodeArea->area.ok && \ + IntermediatecodeArea->area.isactive && \ + IntermediatecodeArea->area.isactive[i]) \ + { \ + INIT_SPENT_PROF_TIME(); \ + curtrace = &IntermediatecodeArea->area.t[i]; \ + BlocksContext *c; \ + if (!globalcurblock) c = (*curtrace)->bc; \ + else c = globalcurblock[i]; \ + while (c->next) { \ + if (c->blockty == CONDITIONAL_HEADER && c->thisp == (CELL)curpreg && !strcmp(c->u.kb.exp, EXP)) { break; } \ + c = (BlocksContext*)c->next; \ + } \ + if (!c->next && (c->blockty != CONDITIONAL_HEADER || c->thisp != (CELL)curpreg || strcmp(c->u.kb.exp, EXP)) ) { \ + BlocksContext *t = (BlocksContext*)malloc(sizeof(BlocksContext)); \ + t->blockty = CONDITIONAL_HEADER; \ + t->thisp = (CELL)curpreg; \ + t->next = 0; \ + t->prev = (CELL)c; \ + t->u.kb.exp = (char*)malloc(1024*sizeof(char)); \ + strcpy(t->u.kb.exp, EXP); \ + t->u.kb._if = (BlocksContext*)malloc(sizeof(BlocksContext)); \ + t->u.kb._if->blockty = NONE; \ + t->u.kb._if->thisp = (CELL)curpreg; \ + t->u.kb._if->next = 0; \ + t->u.kb._if->prev = 0; \ + t->u.kb._if->u.xb.header = (CELL)t; \ + t->u.kb._else = (BlocksContext*)malloc(sizeof(BlocksContext)); \ + t->u.kb._else->blockty = NONE; \ + t->u.kb._else->thisp = (CELL)curpreg; \ + t->u.kb._else->next = 0; \ + t->u.kb._else->prev = 0; \ + t->u.kb._else->u.xb.header = (CELL)t; \ + c->next = (CELL)t; \ + c = t->u.kb._else; \ + (*curtrace)->n += 2; \ + } \ + else { \ + c = c->u.kb._else; \ + } \ + temp_globalcurblock[i] = c; \ + COMPLETE_SPENT_PROF_TIME(); \ + } \ + } \ + globalcurblock = temp_globalcurblock; \ + } + +#define EMIT_CONDITIONAL_SUCCESS(EXP) \ + if (IntermediatecodeArea->n) { \ + int i; \ + BlocksContext** temp_globalcurblock = (BlocksContext**)malloc(IntermediatecodeArea->n * sizeof(BlocksContext*)); \ + for (i = 0; i < IntermediatecodeArea->n; i++) { \ + if (IntermediatecodeArea->area.t && \ + IntermediatecodeArea->area.ok && \ + IntermediatecodeArea->area.isactive && \ + IntermediatecodeArea->area.isactive[i]) \ + { \ + INIT_SPENT_PROF_TIME(); \ + curtrace = &IntermediatecodeArea->area.t[i]; \ + BlocksContext *c; \ + if (!globalcurblock) c = (*curtrace)->bc; \ + else c = globalcurblock[i]; \ + while (c->next) { \ + if (c->blockty == CONDITIONAL_HEADER && c->thisp == (CELL)curpreg && !strcmp(c->u.kb.exp, EXP)) { break; } \ + c = (BlocksContext*)c->next; \ + } \ + if (!c->next && (c->blockty != CONDITIONAL_HEADER || c->thisp != (CELL)curpreg || strcmp(c->u.kb.exp, EXP)) ) { \ + BlocksContext *t = (BlocksContext*)malloc(sizeof(BlocksContext)); \ + t->blockty = CONDITIONAL_HEADER; \ + t->thisp = (CELL)curpreg; \ + t->next = 0; \ + t->prev = (CELL)c; \ + t->u.kb.exp = (char*)malloc(1024*sizeof(char)); \ + strcpy(t->u.kb.exp, EXP); \ + t->u.kb._if = (BlocksContext*)malloc(sizeof(BlocksContext)); \ + t->u.kb._if->blockty = NONE; \ + t->u.kb._if->thisp = (CELL)curpreg; \ + t->u.kb._if->next = 0; \ + t->u.kb._if->prev = 0; \ + t->u.kb._if->u.xb.header = (CELL)t; \ + t->u.kb._else = (BlocksContext*)malloc(sizeof(BlocksContext)); \ + t->u.kb._else->blockty = NONE; \ + t->u.kb._else->thisp = (CELL)curpreg; \ + t->u.kb._else->next = 0; \ + t->u.kb._else->prev = 0; \ + t->u.kb._else->u.xb.header = (CELL)t; \ + c->next = (CELL)t; \ + c = t->u.kb._if; \ + (*curtrace)->n += 2; \ + } \ + else { \ + c = c->u.kb._if; \ + } \ + temp_globalcurblock[i] = c; \ + COMPLETE_SPENT_PROF_TIME(); \ + } \ + } \ + globalcurblock = temp_globalcurblock; \ + } + +#define EMIT_CONDITIONAL() \ + { \ + BlocksContext *c = (*curtrace)->bc; \ + COUNT i = 0; \ + while (i < ncexp) { \ + while (c->next) { \ + if (c->blockty == CONDITIONAL_HEADER && c->thisp == (CELL)curpreg && !strcmp(c->u.kb.exp, cexp[i])) { break; } \ + c = (BlocksContext*)c->next; \ + } \ + if (!c->next && (c->blockty != CONDITIONAL_HEADER || c->thisp != (CELL)curpreg || strcmp(c->u.kb.exp, cexp[i])) ) { \ + BlocksContext *t = (BlocksContext*)malloc(sizeof(BlocksContext)); \ + t->blockty = CONDITIONAL_HEADER; \ + t->thisp = (CELL)curpreg; \ + t->next = 0; \ + t->prev = (CELL)c; \ + t->u.kb.exp = (char*)malloc(1024*sizeof(char)); \ + strcpy(t->u.kb.exp, cexp[i]); \ + t->u.kb._if = (BlocksContext*)malloc(sizeof(BlocksContext)); \ + t->u.kb._if->blockty = NONE; \ + t->u.kb._if->thisp = (CELL)curpreg; \ + t->u.kb._if->next = 0; \ + t->u.kb._if->prev = 0; \ + t->u.kb._if->u.xb.header = (CELL)t; \ + t->u.kb._else = (BlocksContext*)malloc(sizeof(BlocksContext)); \ + t->u.kb._else->blockty = NONE; \ + t->u.kb._else->thisp = (CELL)curpreg; \ + t->u.kb._else->next = 0; \ + t->u.kb._else->prev = 0; \ + t->u.kb._else->u.xb.header = (CELL)t; \ + c->next = (CELL)t; \ + if (condty[i] == 0) { \ + c = t->u.kb._if; \ + } \ + else { \ + c = t->u.kb._else; \ + } \ + (*curtrace)->n += 2; \ + } \ + else { \ + if (condty[i] == 0) { \ + c = c->u.kb._if; \ + } else { \ + c = c->u.kb._else; \ + } \ + } \ + i++; \ + } \ + curblock = c; \ + } + +#define IF(EXP) EMIT_THIS_BLOCK_AS_IF(EXP); +#define ELSEIF(EXP) EMIT_THIS_BLOCK_AS_ELSEIF(EXP); +#define ELSE() EMIT_THIS_BLOCK_AS_ELSE(); +#define ENDBLOCK() \ + BACK_TO_HEADER(); + +#define SIMPLE_VBLOCK_ND0(block) \ + block == GET_X_VAL_GVALX_NONVAR || \ + block == GET_Y_VAL_GVALY_NONVAR || \ + block == PUT_UNSAFE_PUNSAFE_NONVAR || \ + block == UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR || \ + block == UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR || \ + block == UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR || \ + block == UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR || \ + block == WRITE_X_LOC_W_X_BOUND || \ + block == WRITE_Y_LOC_W_Y_BOUND || \ + block == P_DIF_DIF_NVAR1 || \ + block == P_EQ_P_EQ_NVAR1 || \ + block == P_PLUS_VV_PLUS_VV_NVAR || \ + block == P_PLUS_Y_VV_PLUS_Y_VV_NVAR || \ + block == P_MINUS_VV_MINUS_VV_NVAR || \ + block == P_TIMES_VV_TIMES_VV_NVAR || \ + block == P_DIV_VV_DIV_VV_NVAR || \ + block == P_AND_VV_AND_VV_NVAR || \ + block == P_ARG_VV_TEST_D1 || \ + block == P_ARG_VV_ARG_ARG1_NVAR || \ + block == P_ARG_Y_VV_TEST_D1 || \ + block == P_ARG_Y_VV_ARG_Y_ARG1_NVAR + +#define MULTIPLE_DESTINY_VBLOCK_ND0(block) \ + block == GET_LIST_GLIST_NONVAR || \ + block == GET_ATOM_GATOM_NONVAR || \ + block == GET_STRUCT_GSTRUCT_NONVAR || \ + block == GET_FLOAT_GFLOAT_NONVAR || \ + block == GL_VOID_VARX_GLIST_VOID_VARX_READ || \ + block == GL_VOID_VARY_GLIST_VOID_VARY_READ || \ + block == UNIFY_ATOM_UATOM_NONVAR || \ + block == UNIFY_L_ATOM_ULATOM_NONVAR || \ + block == UNIFY_LIST_READMODE || \ + block == UNIFY_L_LIST_READMODE || \ + block == UNIFY_STRUCT_READMODE || \ + block == UNIFY_L_STRUC_READMODE + +#define MULTIPLE_DESTINY_VBLOCK_ND1(block) \ + block == P_ARG_CV_ARG_ARG2_VC_NVAR + +#define MULTIPLE_DESTINY_VBLOCK_ND0_ND1(block) \ + block == GET_X_VAL_GVALX_NONVAR_NONVAR || \ + block == GET_Y_VAL_GVALY_NONVAR_NONVAR || \ + block == CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT || \ + block == CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT || \ + block == CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT || \ + block == CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT || \ + block == P_DIF_DIF_NVAR1_NVAR2 || \ + block == P_EQ_P_EQ_NVAR1_NVAR2 || \ + block == P_ARG_VV_ARG_ARG2_NVAR || \ + block == P_ARG_Y_VV_ARG_Y_ARG2_NVAR + +#define MULTIPLE_DESTINY_VBLOCK_D0_ND1(block) \ + block == GET_X_VAL_GVALX_VAR_NONVAR || \ + block == GET_Y_VAL_GVALY_VAR_NONVAR || \ + block == P_EQ_P_EQ_VAR1_NVAR2 + +static inline int +found_entry(char* key, yamop* p) { + int i = 0; + while (i < p->u.jhc.jh->tcc.cf->nentries && strcmp(p->u.jhc.jh->tcc.cf->entries[i], key)) { + i++; + } + if (i == p->u.jhc.jh->tcc.cf->nentries) return 0; + return 1; +} + +static inline void +emit_blocks_buf (BlocksContext* mt, short nident, char buf[], yamop* p) { + BlocksContext* prevblock = NULL; + char* tmp = (char*)malloc(2048*sizeof(char)); + int i; + //yamop* lastp = lastop_of(p); + short foundlast = 0; + //CELL oldp; + short first = 1; + char *lastlabel = (char*)malloc(1024*sizeof(char)); + while (mt) { + /*if (foundlast) { + if (oldp != mt->thisp) break; + } + if (mt->thisp == (CELL)lastp) { + foundlast = 1; + oldp = mt->thisp; + }*/ + if (mt->blockty == SIMPLE_ENTRY) { + //if ((YAP_BBs)mt->u.eb.id == IF_NOT_THEN_INSTINIT) { strcpy(buf, ""); break; } + p->u.jhc.jh->tcc.cf->emit = 1; + i = 0; + /*while (i < p->u.jhc.jh->cf->nemited) { + if (!strcmp(p->u.jhc.jh->cf->emited_blocks[i], mt->u.eb.label_entry)) { + p->u.jhc.jh->cf->emit = 0; + break; + } + i += 1; + }*/ + if (p->u.jhc.jh->tcc.cf->emit) { + { + p->u.jhc.jh->tcc.cf->leastonce = 1; + p->u.jhc.jh->tcc.cf->nemited += 1; + p->u.jhc.jh->tcc.cf->emited_blocks = (char**)realloc(p->u.jhc.jh->tcc.cf->emited_blocks, p->u.jhc.jh->tcc.cf->nemited*sizeof(char*)); + p->u.jhc.jh->tcc.cf->emited_blocks[p->u.jhc.jh->tcc.cf->nemited-1] = (char*)malloc(1024*sizeof(char)); + strcpy(p->u.jhc.jh->tcc.cf->emited_blocks[p->u.jhc.jh->tcc.cf->nemited-1], mt->u.eb.label_entry); + } + strcpy(lastlabel, mt->u.eb.label_entry); + if (first) { + sprintf(tmp, "%s:\n{\n", mt->u.eb.label_entry); + first = 0; + } + else sprintf(tmp, "}\n\n%s:\n{\n", mt->u.eb.label_entry); + strcat(buf, tmp); +#if YAP_DBG_PREDS + sprintf(tmp, "print_block((YAP_BBs)%ld, ON_NATIVE);\n", (Int)mt->u.eb.id); + strcat(buf, tmp); +#endif + sprint_block((YAP_BBs)mt->u.eb.id, &tmp); + strcat(buf, tmp); + if (mt->u.eb.label_destiny) { + if (strcmp(mt->u.eb.label_destiny, "")) { + if (found_entry(mt->u.eb.label_destiny, p)) { + sprintf(tmp, "goto %s;\n", mt->u.eb.label_destiny); + } else { + sprintf(tmp, "SUCCESSBACK();\n"); + } + strcat(buf, tmp); + } + } + } + } + else if (mt->blockty == SIMPLE) { + if (p->u.jhc.jh->tcc.cf->emit && (prevblock->u.sb.id != PUT_X_VAL_INSTINIT || mt->u.sb.id != YAAM_DEREF_BODY_D0PT0)) { + Int printif = 0; + if ((YAP_BBs)mt->u.sb.id == YAAM_DEREF_BODY_D0PT0 || (YAP_BBs)mt->u.sb.id == YAAM_DEREF_BODY_D0PT1 || + (YAP_BBs)mt->u.sb.id == YAAM_DEREF_BODY_D0S_SREG || (YAP_BBs)mt->u.sb.id == YAAM_DEREF_BODY_D1PT0 || + (YAP_BBs)mt->u.sb.id == YAAM_DEREF_BODY_D1PT1) { + sprintf(tmp, "/* address = 0x%lX */ ", mt->thisp); + strcat(buf, tmp); + } + if ((YAP_BBs)mt->u.sb.id == CUT_COROUTINING || (YAP_BBs)mt->u.sb.id == CUT_T_COROUTINING || (YAP_BBs)mt->u.sb.id == CUT_E_COROUTINING) { + sprintf(tmp, "#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wunused-value\"\n"); + strcat(buf, tmp); + } +#if YAP_DBG_PREDS + sprintf(tmp, "print_block((YAP_BBs)%ld, ON_NATIVE);\n", (Int)mt->u.sb.id); + strcat(buf, tmp); +#endif + sprint_block((YAP_BBs)mt->u.sb.id, &tmp); + strcat(buf, tmp); + if ((YAP_BBs)mt->u.sb.id == CUT_COROUTINING || (YAP_BBs)mt->u.sb.id == CUT_T_COROUTINING || (YAP_BBs)mt->u.sb.id == CUT_E_COROUTINING) { + sprintf(tmp, "#pragma clang diagnostic pop\n"); + strcat(buf, tmp); + } + if(mt->u.sb.label_destiny) { + if (strcmp(mt->u.sb.label_destiny, "")) { + if (foundlast) { + sprintf(tmp, "SUCCESSBACK();\n"); + strcat(buf, tmp); + } + else { + if (found_entry(mt->u.sb.label_destiny, p)) { + if ( + (YAP_BBs)mt->u.sb.id != NoStackExecute_Exception && + (YAP_BBs)mt->u.sb.id != NoStackDExecute_Exception && + (YAP_BBs)mt->u.sb.id != NoStackCall_Exception && + (YAP_BBs)mt->u.sb.id != NoStackDeallocate_Exception && + (YAP_BBs)mt->u.sb.id != NoStackCut_Exception && + (YAP_BBs)mt->u.sb.id != NoStackCutT_Exception && + (YAP_BBs)mt->u.sb.id != NoStackCutE_Exception && + (YAP_BBs)mt->u.sb.id != NoStackCommitX_Exception && + (YAP_BBs)mt->u.sb.id != NoStackCommitY_Exception && + (YAP_BBs)mt->u.sb.id != NoStackEither_Exception && + (YAP_BBs)mt->u.sb.id != NoStackPExecute_Exception && + (YAP_BBs)mt->u.sb.id != NoStackPExecute2_Exception && + (YAP_BBs)mt->u.sb.id != NoStackPTExecute_Exception) + { + sprintf(tmp, "goto %s;\n", mt->u.sb.label_destiny); + strcat(buf, tmp); + } + } else { + sprintf(tmp, "SUCCESSBACK();\n"); + strcat(buf, tmp); + } + } + } + } + if (printif) { + sprintf(tmp, "}\nelse SUCCESSBACK();\n"); + strcat(buf, tmp); + } + //if (mt->u.sb.id == DEXECUTE_END_END) break; + } + } + else if (mt->blockty == CONDITIONAL_HEADER) { + if (p->u.jhc.jh->tcc.cf->emit) { + if (mt->u.kb._if->next && !(mt->u.kb._else->next)) + emit_blocks_buf(mt->u.kb._if, nident+1, buf, p); + else if (!(mt->u.kb._if->next) && mt->u.kb._else->next) + emit_blocks_buf(mt->u.kb._else, nident+1, buf, p); + else if (mt->u.kb._if->next && mt->u.kb._else->next) { + sprintf(tmp, "if (%s) {\n", mt->u.kb.exp); + strcat(buf, tmp); + emit_blocks_buf(mt->u.kb._if, nident+1, buf, p); + if (p->u.jhc.jh->tcc.cf->printlabel) { + sprintf(tmp, "}\nelse {\n%s:;\n", p->u.jhc.jh->tcc.cf->clabel); + p->u.jhc.jh->tcc.cf->printlabel = 0; + } + else { + sprintf(tmp, "}\nelse {\n"); + } + strcat(buf, tmp); + emit_blocks_buf(mt->u.kb._else, nident+1, buf, p); + sprintf(tmp, "}\n"); + strcat(buf, tmp); + } + } + } + else if (mt->blockty == MULTIPLE_DESTINY) { + Int printif = 0; + if (p->u.jhc.jh->tcc.cf->emit) { +#if YAP_DBG_PREDS + sprintf(tmp, "print_block((YAP_BBs)%ld, ON_NATIVE);\n", (Int)mt->u.mdb.id); + strcat(buf, tmp); +#endif + sprint_block((YAP_BBs)mt->u.mdb.id, &tmp); + strcat(buf, tmp); + if(mt->u.mdb.nfaillabels > 0) { + sprintf(tmp, "if (FAILED) {\n"); + strcat(buf, tmp); + for (i = 0; i < mt->u.mdb.nfaillabels; i++) { + sprintf(tmp, " if ((UInt)(*_PREG) == 0x%lX) goto %s;\n", + mt->u.mdb.faildestiny.p[i], mt->u.mdb.faildestiny.labels[i]); + strcat(buf, tmp); + } + sprintf(tmp, "}\n"); + strcat(buf, tmp); + } + if(mt->u.mdb.ndest > 0) { + /*if ((YAP_BBs)mt->u.mdb.id == DEXECUTE_END_END && (CELL)lastp == mt->thisp) { + sprintf(tmp, "SUCCESSBACK();\n"); + strcat(buf, tmp); + break; + } + else {*/ + //if (found_entry(mt->u.mdb.destiny.labels[0]), p) { + sprintf(tmp, "if ((UInt)(*_PREG) == 0x%lX) goto %s;\n", mt->u.mdb.destiny.p[0], mt->u.mdb.destiny.labels[0]); + //} else { + //sprintf(tmp, "if ((UInt)(*_PREG) == 0x%lX) {\n SUCCESSBACK();\n}\n", mt->u.mdb.destiny.p[0]); + //} + strcat(buf, tmp); + //if ((YAP_BBs)mt->u.mdb.id == PROCCEED_END || (YAP_BBs)mt->u.mdb.id == DEXECUTE_END_END) { + int i; + for (i = 1; i < mt->u.mdb.ndest; i++) { + if (found_entry(mt->u.mdb.destiny.labels[i], p)) { + //if (strcmp(lastlabel, mt->u.mdb.destiny.labels[i])) { + sprintf(tmp, "if ((UInt)(*_PREG) == 0x%lX) goto %s;\n", + mt->u.mdb.destiny.p[i], mt->u.mdb.destiny.labels[i]); + //} + } else { + sprintf(tmp, "if ((UInt)(*_PREG) == 0x%lX) SUCCESSBACK();\n", mt->u.mdb.destiny.p[i]); + } + strcat(buf, tmp); + } + //} + //int k = 0; + //while (k < mt->u.mdb.ndest && Yap_op_from_opcode(((yamop*)(mt->u.mdb.destiny.p[k]))->opc) != _jit_handler) { k++; } + //if (k == mt->u.mdb.ndest) { + sprintf(tmp, "SUCCESSBACK();\n"); + //} + //else { + //sprintf(tmp, "else {\n SUCCESS();\n}\n"); + //} + strcat(buf, tmp); + //} + } + else { + sprintf(tmp, "SUCCESSBACK();\n\n"); + strcat(buf, tmp); + } + if (printif) { + sprintf(tmp, "}\nelse SUCCESSBACK();\n"); + strcat(buf, tmp); + } + } + } + prevblock = mt; + mt = (BlocksContext*)mt->next; + } + free(lastlabel); + free(tmp); +} + +static inline void +fill_entries(BlocksContext* mt, yamop** p) { + while (mt) { + if (mt->blockty == SIMPLE_ENTRY) { + (*p)->u.jhc.jh->tcc.cf->nentries += 1; + (*p)->u.jhc.jh->tcc.cf->entries = (char**)realloc((*p)->u.jhc.jh->tcc.cf->entries, (*p)->u.jhc.jh->tcc.cf->nentries*sizeof(char*)); + (*p)->u.jhc.jh->tcc.cf->entries[(*p)->u.jhc.jh->tcc.cf->nentries-1] = (char*)malloc(1024*sizeof(char)); + strcpy((*p)->u.jhc.jh->tcc.cf->entries[(*p)->u.jhc.jh->tcc.cf->nentries-1], mt->u.eb.label_entry); + } + mt = (BlocksContext*)mt->next; + } +} + +#if YAP_STAT_PREDS +#if YAP_DBG_PREDS +const char* cfile_header_for_trace = "#include \n#include \n#include \n#include \n#include \n\nextern CELL nnexec;\nextern int IUnify_complex(CELL*, CELL*, CELL*);\nextern int iequ_complex(CELL*, CELL*, CELL*);\nextern void print_preg(yamop*);\nextern NativeContext* NativeArea;\nextern yamop* HREADPREG;\nextern CELL BLOCK;\nextern CELL BLOCKADDRESS;\nextern CELL FAILED;\n\nvoid* clause(yamop**, yamop**, CELL**, void*[], void*[]);\n\nvoid* clause(yamop** _PREG, yamop** _CPREG, CELL** _SREG, void* external_labels[], void* OpAddress[]) {\nNativeArea->runs[(*_PREG)->u.jhc.jh->caa.naddress] += 1;\n\n\0"; +#else /* YAP_DBG_PREDS */ +const char* cfile_header_for_trace = "#include \n#include \n#include \n#include \n#include \n\nextern CELL nnexec;\nextern int IUnify_complex(CELL*, CELL*, CELL*);\nextern int iequ_complex(CELL*, CELL*, CELL*);\nextern void print_preg(yamop*);\nextern NativeContext* NativeArea;\nextern yamop* HREADPREG;\nextern CELL BLOCK;\nextern CELL BLOCKADDRESS;\nextern CELL FAILED;\n\nvoid* clause(yamop**, yamop**, CELL**, void*[], void*[]);\n\nvoid* clause(yamop** _PREG, yamop** _CPREG, CELL** _SREG, void* external_labels[], void* OpAddress[]) {\nNativeArea->runs[(*_PREG)->u.jhc.jh->caa.naddress] += 1;\n\n\0"; +#endif /* YAP_DBG_PREDS */ +#else /* YAP_STAT_PREDS */ +#if YAP_DBG_PREDS +const char* cfile_header_for_trace = "#include \n#include \n#include \n#include \n#include \n\nextern CELL nnexec;\nextern int IUnify_complex(CELL*, CELL*, CELL*);\nextern int iequ_complex(CELL*, CELL*, CELL*);\nextern void print_preg(yamop*);\nextern NativeContext* NativeArea;\nextern yamop* HREADPREG;\nextern CELL BLOCK;\nextern CELL BLOCKADDRESS;\nextern CELL FAILED;\n\nvoid* clause(yamop**, yamop**, CELL**, void*[], void*[]);\n\nvoid* clause(yamop** _PREG, yamop** _CPREG, CELL** _SREG, void* external_labels[], void* OpAddress[]) {\n\n\0"; +#else /* YAP_DBG_PREDS */ +const char* cfile_header_for_trace = "#include \n#include \n#include \n#include \n#include \n\nextern CELL nnexec;\nextern int IUnify_complex(CELL*, CELL*, CELL*);\nextern int iequ_complex(CELL*, CELL*, CELL*);\nextern void print_preg(yamop*);\nextern NativeContext* NativeArea;\nextern yamop* HREADPREG;\nextern CELL BLOCK;\nextern CELL BLOCKADDRESS;\nextern CELL FAILED;\n\nvoid* clause(yamop**, yamop**, CELL**, void*[], void*[]);\n\nvoid* clause(yamop** _PREG, yamop** _CPREG, CELL** _SREG, void* external_labels[], void* OpAddress[]) {\n\n\0"; +#endif /* YAP_DBG_PREDS */ +#endif /* YAP_STAT_PREDS */ +const char* cfile_end_for_trace = " | clang -O0 -DCUT_C=1 -DCOROUTINING=1 -DRATIONAL_TREES=1 -DDEBUG=1 -DDEPTH_LIMIT=1 -DTABLING=1 -DHAVE_CONFIG_H -D_YAP_NOT_INSTALLED_=1 -D_NATIVE=1 -I. -I./H -I./include -I./os -I./OPTYap -I./BEAM -I./MYDDAS -I./HPP -xc -c - -o - -emit-llvm\0"; +/*const char* cfile_end = " | clang -O0 -DCUT_C=1 -DCOROUTINING=1 -DRATIONAL_TREES=1 -DDEBUG=1 -DDEPTH_LIMIT=1 -DTABLING=1 -DHAVE_CONFIG_H -D_YAP_NOT_INSTALLED_=1 -D_NATIVE=1 -I. -I./H -I./include -I./os -I./OPTYap -I./BEAM -I./MYDDAS -I./HPP -emit-llvm -xc -c - -o\0";*/ + +static inline Int +emit_intermediate_for_trace (TraceContext *tt, CELL *tsize, char **cmd, yamop* p) { + int i; + if (tt) { + p->u.jhc.jh->tcc.cf->entries = NULL; + p->u.jhc.jh->tcc.cf->nentries = 0; + fill_entries(tt->bc, &p); + p->u.jhc.jh->tcc.cf->clabel = (char*)malloc(1024*sizeof(char)); + p->u.jhc.jh->tcc.cf->labelidx = 0; + p->u.jhc.jh->tcc.cf->printlabel = 0; + p->u.jhc.jh->tcc.cf->emited_blocks = NULL; + p->u.jhc.jh->tcc.cf->nemited = 0; + char *buf = (char*)malloc(0x100000*sizeof(char)); + strcpy(buf, ""); + emit_blocks_buf(tt->bc, 0, buf, p); + { + long int tracesize = strlen(cfile_header_for_trace) + strlen(buf); + if (tracesize > 0x1FBD0 || *tsize == tracesize || ((long int)(*tsize * 0.002 + *tsize)) > tracesize) { + for (i = 0; i < p->u.jhc.jh->tcc.cf->nemited; i++) + free(p->u.jhc.jh->tcc.cf->emited_blocks[i]); + free(p->u.jhc.jh->tcc.cf->emited_blocks); + free(buf); + free(p->u.jhc.jh->tcc.cf->clabel); + int i; + for (i = 0; i < p->u.jhc.jh->tcc.cf->nentries; i++) + free(p->u.jhc.jh->tcc.cf->entries[i]); + free(p->u.jhc.jh->tcc.cf->entries); + return 0; + } + *tsize = tracesize; + } + *cmd = (char*)malloc(0x100000*sizeof(char)); + if (strcmp(buf, "")) { + strcpy(*cmd, cfile_header_for_trace); + strcat(*cmd, buf); + strcat(*cmd, "}\n\n}"); + } else { strcpy(*cmd, ""); } + for (i = 0; i < p->u.jhc.jh->tcc.cf->nemited; i++) + free(p->u.jhc.jh->tcc.cf->emited_blocks[i]); + free(p->u.jhc.jh->tcc.cf->emited_blocks); +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.pprint_intermediate.print_to_std) { + if (strcmp((char*)ExpEnv.debug_struc.pprint_intermediate.std_name, "STDOUT") == 0) + fprintf(stdout, "%s%s}\n\n}", cfile_header_for_trace, buf); + else if (strcmp((char*)ExpEnv.debug_struc.pprint_intermediate.std_name, "STDERR") == 0) + fprintf(stderr, "%s%s}\n\n}", cfile_header_for_trace, buf); + } + if (ExpEnv.debug_struc.pprint_intermediate.print_to_file) { + char filename[1024]; + sprintf(filename, "%s%ld.c", (char*)ExpEnv.debug_struc.pprint_intermediate.file_name, p->u.jhc.jh->caa.naddress); + FILE *out = fopen(filename, "w"); + fprintf(out, "%s%s}\n\n}", cfile_header_for_trace, buf); + fclose(out); + } +#endif +/* + This block print the trace. + + char filename[1024]; + sprintf(filename, "trace%ld.c", global); + FILE *out = fopen(filename, "w"); + fprintf(out, "%s%s}\n\n}", cfile_header_for_trace, buf); + fclose(out); +*/ + free(buf); + free(p->u.jhc.jh->tcc.cf->clabel); + int i; + for (i = 0; i < p->u.jhc.jh->tcc.cf->nentries; i++) + free(p->u.jhc.jh->tcc.cf->entries[i]); + free(p->u.jhc.jh->tcc.cf->entries); + return strlen(*cmd); + } + return 0; +} + +void emit_intermediate_for_trace_dbg (TraceContext*, yamop*); + +void +emit_intermediate_for_trace_dbg (TraceContext *tt, yamop* p) { + char *buf; + CELL x; + emit_intermediate_for_trace(tt, &x, &buf, p); + fprintf(stdout, "%s%s}\n\n}", cfile_header_for_trace, buf); +} + +#include "nextof.hpp" + +const char* cfile_header_for_clause = "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nextern CELL nnexec;\nextern int IUnify_complex(CELL*, CELL*, CELL*);\nextern int iequ_complex(CELL*, CELL*, CELL*);\nextern void print_preg(yamop*);\nextern NativeContext* NativeArea;\nextern yamop* HREADPREG;\nextern CELL BLOCK;\nextern CELL BLOCKADDRESS;\nextern CELL FAILED;\n\nvoid* clause(yamop**, yamop**, CELL**, void*[], void*[]);\n\nvoid* clause(yamop** _PREG, yamop** _CPREG, CELL** _SREG, void* external_labels[], void* OpAddress[]) {\n\0"; +const char* cfile_end_for_clause = " | clang -O0 -DCUT_C=1 -DCOROUTINING=1 -DRATIONAL_TREES=1 -DDEBUG=1 -DDEPTH_LIMIT=1 -DTABLING=1 -DHAVE_CONFIG_H -D_YAP_NOT_INSTALLED_=1 -D_NATIVE=1 -I. -I./H -I./include -I./os -I./OPTYap -I./BEAM -I./MYDDAS -I./HPP -xc -c - -o - -emit-llvm\0"; +/*const char* cfile_end = " | clang -O0 -DCUT_C=1 -DCOROUTINING=1 -DRATIONAL_TREES=1 -DDEBUG=1 -DDEPTH_LIMIT=1 -DTABLING=1 -DHAVE_CONFIG_H -D_YAP_NOT_INSTALLED_=1 -D_NATIVE=1 -I. -I./H -I./include -I./os -I./OPTYap -I./BEAM -I./MYDDAS -I./HPP -emit-llvm -xc -c - -o\0";*/ + +#define ENTRY_HAS_WRITED_CPART(entry) \ + entry == _unify_x_var || \ + entry == _unify_l_x_var || \ + entry == _unify_x_var2 || \ + entry == _unify_l_x_var2 || \ + entry == _unify_y_var || \ + entry == _unify_l_y_var || \ + entry == _unify_x_val || \ + entry == _unify_l_x_val || \ + entry == _unify_x_loc || \ + entry == _unify_l_x_loc || \ + entry == _unify_atom || \ + entry == _unify_l_atom || \ + entry == _unify_void || \ + entry == _unify_n_voids || \ + entry == _unify_l_n_voids || \ + entry == _unify_l_list || \ + entry == _unify_struct || \ + entry == _unify_l_struc || \ + entry == _unify_l_float || \ + entry == _save_pair_x + +#define SET_ADDRESS_R() \ + strcat(buf, "static void *NOp_Address_R[] = { "); \ + for (i = 0; i < nentries-1; i++) { \ + strcat(buf, "&&"); \ + sprint_op(tmpbuf, "lbl", entries[i], ""); \ + strcat(buf, tmpbuf); \ + strcat(buf, ", "); \ + } \ + strcat(buf, "&&"); \ + sprint_op(tmpbuf, "lbl", entries[nentries-1], ""); \ + strcat(buf, tmpbuf); \ + strcat(buf, " };\n\n"); + +#define SET_ADDRESS_W() \ + strcat(buf, "static void *NOp_Address_W[] = { "); \ + for (i = 0; i < nentries-1; i++) { \ + strcat(buf, "&&"); \ + sprint_op(tmpbuf, "lbl", entries[i], "_write"); \ + strcat(buf, tmpbuf); \ + strcat(buf, ", "); \ + } \ + strcat(buf, "&&"); \ + sprint_op(tmpbuf, "lbl", entries[nentries-1], "_write"); \ + strcat(buf, tmpbuf); \ + strcat(buf, " };\n\n"); + +static inline Int +fe(op_numbers k, op_numbers* e, COUNT n) { + int i = 0; + while (i < n && e[i] != k) i++; + if (i == n) return -1; + return i; +} + +static inline Int +emit_intermediate_for_clause (yamop *p, char **cmd) { + yamop *tmp = p; + yamop *next; + op_numbers* entries = NULL; + COUNT i, nentries = 0; + while (1) { + op_numbers op = Yap_op_from_opcode(p->opc); + if (fe(op, entries, nentries) == -1) { + nentries += 1; + entries = (op_numbers*)realloc(entries, nentries*sizeof(op_numbers)); + entries[nentries-1] = op; + } + if (op == _execute || op == _dexecute || op == _procceed || op == _fcall || op == _call || op == _execute_cpred) break; + if (op == _either) { + NextOf(&p); + } + else if (op == _cut || op == _cut_t || op == _cut_e || op == _commit_b_x || op == _commit_b_y || op == _p_functor) { + NextOf(&p); + NextOf(&p); + } + NextOf(&p); + } + p = tmp; + while (1) { + next = p; + if (Yap_op_from_opcode(next->opc) == _either) { + NextOf(&next); + } + else if (Yap_op_from_opcode(next->opc) == _cut || Yap_op_from_opcode(next->opc) == _cut_t || Yap_op_from_opcode(next->opc) == _cut_e || Yap_op_from_opcode(next->opc) == _commit_b_x || Yap_op_from_opcode(next->opc) == _commit_b_y || Yap_op_from_opcode(next->opc) == _p_functor) { + NextOf(&next); + NextOf(&next); + } + NextOf(&next); + if (Yap_op_from_opcode(p->opc) == _execute || Yap_op_from_opcode(p->opc) == _dexecute || Yap_op_from_opcode(p->opc) == _procceed || Yap_op_from_opcode(p->opc) == _fcall || Yap_op_from_opcode(p->opc) == _call || Yap_op_from_opcode(p->opc) == _execute_cpred) { + p->next_native_r = p->next_native_w = -1; + break; + } + else { + op_numbers op = Yap_op_from_opcode(next->opc); + p->next_native_r = p->next_native_w = fe(op, entries, nentries); + } + if (Yap_op_from_opcode(p->opc) == _either) { + NextOf(&p); + } + else if (Yap_op_from_opcode(p->opc) == _cut || Yap_op_from_opcode(p->opc) == _cut_t || Yap_op_from_opcode(p->opc) == _cut_e || Yap_op_from_opcode(p->opc) == _commit_b_x || Yap_op_from_opcode(p->opc) == _commit_b_y || Yap_op_from_opcode(p->opc) == _p_functor) { + NextOf(&p); + NextOf(&p); + } + NextOf(&p); + } + /*p = tmp; + while(1){ + op_numbers op = Yap_op_from_opcode(p->opc); + print_op("", op, " -- "); + printf("%ld\n", p->next_native_r); + if (op == _execute || op == _dexecute || op == _procceed || op == _fcall || op == _call || op == _execute_cpred) break; + if (op == _either) { + NextOf(&p); + } + else if (op == _cut || op == _cut_t || op == _cut_e || op == _commit_b_x || op == _commit_b_y || op == _p_functor) { + NextOf(&p); + NextOf(&p); + } + NextOf(&p); + }*/ + + char buf[2097152]; + char tmpbuf[1024]; + strcpy(buf, ""); + SET_ADDRESS_R(); + SET_ADDRESS_W(); + strcat(buf, "\n"); + + for (i = 0; i < nentries; i++) { + /* read part */ + sprint_op(tmpbuf, "lbl", entries[i], ""); + strcat(buf, tmpbuf); + strcat(buf, ":\n{\n"); + sprint_op(tmpbuf, " CELL idx = (*_PREG)->next_native_r;\n ", entries[i], "_instinit;\n"); + strcat(buf, tmpbuf); + //sprintf(tmpbuf, " if (idx != -1) goto *NOp_Address[idx];\n else BACK();\n"); + //strcat(buf, tmpbuf); + strcat(buf, "}\n\n"); + + /* written part */ + if (ENTRY_HAS_WRITED_CPART(entries[i])) { + sprint_op(tmpbuf, "lbl", entries[i], "_write"); + strcat(buf, tmpbuf); + strcat(buf, ":\n{\n"); + /*{ + strcpy(tmplbl, tmpbuf); + sprintf(tmpbuf, " printf(\\\"%s!! -- \\\");\n", tmplbl); + strcat(buf, tmpbuf); + sprintf(tmpbuf, " print_op(\\\"\\\", Yap_op_from_opcode((*_PREG)->opc), \\\"!!\\\n\\\");\n"); + strcat(buf, tmpbuf); + }*/ + sprint_op(tmpbuf, " CELL idx = (*_PREG)->next_native_w;\n ", entries[i], "_write_instinit;\n"); + strcat(buf, tmpbuf); + //sprintf(tmpbuf, " if (idx != -1) goto *NOp_Address[idx];\n else BACK();\n"); + //strcat(buf, tmpbuf); + strcat(buf, "}\n\n"); + } + else { + sprint_op(tmpbuf, "lbl", entries[i], "_write:;\n\n"); + strcat(buf, tmpbuf); + } + } + + *cmd = (char*)malloc(2097152*sizeof(char)); + //strcpy(*cmd, "echo \""); + strcpy(*cmd, cfile_header_for_clause); + strcat(*cmd, buf); + strcat(*cmd, "BACK();\n}"); + //strcat(*cmd, cfile_end_for_clause); + +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.pprint_intermediate.print_to_std) { + if (strcmp((char*)ExpEnv.debug_struc.pprint_intermediate.std_name, "STDOUT") == 0) + fprintf(stdout, "%s%s}\n\n}", cfile_header_for_clause, buf); + else if (strcmp((char*)ExpEnv.debug_struc.pprint_intermediate.std_name, "STDERR") == 0) + fprintf(stderr, "%s%s}\n\n}", cfile_header_for_clause, buf); + } + if (ExpEnv.debug_struc.pprint_intermediate.print_to_file) { + char filename[1024]; + sprintf(filename, "%s%ld.c", (char*)ExpEnv.debug_struc.pprint_intermediate.file_name, p->u.jhc.jh->caa.naddress); + FILE *out = fopen(filename, "w"); + if (out) { + fprintf(out, "%s%s}\n\n}", cfile_header_for_trace, buf); + fclose(out); + free(*cmd); + return 1; + } + free(*cmd); + return 0; + } +#endif +} + +static inline void* +recompile(void *pt) +{ + yamop* p = (yamop*)pt; + +#if YAP_STAT_PREDS + struct rusage rustart, ruend; + getrusage(RUSAGE_SELF, &rustart); +#endif + Int v = emit_intermediate_for_trace(IntermediatecodeArea->area.t[p->u.jhc.jh->caa.taddress], &(IntermediatecodeArea->area.t[p->u.jhc.jh->caa.taddress]->tracesize), &(p->u.jhc.jh->tcc.cmd), p); + if (v) { +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.pprint_me.at_recompilation != 0 && ExpEnv.debug_struc.pprint_me.at_recompilation != 0x1) { + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.at_recompilation); + } +#endif +#if YAP_STAT_PREDS + NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress] += 1; + NativeArea->area.native_size_bytes[p->u.jhc.jh->caa.naddress] = (CELL*)realloc(NativeArea->area.native_size_bytes[p->u.jhc.jh->caa.naddress], NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]*sizeof(CELL)); + NativeArea->area.trace_size_bytes[p->u.jhc.jh->caa.naddress] = (CELL*)realloc(NativeArea->area.trace_size_bytes[p->u.jhc.jh->caa.naddress], NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]*sizeof(CELL)); + NativeArea->area.trace_size_bytes[p->u.jhc.jh->caa.naddress][NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]-1] = v; +#endif + NativeArea->area.p[p->u.jhc.jh->caa.naddress] = call_JIT_Compiler(J, p); + IntermediatecodeArea->area.isactive[p->u.jhc.jh->caa.taddress] = 0; +#if YAP_STAT_PREDS + getrusage(RUSAGE_SELF, &ruend); + NativeArea->area.compilation_time[p->u.jhc.jh->caa.naddress] = (double*)realloc(NativeArea->area.compilation_time[p->u.jhc.jh->caa.naddress], NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]*sizeof(double)); + NativeArea->area.compilation_time[p->u.jhc.jh->caa.naddress][NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]-1] = + (((double)ruend.ru_utime.tv_sec - (double)rustart.ru_utime.tv_sec) + ((double)ruend.ru_utime.tv_usec - (double)rustart.ru_utime.tv_usec) / 1000000.0); +#endif + } + return NULL; +} + +static inline void* +compile(void *pt) +{ + yamop* p = (yamop*)pt; + +#if YAP_STAT_PREDS + struct rusage rustart, ruend; + getrusage(RUSAGE_SELF, &rustart); +#endif + p->u.jhc.jh->caa.naddress = NativeArea->n; + Int v = emit_intermediate_for_trace(IntermediatecodeArea->area.t[p->u.jhc.jh->caa.taddress], &(IntermediatecodeArea->area.t[p->u.jhc.jh->caa.taddress]->tracesize), &(p->u.jhc.jh->tcc.cmd), p); + if (v) { +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.pprint_me.at_compilation != 0 && ExpEnv.debug_struc.pprint_me.at_compilation != 0x1) { + fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); + fprintf(stderr, "%s", (char*)ExpEnv.debug_struc.pprint_me.at_compilation); + } +#endif + NativeArea->area.p = (void**)realloc(NativeArea->area.p, (NativeArea->n+1)*sizeof(void*)); + NativeArea->area.ok = (COUNT*)realloc(NativeArea->area.ok, (NativeArea->n+1)*sizeof(COUNT)); + NativeArea->area.pc = (CELL*)realloc(NativeArea->area.pc, (NativeArea->n+1)*sizeof(CELL)); +#if YAP_STAT_PREDS + NativeArea->area.nrecomp = (COUNT*)realloc(NativeArea->area.nrecomp, (NativeArea->n+1)*sizeof(COUNT)); + NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress] = 1; + NativeArea->area.compilation_time = (double**)realloc(NativeArea->area.compilation_time, (NativeArea->n+1)*sizeof(double*)); + NativeArea->area.native_size_bytes = (CELL**)realloc(NativeArea->area.native_size_bytes, (NativeArea->n+1)*sizeof(CELL*)); + NativeArea->area.native_size_bytes[p->u.jhc.jh->caa.naddress] = (CELL*)malloc(NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]*sizeof(CELL)); + NativeArea->area.trace_size_bytes = (CELL**)realloc(NativeArea->area.trace_size_bytes, (NativeArea->n+1)*sizeof(CELL*)); + NativeArea->area.trace_size_bytes[p->u.jhc.jh->caa.naddress] = (CELL*)malloc(NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]*sizeof(CELL)); + NativeArea->area.trace_size_bytes[p->u.jhc.jh->caa.naddress][NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]-1] = v; + NativeArea->runs = (COUNT*)realloc(NativeArea->runs, (NativeArea->n+1)*sizeof(COUNT)); + NativeArea->t_runs = (double*)realloc(NativeArea->t_runs, (NativeArea->n+1)*sizeof(double)); + NativeArea->success = (COUNT*)realloc(NativeArea->success, (NativeArea->n+1)*sizeof(COUNT)); +#endif + NativeArea->area.ok[p->u.jhc.jh->caa.naddress] = 0; +#if YAP_STAT_PREDS + NativeArea->success[p->u.jhc.jh->caa.naddress] = 0; + NativeArea->runs[p->u.jhc.jh->caa.naddress] = 0; + NativeArea->t_runs[p->u.jhc.jh->caa.naddress] = 0.0; +#endif + NativeArea->n += 1; + NativeArea->area.p[p->u.jhc.jh->caa.naddress] = call_JIT_Compiler(J, p); + NativeArea->area.ok[p->u.jhc.jh->caa.naddress] = 1; + NativeArea->area.pc[p->u.jhc.jh->caa.naddress] = (CELL)p; +#if YAP_STAT_PREDS + getrusage(RUSAGE_SELF, &ruend); + NativeArea->area.compilation_time[p->u.jhc.jh->caa.naddress] = (double*)malloc(NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]*sizeof(double)); + NativeArea->area.compilation_time[p->u.jhc.jh->caa.naddress][NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]-1] = + (((double)ruend.ru_utime.tv_sec - (double)rustart.ru_utime.tv_sec) + ((double)ruend.ru_utime.tv_usec - (double)rustart.ru_utime.tv_usec) / 1000000.0); +#endif + } + else { + p->u.jhc.jh->caa.naddress = -1; + } + IntermediatecodeArea->area.isactive[p->u.jhc.jh->caa.taddress] = 0; + return NULL; +} + +#endif /*_NATIVE */ diff --git a/JIT/HPP/yaam_misc.h b/JIT/HPP/yaam_misc.h new file mode 100644 index 000000000..b1920371b --- /dev/null +++ b/JIT/HPP/yaam_misc.h @@ -0,0 +1,1262 @@ +#if PARALLEL_YAP +#define LUCK_LU_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + if (PP) { \ + GONext(); \ + } \ + else { \ + PP = (*_PREG)->u.p.p; \ + PELOCK(3, PP); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); \ + } +#else /* PARALLEL_YAP */ +#define LUCK_LU_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); +#endif /* PARALLEL_YAP */ + +#define LOCK_LU_END \ + BLOCK = (CELL)LOCK_LU_END; + +#define UNLOCK_LU_INSTINIT + +#if defined(YAPOR) || defined(THREADS) +#define UNLOCK_LU_YAPOR_THREADS \ + UNLOCKPE(1,PP); \ + PP = NULL; +#endif + +#define UNLOCK_LU_END \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); + +#define ALLOC_FOR_LOGICAL_PRED_INSTINIT + +#if MULTIPLE_STACKS +#define ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS \ + LogUpdClause *cl = (*_PREG)->u.L.ClBase; +#if PARALLEL_YAP +#define ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL \ + PredEntry *ap = cl->ClPred; +#endif +#define ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(2,ap); \ + PP = NULL; +#else +#define ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT \ + LogUpdClause *cl = (LogUpdClause *)(*_PREG)->u.L.ClBase; + +#define ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } +#endif + +#define ALLOC_FOR_LOGICAL_PRED_END \ + (*_PREG) = NEXTOP((*_PREG), L); \ + JMPNext(); + +/** COPY_IDB_TERM_INSTINIT was changed: no error messages **/ +#if defined(YAPOR) || defined(THREADS) +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#else /* defined(YAPOR) || defined(THREADS) */ +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define COPY_IDB_TERM_END \ + BLOCK = (CELL)COPY_IDB_TERM_END; + +#if defined(YAPOR) || defined(THREADS) +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define UNIFY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(10,PP); \ + PP = NULL; \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define UNIFY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + JMPNext(); +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define UNIFY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define UNIFY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + JMPNext(); +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#else /* defined(YAPOR) || defined(THREADS) */ +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define UNIFY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + FAIL(); \ + } \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(10,PP); \ + PP = NULL; \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define UNIFY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + FAIL(); \ + } \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(10,PP); \ + PP = NULL; \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + JMPNext(); +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define UNIFY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define UNIFY_IDB_TERM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + JMPNext(); +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define UNIFY_IDB_TERM_END \ + BLOCK = (CELL)UNIFY_IDB_TERM_END; + +#ifdef DEPTH_LIMIT +#define ENSURE_SPACE_INSTINIT \ + { \ + Int sz = (*_PREG)->u.Osbpa.i; \ + UInt arity = (*_PREG)->u.Osbpa.p->ArityOfPE; \ + if (Unsigned(HR) + sz > Unsigned(YREG)-CreepFlag) { \ + YENV[E_CP] = (CELL) (*_C(*_PREG)); \ + YENV[E_E] = (CELL) ENV; \ + YENV[E_DEPTH] = DEPTH; \ + SET_ASP(YREG, (*_PREG)->u.Osbpa.s); \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); \ + saveregs(); \ + setregs(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); \ + } \ + } \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define ENSURE_SPACE_INSTINIT \ + { \ + Int sz = (*_PREG)->u.Osbpa.i; \ + UInt arity = (*_PREG)->u.Osbpa.p->ArityOfPE; \ + if (Unsigned(HR) + sz > Unsigned(YREG)-CreepFlag) { \ + YENV[E_CP] = (CELL) (*_C(*_PREG)); \ + YENV[E_E] = (CELL) ENV; \ + SET_ASP(YREG, (*_PREG)->u.Osbpa.s); \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); \ + saveregs(); \ + setregs(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); \ + } \ + } \ + JMPNext(); +#endif /* DEPTH_LIMIT */ + +#define ENSURE_SPACE_END + +#define JUMP_INSTINIT \ + (*_PREG) = (*_PREG)->u.l.l; \ + JMPNext(); + +#define MOVE_BACK_INSTINIT \ + (*_PREG) = (yamop *)(((char *)(*_PREG))-(Int)(NEXTOP((yamop *)NULL,Osbpp))); \ + JMPNext(); + +#define SKIP_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG),l); \ + JMPNext(); + +#define EITHER_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define EITHER_LOW_LEVEL_TRACER \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); +#endif + +#define EITHER_POST_COROUTINING \ + register CELL d0; \ + register choiceptr pt1; \ + d0 = (*_PREG)->u.Osblp.s; \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define EITHER_FROZEN_YSBA \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; +#else /* YAPOR_SBA */ +#define EITHER_FROZEN_YSBA \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define EITHER_FROZEN_YSBA \ + if (pt1 > B) \ + pt1 = B; +#endif /* FROZEN_STACKS */ + +#define EITHER_POST_FROZEN_YSBA \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); + +#ifdef YAPOR +#define EITHER_YAPOR \ + SCH_set_load(pt1); +#endif + +#define EITHER_END \ + SET_BB(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONext(); + +#define OR_ELSE_INSTINIT \ + HR = HRBREG = PROTECT_FROZEN_H(B); \ + ENV = B->cp_env; \ + B->cp_cp = (*_PREG); + +#ifdef DEPTH_LIMIT +#define OR_ELSE_DEPTH \ + DEPTH = B->cp_depth; +#endif + +#define OR_ELSE_POST_DEPTH \ + SET_BB(PROTECT_FROZEN_B(B)); + +#ifdef YAPOR +#define OR_ELSE_YAPOR \ + SCH_new_alternative((*_PREG), (*_PREG)->u.Osblp.l); +#endif + +#define OR_ELSE_END \ + B->cp_ap = (*_PREG)->u.Osblp.l; \ + (*_PREG) = NEXTOP((*_PREG), Osblp); \ + YREG = (CELL *) B->cp_a1; \ + GONext(); + +#define OR_LAST_INSTINIT \ + register choiceptr pt0; \ + pt0 = B; + +#ifdef YAPOR +#define OR_LAST_IFOK_INIT \ + H = HRBREG = PROTECT_FROZEN_H(pt0); \ + YREG = (CELL *) pt0->cp_a1; \ + ENV = pt0->cp_env; + +#ifdef DEPTH_LIMIT +#define OR_LAST_IFOK_DEPTH \ + DEPTH = pt0->cp_depth; +#endif + +#define OR_LAST_IFOK_END \ + SCH_new_alternative((*_PREG), NULL); +#endif + +#define OR_LAST_NOIF_INIT \ + B = pt0->cp_b; \ + H = PROTECT_FROZEN_H(pt0); \ + YREG = (CELL *) pt0->cp_a1; \ + ENV = pt0->cp_env; + +#ifdef DEPTH_LIMIT +#define OR_LAST_NOIF_DEPTH \ + DEPTH = pt0->cp_depth; +#endif + +#define OR_LAST_NOIF_END \ + HBREG = PROTECT_FROZEN_H(B); +#ifdef YAPOR + +#define OR_LAST_YAPOR \ + (*_PREG) = NEXTOP((*_PREG), Osblp); +#else + +#define OR_LAST_NOYAPOR \ + (*_PREG) = NEXTOP((*_PREG), p); +#endif + +#define OR_LAST_END \ + SET_BB(PROTECT_FROZEN_B(B)); \ + GONext(); + +#define LOCK_PRED_INSTINIT \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + PELOCK(10,ap); \ + PP = ap; + +#define LOCK_PRED_FIRSTIFOK \ + UNLOCKPE(11,ap); \ + FAIL(); + +#define LOCK_PRED_SECONDTIFOK \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(ap, 0, CP); \ + setregs(); \ + CACHE_A1(); \ + save_pc(); + +#define LOCK_PRED_END \ + (*_PREG) = ap->cs.p_code.TrueCodeOfPred; \ + JMPNext(); + +#if defined(YAPOR) || defined(THREADS) +#define INDEX_PRED_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + if (!PP) { \ + PELOCK(11,ap); \ + } \ + if (ap->OpcodeOfPred != INDEX_OPCODE) { \ + if (!PP) { \ + UNLOCKPE(11,ap); \ + } \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + JMPNext(); \ + } \ + else \ + { \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(ap, 0, CP); \ + setregs(); \ + CACHE_A1(); \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + if (!PP) \ + { \ + UNLOCKPE(14,ap); \ + } \ + JMPNext(); \ + } +#else /* defined(YAPOR) || defined(THREADS) */ +#define INDEX_PRED_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + { \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(ap, 0, CP); \ + setregs(); \ + CACHE_A1(); \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + { \ + UNLOCKPE(14,ap); \ + } \ + JMPNext(); \ + } +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define INDEX_PRED_END \ + BLOCK = (CELL)INDEX_PRED_END; + +#if THREADS +#define THREAD_LOCAL_INSTINIT \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + ap = Yap_GetThreadPred(ap PASS_REGS); \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + JMPNext(); +#endif + +#define EXPAND_INDEX_INSTINIT \ + PredEntry *pe = PredFromExpandCode((*_PREG)); \ + yamop *pt0; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_INDEX_YAPOR_THREADS_NOPP \ + PELOCK(12,pe); + +#define EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT \ + (*_PREG) = *PREG_ADDR; + +#define EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK \ + UNLOCKPE(15,pe); + +#define EXPAND_INDEX_YAPOR_THREADS_IFOK_END \ + JMPNext(); +#endif + +#ifdef SHADOW_S +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS \ + S = (*_SREG); +#endif + +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS \ + saveregs(); \ + pt0 = Yap_ExpandIndex(pe, 0); \ + setregs(); + +#ifdef SHADOW_S +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG \ + (*_SREG) = S; +#endif + +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG \ + (*_PREG) = pt0; + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_INDEX_UNLOCK \ + UNLOCKPE(12,pe); +#endif + +#define EXPAND_INDEX_END \ + JMPNext(); + +#define EXPAND_CLAUSES_INSTINIT \ + PredEntry *pe = (*_PREG)->u.sssllp.p; \ + yamop *pt0; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_CLAUSES_YAPOR_THREADS_NOPP \ + PELOCK(13,pe); + +#define EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT \ + (*_PREG) = *PREG_ADDR; + +#define EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK \ + UNLOCKPE(16,pe); + +#define EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END \ + JMPNext(); +#endif + +#define EXPAND_CLAUSES_NOYAPOR_NOTHREADS \ + saveregs(); \ + pt0 = Yap_ExpandIndex(pe, 0); \ + setregs(); \ + UNLOCKPE(17,pe); \ + (*_PREG) = pt0; + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_CLAUSES_UNLOCK \ + UNLOCKPE(18,pe); +#endif + +#define EXPAND_CLAUSES_END \ + JMPNext(); + +#if defined(YAPOR) || defined(THREADS) +#ifdef LOW_LEVEL_TRACER +#define UNDEF_P_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + PP = NULL; \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,UndefCode,XREGS+1); \ + } \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#else /* LOW_LEVEL_TRACER */ +#define UNDEF_P_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + PP = NULL; \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#endif /* LOW_LEVEL_TRACER */ +#else /* defined(YAPOR) || defined(THREADS) */ +#ifdef LOW_LEVEL_TRACER +#define UNDEF_P_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,UndefCode,XREGS+1); \ + } \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#else /* LOW_LEVEL_TRACER */ +#define UNDEF_P_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#endif /* LOW_LEVEL_TRACER */ +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define UNDEF_P_END \ + BLOCK = (CELL)UNDEF_P_END; + +#define SPY_PRED_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + PELOCK(14,pe); + +#define SPY_PRED_FIRSTIFOK \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(pe, 0, CP); \ + setregs(); + +#define SPY_PRED_SECONDIFOK_INIT \ + LOCK(pe->StatisticsForPred.lock); \ + pe->StatisticsForPred.NOfEntries++; \ + UNLOCK(pe->StatisticsForPred.lock); \ + LOCAL_ReductionsCounter--; + +#define SPY_PRED_SECONDIFOK_FIRSTIFOK \ + UNLOCKPE(20,pe); \ + saveregs(); \ + Yap_NilError(CALL_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); + +#define SPY_PRED_SECONDIFOK_POST_FIRSTIF \ + LOCAL_PredEntriesCounter--; + +#define SPY_PRED_SECONDIFOK_SECONDIFOK \ + UNLOCKPE(21,pe); \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); + +#define SPY_PRED_SECONDIFOK_THIRDIFOK \ + (*_PREG) = pe->cs.p_code.TrueCodeOfPred; \ + UNLOCKPE(22,pe); \ + JMPNext(); + +#define SPY_PRED_THIRDIFOK_INIT \ + LOCK(pe->StatisticsForPred.lock); \ + pe->StatisticsForPred.NOfEntries++; \ + UNLOCK(pe->StatisticsForPred.lock); + +#define SPY_PRED_THIRDIFOK_FIRSTIFOK \ + (*_PREG) = pe->cs.p_code.TrueCodeOfPred; \ + UNLOCKPE(23,pe); \ + JMPNext(); + +#define SPY_PRED_FOURTHIFOK \ + (*_PREG) = pe->cs.p_code.TrueCodeOfPred; \ + UNLOCKPE(24,pe); \ + JMPNext(); + +#define SPY_PRED_POST_FOURTHIF \ + UNLOCKPE(25,pe); \ + d0 = pe->ArityOfPE; + +#define SPY_PRED_D0ISZERO \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); + +#define SPY_PRED_D0ISNOZERO_INIT \ + *H = (CELL) pe->FunctorOfPred; \ + HR[d0 + 2] = AbsAppl(HR); \ + HR++; \ + pt1 = XREGS + 1; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT \ + pt0 = pt1++; \ + d1 = *pt0; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR \ + *H++ = d1; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR \ + *H++ = (CELL)pt0; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); + +#define SPY_PRED_POST_IFS \ + H[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + PredEntry *pt0; + +#ifdef THREADS +#define SPY_PRED_THREADS_LOCK \ + LOCK(GLOBAL_ThreadHandlesLock); +#endif + +#define SPY_PRED_POST_LOCK \ + pt0 = SpyCode; \ + P_before_spy = (*_PREG); \ + (*_PREG) = pt0->CodeOfPred; + +#ifdef THREADS +#define SPY_PRED_THREADS_UNLOCK \ + UNLOCK(GLOBAL_ThreadHandlesLock); +#endif + +#define SPY_PRED_POST_UNLOCK \ + save_pc(); \ + CACHE_A1(); + +#ifdef LOW_LEVEL_TRACER +#define SPY_PRED_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,pt0,XREGS+1); +#endif + +#define SPY_PRED_END \ + JMPNext(); + diff --git a/JIT/HPP/yaam_misc_d.h b/JIT/HPP/yaam_misc_d.h new file mode 100644 index 000000000..6dc543eaa --- /dev/null +++ b/JIT/HPP/yaam_misc_d.h @@ -0,0 +1,1301 @@ +#if PARALLEL_YAP +#define LUCK_LU_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + if (PP) { \ + GONext(); \ + } \ + else { \ + PP = (*_PREG)->u.p.p; \ + PELOCK(3, PP); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); \ + } +#else /* PARALLEL_YAP */ +#define LUCK_LU_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + GONext(); +#endif /* PARALLEL_YAP */ + +#define LOCK_LU_END \ + BLOCK = (CELL)LOCK_LU_END; + +#define UNLOCK_LU_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#if defined(YAPOR) || defined(THREADS) +#define UNLOCK_LU_YAPOR_THREADS \ + UNLOCKPE(1,PP); \ + PP = NULL; +#endif + +#define UNLOCK_LU_END \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); + +#define ALLOC_FOR_LOGICAL_PRED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#if MULTIPLE_STACKS +#define ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS \ + LogUpdClause *cl = (*_PREG)->u.L.ClBase; +#if PARALLEL_YAP +#define ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_PARALLEL \ + PredEntry *ap = cl->ClPred; +#endif +#define ALLOC_FOR_LOGICAL_PRED_MULTIPLE_STACKS_END \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(2,ap); \ + PP = NULL; +#else +#define ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_INIT \ + LogUpdClause *cl = (LogUpdClause *)(*_PREG)->u.L.ClBase; + +#define ALLOC_FOR_LOGICAL_PRED_NOMULTIPLE_STACKS_IF \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } +#endif + +#define ALLOC_FOR_LOGICAL_PRED_END \ + (*_PREG) = NEXTOP((*_PREG), L); \ + JMPNext(); + +/** COPY_IDB_TERM_INSTINIT was changed: no error messages **/ +#if defined(YAPOR) || defined(THREADS) +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + PP = NULL; \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#else /* defined(YAPOR) || defined(THREADS) */ +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(7,PP); \ + PP = NULL; \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define COPY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); \ + } +#else /* DEPTH_LIMIT */ +#define COPY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + Term t; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + while ((t = Yap_FetchTermFromDB(cl->ClSource)) == 0L) { \ + LOCAL_Error_TYPE = YAP_NO_ERROR; \ + } \ + if (!Yap_IUnify(ARG2, t)) { \ + setregs(); \ + UNLOCKPE(5,PP); \ + YAAM_FAIL; \ + } \ + else if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(6,PP); \ + YAAM_FAIL; \ + } \ + else { \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + (*_PREG) = (*_CPREG); \ + YREG = ENV; \ + JMPNext(); \ + } +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define COPY_IDB_TERM_END \ + BLOCK = (CELL)COPY_IDB_TERM_END; + +#if defined(YAPOR) || defined(THREADS) +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define UNIFY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(10,PP); \ + PP = NULL; \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define UNIFY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + JMPNext(); +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define UNIFY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define UNIFY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + PP = NULL; \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + JMPNext(); +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#else /* defined(YAPOR) || defined(THREADS) */ +#if MULTIPLE_STACKS +#ifdef DEPTH_LIMIT +#define UNIFY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + FAIL(); \ + } \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(10,PP); \ + PP = NULL; \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define UNIFY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + FAIL(); \ + } \ + setregs(); \ + INC_CLREF_COUNT(cl); \ + TRAIL_CLREF(cl); \ + UNLOCKPE(10,PP); \ + PP = NULL; \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + JMPNext(); +#endif /* DEPTH_LIMIT */ +#else /* MULTIPLE_STACKS */ +#ifdef DEPTH_LIMIT +#define UNIFY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + DEPTH = YREG[E_DEPTH]; \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define UNIFY_IDB_TERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + { \ + LogUpdClause *cl = ClauseCodeToLogUpdClause((*_PREG)); \ + saveregs(); \ + if (!Yap_IUnify(ARG2, cl->ClSource->Entry)) { \ + setregs(); \ + UNLOCKPE(8,PP); \ + FAIL(); \ + } \ + if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) { \ + setregs(); \ + UNLOCKPE(9,PP); \ + FAIL(); \ + } \ + setregs(); \ + if (!(cl->ClFlags & InUseMask)) { \ + cl->ClFlags |= InUseMask; \ + TRAIL_CLREF(cl); \ + } \ + } \ + (*_PREG) = (*_C(*_PREG)); \ + YREG = ENV; \ + JMPNext(); +#endif /* DEPTH_LIMIT */ +#endif /* MULTIPLE_STACKS */ +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define UNIFY_IDB_TERM_END \ + BLOCK = (CELL)UNIFY_IDB_TERM_END; + +#ifdef DEPTH_LIMIT +#define ENSURE_SPACE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + { \ + Int sz = (*_PREG)->u.Osbpa.i; \ + UInt arity = (*_PREG)->u.Osbpa.p->ArityOfPE; \ + if (Unsigned(HR) + sz > Unsigned(YREG)-CreepFlag) { \ + YENV[E_CP] = (CELL) (*_C(*_PREG)); \ + YENV[E_E] = (CELL) ENV; \ + YENV[E_DEPTH] = DEPTH; \ + SET_ASP(YREG, (*_PREG)->u.Osbpa.s); \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); \ + saveregs(); \ + setregs(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); \ + } \ + } \ + JMPNext(); +#else /* DEPTH_LIMIT */ +#define ENSURE_SPACE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + { \ + Int sz = (*_PREG)->u.Osbpa.i; \ + UInt arity = (*_PREG)->u.Osbpa.p->ArityOfPE; \ + if (Unsigned(HR) + sz > Unsigned(YREG)-CreepFlag) { \ + YENV[E_CP] = (CELL) (*_C(*_PREG)); \ + YENV[E_E] = (CELL) ENV; \ + SET_ASP(YREG, (*_PREG)->u.Osbpa.s); \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); \ + saveregs(); \ + setregs(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG),Osbpa); \ + } \ + } \ + JMPNext(); +#endif /* DEPTH_LIMIT */ + +#define ENSURE_SPACE_END + +#define JUMP_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_PREG) = (*_PREG)->u.l.l; \ + JMPNext(); + +#define MOVE_BACK_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_PREG) = (yamop *)(((char *)(*_PREG))-(Int)(NEXTOP((yamop *)NULL,Osbpp))); \ + JMPNext(); + +#define SKIP_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_PREG) = NEXTOP((*_PREG),l); \ + JMPNext(); + +#define EITHER_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define EITHER_LOW_LEVEL_TRACER \ + low_level_trace(try_or, (PredEntry *)(*_PREG), NULL); +#endif + +#define EITHER_POST_COROUTINING \ + register CELL d0; \ + register choiceptr pt1; \ + d0 = (*_PREG)->u.Osblp.s; \ + pt1 = (choiceptr) ((char *) YREG + (yslot) d0); + +#ifdef FROZEN_STACKS +#ifdef YAPOR_SBA +#define EITHER_FROZEN_YSBA \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b || pt1 < (choiceptr)H) \ + pt1 = top_b; +#else /* YAPOR_SBA */ +#define EITHER_FROZEN_YSBA \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (pt1 > top_b) \ + pt1 = top_b; +#endif /* YAPOR_SBA */ +#else /* FROZEN_STACKS */ +#define EITHER_FROZEN_YSBA \ + if (pt1 > B) \ + pt1 = B; +#endif /* FROZEN_STACKS */ + +#define EITHER_POST_FROZEN_YSBA \ + pt1 = (choiceptr)(((CELL *) pt1)-1); \ + *(CELL **) pt1 = YREG; \ + store_yaam_regs_for_either((*_PREG)->u.Osblp.l, (*_PREG)); \ + (*_SREG) = (CELL *) (B = pt1); + +#ifdef YAPOR +#define EITHER_YAPOR \ + SCH_set_load(pt1); +#endif + +#define EITHER_END \ + SET_BB(pt1); \ + (*_PREG) = NEXTOP(NEXTOP((*_PREG), Osblp),l); \ + GONext(); + +#define OR_ELSE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + HR = HRBREG = PROTECT_FROZEN_H(B); \ + ENV = B->cp_env; \ + B->cp_cp = (*_PREG); + +#ifdef DEPTH_LIMIT +#define OR_ELSE_DEPTH \ + DEPTH = B->cp_depth; +#endif + +#define OR_ELSE_POST_DEPTH \ + SET_BB(PROTECT_FROZEN_B(B)); + +#ifdef YAPOR +#define OR_ELSE_YAPOR \ + SCH_new_alternative((*_PREG), (*_PREG)->u.Osblp.l); +#endif + +#define OR_ELSE_END \ + B->cp_ap = (*_PREG)->u.Osblp.l; \ + (*_PREG) = NEXTOP((*_PREG), Osblp); \ + YREG = (CELL *) B->cp_a1; \ + GONext(); + +#define OR_LAST_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register choiceptr pt0; \ + pt0 = B; + +#ifdef YAPOR +#define OR_LAST_IFOK_INIT \ + H = HRBREG = PROTECT_FROZEN_H(pt0); \ + YREG = (CELL *) pt0->cp_a1; \ + ENV = pt0->cp_env; + +#ifdef DEPTH_LIMIT +#define OR_LAST_IFOK_DEPTH \ + DEPTH = pt0->cp_depth; +#endif + +#define OR_LAST_IFOK_END \ + SCH_new_alternative((*_PREG), NULL); +#endif + +#define OR_LAST_NOIF_INIT \ + B = pt0->cp_b; \ + H = PROTECT_FROZEN_H(pt0); \ + YREG = (CELL *) pt0->cp_a1; \ + ENV = pt0->cp_env; + +#ifdef DEPTH_LIMIT +#define OR_LAST_NOIF_DEPTH \ + DEPTH = pt0->cp_depth; +#endif + +#define OR_LAST_NOIF_END \ + HBREG = PROTECT_FROZEN_H(B); +#ifdef YAPOR + +#define OR_LAST_YAPOR \ + (*_PREG) = NEXTOP((*_PREG), Osblp); +#else + +#define OR_LAST_NOYAPOR \ + (*_PREG) = NEXTOP((*_PREG), p); +#endif + +#define OR_LAST_END \ + SET_BB(PROTECT_FROZEN_B(B)); \ + GONext(); + +#define LOCK_PRED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + PELOCK(10,ap); \ + PP = ap; + +#define LOCK_PRED_FIRSTIFOK \ + UNLOCKPE(11,ap); \ + FAIL(); + +#define LOCK_PRED_SECONDTIFOK \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(ap, 0, CP); \ + setregs(); \ + CACHE_A1(); \ + save_pc(); + +#define LOCK_PRED_END \ + (*_PREG) = ap->cs.p_code.TrueCodeOfPred; \ + JMPNext(); + +#if defined(YAPOR) || defined(THREADS) +#define INDEX_PRED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + if (!PP) { \ + PELOCK(11,ap); \ + } \ + if (ap->OpcodeOfPred != INDEX_OPCODE) { \ + if (!PP) { \ + UNLOCKPE(11,ap); \ + } \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + JMPNext(); \ + } \ + else \ + { \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(ap, 0, CP); \ + setregs(); \ + CACHE_A1(); \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + if (!PP) \ + { \ + UNLOCKPE(14,ap); \ + } \ + JMPNext(); \ + } +#else /* defined(YAPOR) || defined(THREADS) */ +#define INDEX_PRED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + { \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(ap, 0, CP); \ + setregs(); \ + CACHE_A1(); \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + { \ + UNLOCKPE(14,ap); \ + } \ + JMPNext(); \ + } +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define INDEX_PRED_END \ + BLOCK = (CELL)INDEX_PRED_END; + +#if THREADS +#define THREAD_LOCAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + PredEntry *ap = PredFromDefCode((*_PREG)); \ + ap = Yap_GetThreadPred(ap PASS_REGS); \ + (*_PREG) = ap->CodeOfPred; \ + save_pc(); \ + JMPNext(); +#endif + +#define EXPAND_INDEX_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + PredEntry *pe = PredFromExpandCode((*_PREG)); \ + yamop *pt0; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_INDEX_YAPOR_THREADS_NOPP \ + PELOCK(12,pe); + +#define EXPAND_INDEX_YAPOR_THREADS_IFOK_INIT \ + (*_PREG) = *PREG_ADDR; + +#define EXPAND_INDEX_YAPOR_THREADS_IFOK_IFOK \ + UNLOCKPE(15,pe); + +#define EXPAND_INDEX_YAPOR_THREADS_IFOK_END \ + JMPNext(); +#endif + +#ifdef SHADOW_S +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_SETS \ + S = (*_SREG); +#endif + +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETS \ + saveregs(); \ + pt0 = Yap_ExpandIndex(pe, 0); \ + setregs(); + +#ifdef SHADOW_S +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_SETSREG \ + (*_SREG) = S; +#endif + +#define EXPAND_INDEX_NOYAPOR_NOTHREADS_POST_SETSREG \ + (*_PREG) = pt0; + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_INDEX_UNLOCK \ + UNLOCKPE(12,pe); +#endif + +#define EXPAND_INDEX_END \ + JMPNext(); + +#define EXPAND_CLAUSES_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + PredEntry *pe = (*_PREG)->u.sssllp.p; \ + yamop *pt0; \ + SET_ASP(YREG, E_CB*sizeof(CELL)); + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_CLAUSES_YAPOR_THREADS_NOPP \ + PELOCK(13,pe); + +#define EXPAND_CLAUSES_YAPOR_THREADS_IFOK_INIT \ + (*_PREG) = *PREG_ADDR; + +#define EXPAND_CLAUSES_YAPOR_THREADS_IFOK_IFOK \ + UNLOCKPE(16,pe); + +#define EXPAND_CLAUSES_YAPOR_THREADS_IFOK_END \ + JMPNext(); +#endif + +#define EXPAND_CLAUSES_NOYAPOR_NOTHREADS \ + saveregs(); \ + pt0 = Yap_ExpandIndex(pe, 0); \ + setregs(); \ + UNLOCKPE(17,pe); \ + (*_PREG) = pt0; + +#if defined(YAPOR) || defined(THREADS) +#define EXPAND_CLAUSES_UNLOCK \ + UNLOCKPE(18,pe); +#endif + +#define EXPAND_CLAUSES_END \ + JMPNext(); + +#if defined(YAPOR) || defined(THREADS) +#ifdef LOW_LEVEL_TRACER +#define UNDEF_P_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + PP = NULL; \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,UndefCode,XREGS+1); \ + } \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#else /* LOW_LEVEL_TRACER */ +#define UNDEF_P_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + PP = NULL; \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#endif /* LOW_LEVEL_TRACER */ +#else /* defined(YAPOR) || defined(THREADS) */ +#ifdef LOW_LEVEL_TRACER +#define UNDEF_P_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + if (Yap_do_low_level_trace) { \ + low_level_trace(enter_pred,UndefCode,XREGS+1); \ + } \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#else /* LOW_LEVEL_TRACER */ +#define UNDEF_P_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + FAILED = 0; \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + if ((pe->PredFlags & (DynamicPredFlag|LogUpdatePredFlag|MultiFileFlag)) || \ + (UndefCode->OpcodeOfPred == UNDEF_OPCODE)) { \ + UNLOCKPE(19,pe); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = pe->ArityOfPE; \ + UNLOCKPE(19,pe); \ + if (d0 == 0) { \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); \ + } \ + else { \ + HR[d0 + 2] = AbsAppl(HR); \ + *H = (CELL) pe->FunctorOfPred; \ + HR++; \ + pt1 = XREGS + 1; \ + for (; d0 > 0; --d0) { \ + pt0 = pt1++; \ + d1 = *pt0; \ + if (IsVarTerm(d1)) { \ + short setHwithd1 = 0; \ + while (Unsigned(pt0) != (d1)) { \ + (pt0) = (CELL *)(d1); \ + (d1) = *(CELL *)(d1); \ + if(!IsVarTerm(d1)) { \ + *H++ = d1; \ + setHwithd1 = 1; \ + break; \ + } \ + } \ + if (setHwithd1) { continue; } \ + if (pt0 <= HR) { \ + *H++ = (CELL)pt0; \ + } else { \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); \ + } \ + } \ + else { \ + *H++ = d1; \ + } \ + } \ + } \ + HR[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + (*_PREG) = UndefCode->CodeOfPred; \ + save_pc(); \ + CACHE_A1(); \ + JMPNext(); \ + } +#endif /* LOW_LEVEL_TRACER */ +#endif /* defined(YAPOR) || defined(THREADS) */ + +#define UNDEF_P_END \ + BLOCK = (CELL)UNDEF_P_END; + +#define SPY_PRED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + PredEntry *pe = PredFromDefCode((*_PREG)); \ + PELOCK(14,pe); + +#define SPY_PRED_FIRSTIFOK \ + SET_ASP(YREG, E_CB*sizeof(CELL)); \ + saveregs(); \ + Yap_IPred(pe, 0, CP); \ + setregs(); + +#define SPY_PRED_SECONDIFOK_INIT \ + LOCK(pe->StatisticsForPred.lock); \ + pe->StatisticsForPred.NOfEntries++; \ + UNLOCK(pe->StatisticsForPred.lock); \ + LOCAL_ReductionsCounter--; + +#define SPY_PRED_SECONDIFOK_FIRSTIFOK \ + UNLOCKPE(20,pe); \ + saveregs(); \ + Yap_NilError(CALL_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); + +#define SPY_PRED_SECONDIFOK_POST_FIRSTIF \ + LOCAL_PredEntriesCounter--; + +#define SPY_PRED_SECONDIFOK_SECONDIFOK \ + UNLOCKPE(21,pe); \ + saveregs(); \ + Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW,""); \ + setregs(); \ + JMPNext(); + +#define SPY_PRED_SECONDIFOK_THIRDIFOK \ + (*_PREG) = pe->cs.p_code.TrueCodeOfPred; \ + UNLOCKPE(22,pe); \ + JMPNext(); + +#define SPY_PRED_THIRDIFOK_INIT \ + LOCK(pe->StatisticsForPred.lock); \ + pe->StatisticsForPred.NOfEntries++; \ + UNLOCK(pe->StatisticsForPred.lock); + +#define SPY_PRED_THIRDIFOK_FIRSTIFOK \ + (*_PREG) = pe->cs.p_code.TrueCodeOfPred; \ + UNLOCKPE(23,pe); \ + JMPNext(); + +#define SPY_PRED_FOURTHIFOK \ + (*_PREG) = pe->cs.p_code.TrueCodeOfPred; \ + UNLOCKPE(24,pe); \ + JMPNext(); + +#define SPY_PRED_POST_FOURTHIF \ + UNLOCKPE(25,pe); \ + d0 = pe->ArityOfPE; + +#define SPY_PRED_D0ISZERO \ + HR[1] = MkAtomTerm((Atom)(pe->FunctorOfPred)); + +#define SPY_PRED_D0ISNOZERO_INIT \ + *H = (CELL) pe->FunctorOfPred; \ + HR[d0 + 2] = AbsAppl(HR); \ + HR++; \ + pt1 = XREGS + 1; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_INIT \ + pt0 = pt1++; \ + d1 = *pt0; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_DOSPY_NONVAR \ + *H++ = d1; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_SAFEVAR \ + *H++ = (CELL)pt0; + +#define SPY_PRED_D0ISNOZERO_INSIDEFOR_UNSAFEVAR \ + d1 = Unsigned(HR); \ + RESET_VARIABLE(HR); \ + HR += 1; \ + Bind_Local(pt0, d1); + +#define SPY_PRED_POST_IFS \ + H[0] = Yap_Module_Name(pe); \ + ARG1 = (Term) AbsPair(HR); \ + HR += 2; \ + PredEntry *pt0; + +#ifdef THREADS +#define SPY_PRED_THREADS_LOCK \ + LOCK(GLOBAL_ThreadHandlesLock); +#endif + +#define SPY_PRED_POST_LOCK \ + pt0 = SpyCode; \ + P_before_spy = (*_PREG); \ + (*_PREG) = pt0->CodeOfPred; + +#ifdef THREADS +#define SPY_PRED_THREADS_UNLOCK \ + UNLOCK(GLOBAL_ThreadHandlesLock); +#endif + +#define SPY_PRED_POST_UNLOCK \ + save_pc(); \ + CACHE_A1(); + +#ifdef LOW_LEVEL_TRACER +#define SPY_PRED_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred,pt0,XREGS+1); +#endif + +#define SPY_PRED_END \ + JMPNext(); + diff --git a/JIT/HPP/yaam_pop.h b/JIT/HPP/yaam_pop.h new file mode 100644 index 000000000..6a6669f43 --- /dev/null +++ b/JIT/HPP/yaam_pop.h @@ -0,0 +1,39 @@ +#define POP_N_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + d0 = (*_PREG)->u.os.s; \ + SP = (CELL *) (((char *) SP) + d0); \ + d0 = SP[0]; \ + if (d0) { \ + (*_SREG) = (CELL *) (SP[1]); \ + SP += 2; \ + (*_PREG) = NEXTOP((*_PREG), s); \ + GONext(); \ + } \ + else { \ + (*_SREG) = (CELL *) (SP[1]); \ + SP += 2; \ + (*_PREG) = NEXTOP((*_PREG), s); \ + GONextW(); \ + } + +#define POP_N_END \ + BLOCK = (CELL)POP_N_END; + +#define POP_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + d0 = SP[0]; \ + (*_SREG) = (CELL *) (SP[1]); \ + SP += 2; \ + if (d0) { \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONextW(); \ + } + +#define POP_END \ + BLOCK = (CELL)POP_END; diff --git a/JIT/HPP/yaam_pop_d.h b/JIT/HPP/yaam_pop_d.h new file mode 100644 index 000000000..b4fe7c0f0 --- /dev/null +++ b/JIT/HPP/yaam_pop_d.h @@ -0,0 +1,41 @@ +#define POP_N_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + d0 = (*_PREG)->u.os.s; \ + SP = (CELL *) (((char *) SP) + d0); \ + d0 = SP[0]; \ + if (d0) { \ + (*_SREG) = (CELL *) (SP[1]); \ + SP += 2; \ + (*_PREG) = NEXTOP((*_PREG), s); \ + GONext(); \ + } \ + else { \ + (*_SREG) = (CELL *) (SP[1]); \ + SP += 2; \ + (*_PREG) = NEXTOP((*_PREG), s); \ + GONextW(); \ + } + +#define POP_N_END \ + BLOCK = (CELL)POP_N_END; + +#define POP_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + d0 = SP[0]; \ + (*_SREG) = (CELL *) (SP[1]); \ + SP += 2; \ + if (d0) { \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONextW(); \ + } + +#define POP_END \ + BLOCK = (CELL)POP_END; diff --git a/JIT/HPP/yaam_primitive_predicates.h b/JIT/HPP/yaam_primitive_predicates.h new file mode 100644 index 000000000..0a8edd300 --- /dev/null +++ b/JIT/HPP/yaam_primitive_predicates.h @@ -0,0 +1,3111 @@ +#define P_ATOM_X_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_ATOM_X_ATOM \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); \ + +#define P_ATOM_X_NOATOM \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_ATOM_Y_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_ATOM_Y_IFOK \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_ATOM_Y_NOIF \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_ATOM_Y_END \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_ATOMIC_X_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_ATOMIC_X_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_ATOMIC_X_VAR \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_ATOMIC_X_END \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_ATOMIC_Y_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_ATOMIC_Y_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_ATOMIC_Y_VAR \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_ATOMIC_Y_END \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_INTEGER_X_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); \ + +#define P_INTEGER_X_INTEGER_X_NVAR_OK \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_INTEGER_X_INTEGER_X_NVAR_NOOK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_INTEGER_X_INTEGER_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_INTEGER_Y_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_INTEGER_Y_INTEGER_Y_NVAR_OK \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_INTEGER_Y_INTEGER_Y_NVAR_NOOK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_INTEGER_Y_INTEGER_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_NONVAR_X_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_NONVAR_X_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_NONVAR_X_NONONVAR \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NONVAR_Y_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_NONVAR_Y_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_NONVAR_Y_NONONVAR \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_NUMBER_X_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_NUMBER_X_INT \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_NUMBER_X_FUNCTORINT \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_NUMBER_X_FUNCTORDEFAULT \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NUMBER_X_POST_IF \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NUMBER_X_NUMBER_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NUMBER_Y_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_NUMBER_Y_INT \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_NUMBER_Y_FUNCTORINT \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_NUMBER_Y_FUNCTORDEFAULT \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_NUMBER_Y_POST_IF \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NUMBER_Y_NUMBER_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_VAR_X_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_VAR_X_NONVAR \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_VAR_X_VAR \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_VAR_Y_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_VAR_Y_NONVAR \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_VAR_Y_VAR \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_DB_REF_X_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_DB_REF_X_DBREF \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_DB_REF_X_NODBREF \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_DB_REF_X_DBREF_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_DB_REF_Y_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_DB_REF_Y_DBREF \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_DB_REF_Y_NODBREF \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_DB_REF_Y_DBREF_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_PRIMITIVE_X_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_PRIMITIVE_X_PRIMITIVE \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_PRIMITIVE_X_NOPRIMITIVE \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_PRIMITIVE_X_PRIMI_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_PRIMITIVE_Y_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_PRIMITIVE_Y_PRIMITIVE \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_PRIMITIVE_Y_NOPRIMITIVE \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_PRIMITIVE_Y_PRIMI_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_COMPOUND_X_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_COMPOUND_X_PAIR \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_COMPOUND_X_APPL_IFOK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_COMPOUND_X_APPL \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_COMPOUND_X_NOAPPL \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_COMPOUND_X_COMPOUND_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_COMPOUND_Y_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_COMPOUND_Y_PAIR \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_COMPOUND_Y_APPL_IFOK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_COMPOUND_Y_APPL \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_COMPOUND_Y_NOAPPL \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_COMPOUND_Y_COMPOUND_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_FLOAT_X_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_FLOAT_X_FLOAT \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_FLOAT_X_POST_IF \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_FLOAT_X_FLOAT_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_FLOAT_Y_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_FLOAT_Y_FLOAT \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_FLOAT_Y_POST_IF \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_FLOAT_Y_FLOAT_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_PLUS_VV_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_PLUS_VV_PLUS_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1)); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_PLUS_VV_PLUS_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is _+B"); \ + setregs(); \ + FAIL(); + +#define P_PLUS_VV_PLUS_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); \ + setregs(); \ + FAIL(); + +#define P_PLUS_VC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_PLUS_VC_PLUS_VC_NVAR_INT \ + d0 = MkIntegerTerm(IntOfTerm(d0) + d1); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_PLUS_VC_PLUS_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_PLUS_VC_PLUS_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_PLUS_Y_VV_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_PLUS_Y_VV_PLUS_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1)); \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_PLUS_Y_VV_PLUS_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); \ + setregs(); \ + FAIL(); + +#define P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); \ + setregs(); \ + FAIL(); + +#define P_PLUS_Y_VC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT \ + d0 = MkIntegerTerm(IntOfTerm(d0) + d1); \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_PLUS_Y_VC_PLUS_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_MINUS_VV_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_MINUS_VV_MINUS_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1)); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_MINUS_VV_MINUS_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); + +#define P_MINUS_VV_MINUS_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); + +#define P_MINUS_CV_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_MINUS_CV_MINUS_CV_NVAR_INT \ + d0 = MkIntegerTerm(d1 - IntOfTerm(d0)); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_MINUS_CV_MINUS_CV_NVAR_NOINT \ + saveregs(); \ + d0 = p_minus(MkIntegerTerm(d1),Yap_Eval(d0)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_MINUS_CV_MINUS_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "-A", (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_VV_INSTINIT \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_MINUS_Y_VV_MINUS_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_MINUS_Y_VV_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1)); + +#define P_MINUS_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_MINUS_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_MINUS_Y_VV_MINUS_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_CV_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_MINUS_Y_CV_MINUS_Y_CV_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_MINUS_Y_CV_INTTERM \ + d0 = MkIntegerTerm(d1 - IntOfTerm(d0)); + +#define P_MINUS_Y_CV_NOINTTERM \ + saveregs(); \ + d0 = p_minus(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); + +#define P_MINUS_Y_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_CV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_MINUS_Y_CV_MINUS_Y_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "-A", (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_TIMES_VV_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_TIMES_VV_TIMES_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = times_int(IntOfTerm(d0), IntOfTerm(d1)); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_TIMES_VV_TIMES_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); + +#define P_TIMES_VV_TIMES_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); + +#define P_TIMES_VC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_TIMES_VC_TIMES_VC_NVAR_INT \ + d0 = times_int(IntOfTerm(d0), d1); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_TIMES_VC_TIMES_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_TIMES_VC_TIMES_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A* " Int_FORMAT, (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_TIMES_Y_VV_INSTINIT \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_TIMES_Y_VV_TIMES_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_TIMES_Y_VV_INTTERM \ + d0 = times_int(IntOfTerm(d0), IntOfTerm(d1)); + +#define P_TIMES_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_TIMES_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_TIMES_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_TIMES_Y_VV_TIMES_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); + +#define P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); + +#define P_TIMES_Y_VC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT \ + d0 = times_int(IntOfTerm(d0), d1); \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_TIMES_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_TIMES_Y_VC_TIMES_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A* " Int_FORMAT, (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_DIV_VV_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_DIV_VV_DIV_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_DIV_VV_DIV_VV_NVAR_NVAR_INT \ + BLOCK = (CELL)P_DIV_VV_DIV_VV_NVAR_NVAR_INT; \ + FAILED = 0; \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + Int div = IntOfTerm(d1); \ + if (div == 0) { \ + saveregs(); \ + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); \ + setregs(); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = MkIntTerm(IntOfTerm(d0) / div); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); \ + } + +#define P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_div(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_DIV_VV_DIV_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_VV_DIV_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_VC_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_DIV_VC_DIV_VC_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_DIV_VC_INTTERM \ + d0 = MkIntTerm(IntOfTerm(d0) / d1); + +#define P_DIV_VC_NOINTTERM \ + saveregs(); \ + d0 = p_div(Yap_Eval(d0),MkIntegerTerm(d1)); \ + setregs(); + +#define P_DIV_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_VC_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_DIV_VC_DIV_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_CV_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_DIV_CV_DIV_CV_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_DIV_CV_INTTERM_INIT \ + Int div = IntOfTerm(d0); + +#define P_DIV_CV_INTTERM_DIVEQUALS0 \ + saveregs(); \ + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); \ + setregs(); \ + FAIL(); + +#define P_DIV_CV_INTTERM_END \ + d0 = MkIntegerTerm(d1 / div); + +#define P_DIV_CV_NOINTTERM \ + saveregs(); \ + d0 = p_div(MkIntegerTerm(d1),Yap_Eval(d0)); + +#define P_DIV_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_CV_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_DIV_CV_DIV_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "// A", (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VV_INSTINIT \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_DIV_Y_VV_DIV_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_DIV_Y_VV_INTTERM_INIT \ + Int div = IntOfTerm(d1); + +#define P_DIV_Y_VV_INTTERM_DIVEQUALS0 \ + saveregs(); \ + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VV_INTTERM_END \ + d0 = MkIntTerm(IntOfTerm(d0) / div); + +#define P_DIV_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_div(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_DIV_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_DIV_Y_VV_DIV_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VC_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_DIV_Y_VC_DIV_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_DIV_Y_VC_INTTERM \ + d0 = MkIntTerm(IntOfTerm(d0)/d1); + +#define P_DIV_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_div(Yap_Eval(d0),MkIntegerTerm(d1)); \ + setregs(); + +#define P_DIV_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_DIV_Y_VC_DIV_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_CV_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_DIV_Y_CV_DIV_Y_CV_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_DIV_Y_CV_INTTERM_INIT \ + Int div = IntOfTerm(d0); + +#define P_DIV_Y_CV_INTTERM_DIVEQUALS0 \ + saveregs(); \ + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_CV_INTTERM_END \ + d0 = MkIntegerTerm(d1 / div); + +#define P_DIV_Y_CV_NOINTTERM \ + saveregs(); \ + d0 = p_div(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); + +#define P_DIV_Y_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_CV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_DIV_Y_CV_DIV_Y_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "// A", (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_AND_VV_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_AND_VV_AND_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_AND_VV_AND_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1)); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_AND_VV_AND_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_AND_VV_AND_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); + +#define P_AND_VV_AND_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); + +#define P_AND_VC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_AND_VC_AND_VC_NVAR_INT \ + d0 = MkIntegerTerm(IntOfTerm(d0) & d1); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_AND_VC_AND_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_AND_VC_AND_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A /\\ " Int_FORMAT , (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VV_INSTINIT \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_AND_Y_VV_AND_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_AND_Y_VV_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1)); + +#define P_AND_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_AND_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_AND_Y_VV_AND_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VV_AND_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VC_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_AND_Y_VC_AND_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_AND_Y_VC_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) & d1); + +#define P_AND_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_AND_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_AND_Y_VC_AND_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A /\\ " Int_FORMAT , (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_OR_VV_INSTINIT \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_OR_VV_OR_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_OR_VV_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1)); + +#define P_OR_VV_NOINTTERM \ + saveregs(); \ + d0 = p_or(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_OR_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_OR_VV_NVAR_END \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_OR_VV_OR_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); \ + setregs(); \ + FAIL(); + +#define P_OR_VV_OR_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); \ + setregs(); \ + FAIL(); + +#define P_OR_VC_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_OR_VC_OR_VC_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_OR_VC_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) | d1); + +#define P_OR_VC_NOINTTERM \ + saveregs(); \ + d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1)); + +#define P_OR_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_OR_VC_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_OR_VC_OR_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A \\/ " Int_FORMAT , (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VV_INSTINIT \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_OR_Y_VV_OR_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_OR_Y_VV_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1)); + +#define P_OR_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_or(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_OR_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_OR_Y_VV_OR_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VV_OR_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VC_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_OR_Y_VC_OR_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_OR_Y_VC_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) | d1); + +#define P_OR_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_OR_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_OR_Y_VC_OR_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A \\/ " Int_FORMAT , (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_SLL_VV_INSTINIT \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_SLL_VV_SLL_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_SLL_VV_INTTERM_INIT \ + Int i2 = IntOfTerm(d1); + +#define P_SLL_VV_INTTERM_LESS \ + d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2)); + +#define P_SLL_VV_INTTERM_GREATER \ + d0 = do_sll(IntOfTerm(d0),i2); + +#define P_SLL_VV_NOINTTERM \ + saveregs(); \ + d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_SLL_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_VV_NVAR_END \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_SLL_VV_SLL_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxn.xi); + +#define P_SLL_VC_SLL_VC_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_SLL_VC_INTTERM \ + d0 = do_sll(IntOfTerm(d0), (Int)d1); + +#define P_SLL_VC_NOINTTERM \ + saveregs(); \ + d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_SLL_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_VC_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLL_VC_SLL_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_SLL_CV_SLL_CV_NVAR_INT \ + Int i2 = IntOfTerm(d0); \ + if (i2 < 0) { \ + d0 = MkIntegerTerm(SLR(d1, -i2)); \ + } else { \ + d0 = do_sll(d1,i2); \ + } \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLL_CV_SLL_CV_NVAR_NOINT \ + saveregs(); \ + d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); \ + XREG((*_PREG->u.xxn.x) = d0; \ + (*_PREG = NEXTOP((*_PREG, xxn); \ + GONext(); + +#define P_SLL_CV_SLL_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.yxx.x1); + +#define P_SLL_Y_VV_SLL_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_SLL_Y_VV_INTTERM_INIT \ + Int i2 = IntOfTerm(d1); + +#define P_SLL_Y_VV_INTERM_LESS \ + d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2)); + +#define P_SLL_Y_VV_INTTERM_GREATER \ + d0 = do_sll(IntOfTerm(d0),i2); + +#define P_SLL_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_SLL_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLL_Y_VV_SLL_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.yxn.xi); + +#define P_SLL_Y_VC_SLL_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_SLL_Y_VC_INTTERM \ + d0 = do_sll(IntOfTerm(d0), Yap_Eval(d1)); + +#define P_SLL_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_SLL_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLL_Y_VC_SLL_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.yxn.xi); + +#define P_SLL_Y_CV_SLL_Y_CV_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_SLL_Y_CV_INTTERM_INIT \ + Int i2 = IntOfTerm(d0); + +#define P_SLL_Y_CV_INTTERM_LESS \ + d0 = MkIntegerTerm(SLR(d1, -i2)); + +#define P_SLL_Y_CV_INTTERM_GREATER \ + d0 = do_sll(d1,i2); + +#define P_SLL_Y_CV_NOINTTERM \ + saveregs(); \ + d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(0)); \ + setregs(); + +#define P_SLL_Y_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_Y_CV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLL_Y_CV_SLL_Y_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxx.x1); + +#define P_SLR_VV_SLR_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_SLR_VV_INTTERM_INIT \ + Int i2 = IntOfTerm(d1); + +#define P_SLR_VV_INTTERM_LESS \ + d0 = do_sll(IntOfTerm(d0), -i2); + +#define P_SLR_VV_INTTERM_GREATER \ + d0 = MkIntTerm(SLR(IntOfTerm(d0), i2)); + +#define P_SLR_VV_NOINTTERM \ + saveregs(); \ + d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_SLR_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_VV_NVAR_END \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_SLR_VV_SRL_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_VV_SRL_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_VC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_SLR_VC_SLR_VC_NVAR_INT \ + d0 = MkIntTerm(SLR(IntOfTerm(d0), d1)); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLR_VC_SLR_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLR_VC_SRL_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_CV_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_SLR_CV_SLR_CV_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_SLR_CV_INTTERM_INIT \ + Int i2 = IntOfTerm(d0); + +#define P_SLR_CV_INTTERM_LESS \ + d0 = do_sll(d1, -i2); + +#define P_SLR_CV_INTTERM_GREATER \ + d0 = MkIntegerTerm(SLR(d1, i2)); + +#define P_SLR_CV_NOINTTERM \ + saveregs(); \ + d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); + +#define P_SLR_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_CV_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLR_CV_SLR_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VV_INSTINIT \ + register CELL d0, d1; \ + register CELL8 pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_SLR_Y_VV_SLR_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_SLR_Y_VV_INTTERM_INIT \ + Int i2 = IntOfTerm(d1); + +#define P_SLR_Y_VV_INTTERM_LESS \ + d0 = do_sll(IntOfTerm(d0), -i2); + +#define P_SLR_Y_VV_INTTERM_GREATER \ + d0 = MkIntTerm(SLR(IntOfTerm(d0), i2)); + +#define P_SLR_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_SLR_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLR_Y_VV_SLR_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VC_INSTINIT \ + register CELL d0; \ + register CELL8 pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_SLR_Y_VC_SLR_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_SLR_Y_VC_INTTERM \ + d0 = MkIntTerm(SLR(IntOfTerm(d0), d1)); + +#define P_SLR_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_SLR_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLR_Y_VC_SLR_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); + +#define P_SLR_Y_CV_INSTINIT \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_SLR_Y_CV_SLR_Y_CV_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_SLR_Y_CV_INTTERM_INIT \ + Int i2 = IntOfTerm(d0); + +#define P_SLR_Y_CV_INTTERM_LESS \ + d0 = do_sll(d1, -i2); + +#define P_SLR_Y_CV_INTTERM_GREATER \ + d0 = MkIntegerTerm(SLR(d1, i2)); + +#define P_SLR_Y_CV_NOINTTERM \ + saveregs(); \ + d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); + +#define P_SLR_Y_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_CV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLR_Y_CV_SLR_Y_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define CALL_BFUNC_XX_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.plxxs.x1); + +#define CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR \ + d1 = XREG((*_PREG)->u.plxxs.x2); + +#define CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT \ + BLOCK = (CELL)CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT; \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + COUNT flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plxxs.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + yamop *nextp = NEXTOP((*_PREG), plxxs); \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + else { \ + yamop *nextp = (*_PREG)->u.plxxs.f; \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + } \ + else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + yamop *nextp = NEXTOP((*_PREG), plxxs); \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + else { \ + yamop *nextp = (*_PREG)->u.plxxs.f; \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + } \ + else { \ + if (flags & EQ_OK_IN_CMP) { \ + yamop *nextp = NEXTOP((*_PREG), plxxs); \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + else { \ + yamop *nextp = (*_PREG)->u.plxxs.f; \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + } \ + } + +#define CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT \ + BLOCK = (CELL)CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT; \ + CmpPredicate f = (*_PREG)->u.plxxs.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + if ((*_PREG) == FAILCODE) { \ + JMPNext(); \ + } \ + else if (!d0) { \ + (*_PREG) = (*_PREG)->u.plxxs.f; \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), plxxs); \ + JMPNext(); \ + } + +#define CALL_BFUNC_XX_CALL_BFUNC_XX_UNK \ + d1 = Deref(d1); + +#define CALL_BFUNC_YX_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.plxys.y; \ + d1 = XREG((*_PREG)->u.plxys.x); \ + d0 = *pt0; + +#define CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT \ + BLOCK = (CELL)CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT; \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + int flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plxys.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } else { \ + if (flags & EQ_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } \ + } + +#define CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT \ + BLOCK = (CELL)CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT; \ + CmpPredicate f = (*_PREG)->u.plxys.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + if (!d0 || (*_PREG) == FAILCODE) { \ + if ((*_PREG) != FAILCODE) { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + } \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } + +#define CALL_BFUNC_YX_CALL_BFUNC_YX_UNK \ + d1 = Deref(d1); + +#define CALL_BFUNC_XY_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.plxys.y; \ + d0 = XREG((*_PREG)->u.plxys.x); \ + d1 = *pt0; + +#define CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT \ + BLOCK = (CELL)CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT; \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + int flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plxys.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } else { \ + if (flags & EQ_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } \ + } + +#define CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT \ + BLOCK = (CELL)CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT; \ + CmpPredicate f = (*_PREG)->u.plxys.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + if (!d0 || (*_PREG) == FAILCODE) { \ + if ((*_PREG) != FAILCODE) { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + } \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } + +#define CALL_BFUNC_XY_CALL_BFUNC_XY_UNK \ + d1 = Deref(d1); + +#define CALL_BFUNC_YY_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = YREG + (*_PREG)->u.plyys.y1; \ + pt1 = YREG + (*_PREG)->u.plyys.y2; \ + d0 = *pt0; \ + d1 = *pt1; + +#define CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT \ + BLOCK = (CELL)CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT; \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + int flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plyys.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + JMPNext(); \ + } \ + } else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + JMPNext(); \ + } \ + } else { \ + if (flags & EQ_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + JMPNext(); \ + } \ + } \ + } + +#define CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT \ + BLOCK = (CELL)CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT; \ + CmpPredicate f = (*_PREG)->u.plyys.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + if (!d0 || (*_PREG) == FAILCODE) { \ + if ((*_PREG) != FAILCODE) { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + } \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); \ + } + +#define CALL_BFUNC_YY_NOINTTERM_NOFAILCODE \ + (*_PREG) = (*_PREG)->u.plyys.f; + +#define CALL_BFUNC_YY_NOINTTERM_NOD0 \ + JMPNext(); + +#define CALL_BFUNC_YY_NOINTTERM_END \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); + +#define CALL_BFUNC_YY_CALL_BFUNC_YY_UNK \ + d1 = Deref(d1); + +#define P_EQUAL_INSTINIT \ + save_hb(); + +#define P_EQUAL_END \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); + +#include "p_dif.i" + +#include "p_eq.i" + +#define P_ARG_VV_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define P_ARG_VV_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.xxx.x1); \ + H[1] = XREG((*_PREG)->u.xxx.x2); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); +#endif + +#define P_ARG_VV_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_ARG_VV_ARG_ARG1_NVAR \ + FAILED = 0; \ + if (IsIntTerm(d0)) { \ + d0 = IntOfTerm(d0); \ + } else if (IsLongIntTerm(d0)) { \ + d0 = LongIntOfTerm(d0); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); \ + setregs(); \ + YAAM_FAIL; \ + } + +#define P_ARG_VV_TEST_D1 \ + if (!FAILED) { \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_ARG_VV_ARG_ARG2_NVAR \ + BLOCK = (CELL)P_ARG_VV_ARG_ARG2_NVAR; \ + if (IsApplTerm(d1)) { \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + XREG((*_PREG)->u.xxx.x) = pt0[d0]; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); \ + } \ + } \ + else if (IsPairTerm(d1)) { \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + YAAM_FAIL; \ + } \ + else { \ + XREG((*_PREG)->u.xxx.x) = pt0[d0-1]; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); \ + } \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } + +#define P_ARG_VV_ARG_ARG2_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_VV_ARG_ARG1_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_CV_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define P_ARG_CV_LOW_LEVEL_TRACER \ + CELL *Ho = HR; \ + Term t = MkIntegerTerm((*_PREG)->u.xxn.c); \ + H[0] = t; \ + H[1] = XREG((*_PREG)->u.xxn.xi); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); \ + H = HRo; +#endif + +#define P_ARG_CV_TEST_D1 \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = (*_PREG)->u.xxn.c; \ + d1 = XREG((*_PREG)->u.xxn.xi); + +#define P_ARG_CV_ARG_ARG2_VC_NVAR \ + BLOCK = (CELL)P_ARG_CV_ARG_ARG2_VC_NVAR; \ + FAILED = 0; \ + if (IsApplTerm(d1)) { \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + XREG((*_PREG)->u.xxn.x) = pt0[d0]; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); \ + } \ + } \ + else if (IsPairTerm(d1)) { \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + YAAM_FAIL; \ + } \ + else { \ + XREG((*_PREG)->u.xxn.x) = pt0[d0-1]; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); \ + } \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define P_ARG_CV_ARG_ARG2_VC_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_Y_VV_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define P_ARG_Y_VV_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.yxx.x1); \ + H[1] = XREG((*_PREG)->u.yxx.x2); \ + H[2] = YREG[(*_PREG)->u.yxx.y]; \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); +#endif + +#define P_ARG_Y_VV_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_ARG_Y_VV_ARG_Y_ARG1_NVAR \ + FAILED = 0; \ + if (IsIntTerm(d0)) { \ + d0 = IntOfTerm(d0); \ + } else if (IsLongIntTerm(d0)) { \ + d0 = LongIntOfTerm(d0); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); \ + setregs(); \ + YAAM_FAIL; \ + } + +#define P_ARG_Y_VV_TEST_D1 \ + if (!FAILED) { \ + d1 = XREG((*_PREG)->u.yxx.x2); + +#define P_ARG_Y_VV_ARG_Y_ARG2_NVAR \ + BLOCK = (CELL)P_ARG_Y_VV_ARG_Y_ARG2_NVAR; \ + if (IsApplTerm(d1)) { \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt1,pt0[d0]); \ + GONext(); \ + } \ + } \ + else if (IsPairTerm(d1)) { \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + YAAM_FAIL; \ + } \ + else { \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt1,pt0[d0-1]); \ + GONext(); \ + } \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } + +#define P_ARG_Y_VV_ARG_Y_ARG2_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_Y_VV_ARG_Y_ARG1_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_Y_CV_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_ARG_Y_CV_LOW_LEVEL_TRACER \ + CELL *Ho = HR; \ + Term t = MkIntegerTerm((*_PREG)->u.yxn.c); \ + H[0] = t; \ + H[1] = XREG((*_PREG)->u.yxn.xi); \ + H[2] = YREG[(*_PREG)->u.yxn.y]; \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); \ + H = HRo; +#endif + +#define P_ARG_Y_CV_TEST_D1 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = (*_PREG)->u.yxn.c; \ + d1 = XREG((*_PREG)->u.yxn.xi); + +#define P_ARG_Y_CV_D1APPL_INIT \ + pt0 = RepAppl(d1); \ + d1 = *pt0; + +#define P_ARG_Y_CV_D1APPL_END \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt1,pt0[d0]); \ + GONext(); + +#define P_ARG_Y_CV_D1PAIR_INIT \ + pt0 = RepPair(d1); + +#define P_ARG_Y_CV_D1PAIR_LESS0 \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); + +#define P_ARG_Y_CV_D1PAIR_END \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt1,pt0[d0-1]); \ + GONext(); + +#define P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_VV_LOW_LEVEL_TRACER \ + RESET_VARIABLE(HR); \ + H[1] = XREG((*_PREG)->u.xxx.x1); \ + H[2] = XREG((*_PREG)->u.xxx.x2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2S_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_FUNC2S_VV_TEST_D1 \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_FUNC2S_VV_D1INT \ + d1 = IntegerOfTerm(d1); + +#define P_FUNC2S_VV_D1NOTINT \ + saveregs(); + +#define P_FUNC2S_VV_D1BIGINT \ + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + +#define P_FUNC2S_VV_D1NOTBIGINT \ + Yap_Error(TYPE_ERROR_INTEGER, d1, "functor/3"); + +#define P_FUNC2S_VV_D1NOTINT_END \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_D0NOTATOMIC \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_FIRSTIFOK \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxx),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VV_SECONDIFOK_D0NOTATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_SECONDIFOK_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT \ + saveregs(); + +#define P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF \ + setregs(); + +#define P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_VV_SECONDIFOK_END \ + H = pt1; \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxx),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VV_THIRDIFOK \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxx),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VV_ELSE \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_FUNC2S_UNK2 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_FUNC2S_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_CV_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_CV_LOW_LEVEL_TRACER \ + RESET_VARIABLE(HR); \ + H[1] = (*_PREG)->u.xxc.c; \ + H[2] = XREG((*_PREG)->u.xxc.xi); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2S_CV_TEST_D1 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = (*_PREG)->u.xxc.c; \ + d1 = XREG((*_PREG)->u.xxc.xi); + +#define P_FUNC2S_CV_D1INT \ + d1 = IntegerOfTerm(d1); + +#define P_FUNC2S_CV_D1NOTINT \ + saveregs(); + +#define P_FUNC2S_CV_D1NOINT_D1BIGINT \ + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + +#define P_FUNC2S_CV_D1NOTBIGINT \ + Yap_Error(TYPE_ERROR_INTEGER,d1,"functor/3"); + +#define P_FUNC2S_CV_POST_IF \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_CV_FIRSTIFOK \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + XREG((*_PREG)->u.xxc.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxc),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_CV_D1GREATER_D0NOTATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_CV_D1GREATER_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_CV_D1GREATER_POST_IF \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_CV_D1GREATER_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_CV_D1GREATER_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_CV_D1GREATER_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_CV_D1GREATER_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_CV_D1GREATER_END \ + H = pt1; \ + XREG((*_PREG)->u.xxc.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxc),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_CV_D1ISZERO \ + XREG((*_PREG)->u.xxc.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxc),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_CV_ELSE \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_CV_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VC_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_VC_LOW_LEVEL_TRACER \ + Term ti; \ + CELL *hi = HR; \ + ti = MkIntegerTerm((*_PREG)->u.xxn.c); \ + RESET_VARIABLE(HR); \ + H[1] = XREG((*_PREG)->u.xxn.xi); \ + H[2] = ti; \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); \ + H = hi; +#endif + +#define P_FUNC2S_VC_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_FUNC2S_VC_FUNC2S_NVAR_VC \ + d1 = (*_PREG)->u.xxn.c; + +#define P_FUNC2S_VC_D0NOATOMIC \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VC_EQUALS \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxn),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VC_D1ISZERO \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxn),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VC_D0NOATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VC_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_VC_POST_ELSE \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_VC_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_VC_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_VC_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_VC_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_VC_END1 \ + HR = pt1; \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxn),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VC_END2 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_Y_VV_LOW_LEVEL_TRACER \ + RESET_VARIABLE(HR); \ + H[1] = XREG((*_PREG)->u.yxx.x1); \ + H[2] = XREG((*_PREG)->u.yxx.x2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2S_Y_VV_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_FUNC2S_Y_VV_TEST_D1 \ + d1 = XREG((*_PREG)->u.yxx.x2); + +#define P_FUNC2S_Y_VV_D1INT \ + d1 = IntegerOfTerm(d1); + +#define P_FUNC2S_Y_VV_D1NOTINT \ + saveregs(); + +#define P_FUNC2S_Y_VV_D1BIGINT \ + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + +#define P_FUNC2S_Y_VV_D1NOTBIGINT \ + Yap_Error(TYPE_ERROR_INTEGER,d1,"functor/3"); + +#define P_FUNC2S_Y_VV_POST_IF \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_D0NOATOMIC \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_EQUALS \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxx),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VV_D1GREATER_D0NOATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_D1GREATER_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_Y_VV_D1GREATER_POST_ELSE \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_Y_VV_D1GREATER_END \ + H = pt1; \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxx),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VV_D1ISZERO \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxx),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VV_ELSE \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_END1 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_END2 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_CV_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_Y_CV_LOW_LEVEL_TRACER \ + RESET_VARIABLE(HR); \ + H[1] = (*_PREG)->u.yxn.c; \ + H[2] = XREG((*_PREG)->u.yxn.xi); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2S_Y_CV_TEST_D1 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = (*_PREG)->u.yxn.c; \ + d1 = XREG((*_PREG)->u.yxn.xi); + +#define P_FUNC2S_Y_CV_D1INT \ + d1 = IntegerOfTerm(d1); + +#define P_FUNC2S_Y_CV_D1NOTINT \ + saveregs(); + +#define P_FUNC2S_Y_CV_D1BIGINT \ + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + +#define P_FUNC2S_Y_CV_D1NOTBIGINT \ + Yap_Error(TYPE_ERROR_INTEGER,d1,"functor/3"); + +#define P_FUNC2S_Y_CV_POST_IF \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_CV_EQUALS \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_CV_D1GREATER_D0NOATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_CV_D1GREATER_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_Y_CV_D1GREATER_POST_ELSE \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_Y_CV_D1GREATER_END \ + H = pt1; \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_CV_D1ISZERO \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_CV_ELSE \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_CV_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VC_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_Y_VC_LOW_LEVEL_TRACER \ + Term ti; \ + CELL *hi = HR; \ + ti = MkIntegerTerm((Int)((*_PREG)->u.yxn.c)); \ + RESET_VARIABLE(HR); \ + H[1] = XREG((*_PREG)->u.yxn.xi); \ + H[2] = ti; \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); \ + H = hi; +#endif + +#define P_FUNC2S_Y_VC_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC \ + d1 = (*_PREG)->u.yxn.c; + +#define P_FUNC2S_Y_VC_D0NOATOMIC \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VC_EQUALS \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VC_D1ISZERO \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VC_D0NOATOM1 \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VC_D0NOATOM2 \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VC_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_Y_VC_POST_ELSE \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_Y_VC_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_Y_VC_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_Y_VC_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_Y_VC_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_Y_VC_END1 \ + HR = pt1; \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VC_END2 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2F_XX_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2F_XX_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.xxx.x); \ + RESET_VARIABLE(HR+1); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2F_XX_TEST_D0 \ + register CELL d0; \ + register CELL* pt1; \ + d0 = XREG((*_PREG)->u.xxx.x); + +#define P_FUNC2F_XX_D0APPL \ + Functor d1 = FunctorOfTerm(d0); + +#define P_FUNC2F_XX_D0APPL_D1EXTFUNC \ + XREG((*_PREG)->u.xxx.x1) = d0; \ + XREG((*_PREG)->u.xxx.x2) = MkIntTerm(0); \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_FUNC2F_XX_D0APPL_END \ + XREG((*_PREG)->u.xxx.x1) = MkAtomTerm(NameOfFunctor(d1)); \ + XREG((*_PREG)->u.xxx.x2) = MkIntegerTerm(ArityOfFunctor(d1)); \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + + +#define P_FUNC2F_XX_D0PAIR \ + XREG((*_PREG)->u.xxx.x1) = TermDot; \ + XREG((*_PREG)->u.xxx.x2) = MkIntTerm(2); \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_FUNC2F_XX_D0NOCOMPOUND \ + XREG((*_PREG)->u.xxx.x1) = d0; \ + XREG((*_PREG)->u.xxx.x2) = MkIntTerm(0); \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_FUNC2F_XX_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2F_XY_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2F_XY_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.xxy.x); \ + RESET_VARIABLE(HR+1); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2F_XY_TEST_D0 \ + register CELL d0; \ + register CELL *pt1; \ + d0 = XREG((*_PREG)->u.xxy.x); + +#define P_FUNC2F_XY_D0APPL \ + Functor d1 = FunctorOfTerm(d0); \ + CELL *pt0 = YREG+(*_PREG)->u.xxy.y2; + +#define P_FUNC2F_XY_D0APPL_D1EXTFUNC \ + XREG((*_PREG)->u.xxy.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxy); \ + INITIALIZE_PERMVAR(pt0, MkIntTerm(0)); \ + GONext(); + +#define P_FUNC2F_XY_D0APPL_END \ + XREG((*_PREG)->u.xxy.x1) = MkAtomTerm(NameOfFunctor(d1)); \ + (*_PREG) = NEXTOP((*_PREG), xxy); \ + INITIALIZE_PERMVAR(pt0, MkIntegerTerm(ArityOfFunctor(d1))); \ + GONext(); + +#define P_FUNC2F_XY_D0PAIR \ + CELL *pt0 = YREG+(*_PREG)->u.xxy.y2; \ + XREG((*_PREG)->u.xxy.x1) = TermDot; \ + (*_PREG) = NEXTOP((*_PREG), xxy); \ + INITIALIZE_PERMVAR(pt0, MkIntTerm(2)); \ + GONext(); + +#define P_FUNC2F_XY_D0NOCOMPOUND \ + CELL *pt0 = YREG+(*_PREG)->u.xxy.y2; \ + XREG((*_PREG)->u.xxy.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxy); \ + INITIALIZE_PERMVAR(pt0, MkIntTerm(0)); \ + GONext(); + +#define P_FUNC2F_XY_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2F_YX_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2F_YX_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.yxx.x2); \ + RESET_VARIABLE(HR+1); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2F_YX_TEST_D0 \ + register CELL d0; \ + register CELL *pt1; \ + d0 = XREG((*_PREG)->u.yxx.x2); + +#define P_FUNC2F_YX_D0APPL \ + Functor d1 = FunctorOfTerm(d0); \ + CELL *pt0 = YREG+(*_PREG)->u.yxx.y; + +#define P_FUNC2F_YX_D0APPL_D1EXTFUNC \ + XREG((*_PREG)->u.yxx.x1) = MkIntTerm(0); \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0, d0); \ + GONext(); + +#define P_FUNC2F_YX_D0APPL_END \ + XREG((*_PREG)->u.yxx.x1) = MkIntegerTerm(ArityOfFunctor(d1)); \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1))); \ + GONext(); + +#define P_FUNC2F_YX_D0PAIR \ + CELL *pt0 = YREG+(*_PREG)->u.yxx.y; \ + XREG((*_PREG)->u.yxx.x1) = MkIntTerm(2); \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0 ,TermDot); \ + GONext(); + +#define P_FUNC2F_YX_D0NOCOMPOUND \ + CELL *pt0 = YREG+(*_PREG)->u.yxx.y; \ + XREG((*_PREG)->u.yxx.x1) = MkIntTerm(0); \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0, d0); \ + GONext(); + +#define P_FUNC2F_YX_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2F_YY_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2F_YY_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.yyx.x); \ + RESET_VARIABLE(HR+1); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2F_YY_TEST_D0 \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.yyx.x); + +#define P_FUNC2F_YY_D0APPL \ + Functor d1 = FunctorOfTerm(d0); \ + CELL *pt0 = YREG+(*_PREG)->u.yyx.y1; \ + CELL *pt1 = YREG+(*_PREG)->u.yyx.y2; + +#define P_FUNC2F_YY_D0APPL_D1EXTFUNC \ + (*_PREG) = NEXTOP((*_PREG), yyx); \ + INITIALIZE_PERMVAR(pt0, d0); \ + INITIALIZE_PERMVAR(pt1, MkIntTerm(0)); \ + GONext(); + +#define P_FUNC2F_YY_D0APPL_END \ + (*_PREG) = NEXTOP((*_PREG), yyx); \ + INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1))); \ + INITIALIZE_PERMVAR(pt1, MkIntegerTerm(ArityOfFunctor(d1))); \ + GONext(); + +#define P_FUNC2F_YY_D0PAIR \ + CELL *pt0 = YREG+(*_PREG)->u.yyx.y1; \ + CELL *pt1 = YREG+(*_PREG)->u.yyx.y2; \ + (*_PREG) = NEXTOP((*_PREG), yyx); \ + INITIALIZE_PERMVAR(pt0, TermDot); \ + INITIALIZE_PERMVAR(pt1, MkIntTerm(2)); \ + GONext(); + +#define P_FUNC2F_YY_D0NOCOMPOUND \ + CELL *pt0 = YREG+(*_PREG)->u.yyx.y1; \ + CELL *pt1 = YREG+(*_PREG)->u.yyx.y2; \ + (*_PREG) = NEXTOP((*_PREG), yyx); \ + INITIALIZE_PERMVAR(pt0, d0); \ + INITIALIZE_PERMVAR(pt1, MkIntTerm(0)); \ + GONext(); + +#define P_FUNC2F_YY_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#include "p_functor.i" diff --git a/JIT/HPP/yaam_primitive_predicates_d.h b/JIT/HPP/yaam_primitive_predicates_d.h new file mode 100644 index 000000000..c364c362f --- /dev/null +++ b/JIT/HPP/yaam_primitive_predicates_d.h @@ -0,0 +1,3187 @@ +#define P_ATOM_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_ATOM_X_ATOM \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); \ + +#define P_ATOM_X_NOATOM \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_ATOM_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_ATOM_Y_IFOK \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_ATOM_Y_NOIF \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_ATOM_Y_END \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_ATOMIC_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_ATOMIC_X_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_ATOMIC_X_VAR \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_ATOMIC_X_END \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_ATOMIC_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_ATOMIC_Y_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_ATOMIC_Y_VAR \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_ATOMIC_Y_END \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_INTEGER_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); \ + +#define P_INTEGER_X_INTEGER_X_NVAR_OK \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_INTEGER_X_INTEGER_X_NVAR_NOOK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_INTEGER_X_INTEGER_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_INTEGER_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_INTEGER_Y_INTEGER_Y_NVAR_OK \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_INTEGER_Y_INTEGER_Y_NVAR_NOOK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_INTEGER_Y_INTEGER_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_NONVAR_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_NONVAR_X_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_NONVAR_X_NONONVAR \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NONVAR_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_NONVAR_Y_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_NONVAR_Y_NONONVAR \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_NUMBER_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_NUMBER_X_INT \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_NUMBER_X_FUNCTORINT \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_NUMBER_X_FUNCTORDEFAULT \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NUMBER_X_POST_IF \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NUMBER_X_NUMBER_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NUMBER_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_NUMBER_Y_INT \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_NUMBER_Y_FUNCTORINT \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_NUMBER_Y_FUNCTORDEFAULT \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_NUMBER_Y_POST_IF \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_NUMBER_Y_NUMBER_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_VAR_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_VAR_X_NONVAR \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_VAR_X_VAR \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_VAR_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_VAR_Y_NONVAR \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_VAR_Y_VAR \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_DB_REF_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_DB_REF_X_DBREF \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_DB_REF_X_NODBREF \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_DB_REF_X_DBREF_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_DB_REF_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_DB_REF_Y_DBREF \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_DB_REF_Y_NODBREF \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_DB_REF_Y_DBREF_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_PRIMITIVE_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_PRIMITIVE_X_PRIMITIVE \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_PRIMITIVE_X_NOPRIMITIVE \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_PRIMITIVE_X_PRIMI_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_PRIMITIVE_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_PRIMITIVE_Y_PRIMITIVE \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_PRIMITIVE_Y_NOPRIMITIVE \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_PRIMITIVE_Y_PRIMI_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_COMPOUND_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_COMPOUND_X_PAIR \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_COMPOUND_X_APPL_IFOK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_COMPOUND_X_APPL \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_COMPOUND_X_NOAPPL \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_COMPOUND_X_COMPOUND_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_COMPOUND_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_COMPOUND_Y_PAIR \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_COMPOUND_Y_APPL_IFOK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_COMPOUND_Y_APPL \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_COMPOUND_Y_NOAPPL \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_COMPOUND_Y_COMPOUND_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_FLOAT_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xl.x); + +#define P_FLOAT_X_FLOAT \ + (*_PREG) = NEXTOP((*_PREG), xl); \ + GONext(); + +#define P_FLOAT_X_POST_IF \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_FLOAT_X_FLOAT_X_UNK \ + (*_PREG) = (*_PREG)->u.xl.F; \ + GONext(); + +#define P_FLOAT_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + pt0 = YREG + (*_PREG)->u.yl.y; \ + d0 = *pt0; + +#define P_FLOAT_Y_FLOAT \ + (*_PREG) = NEXTOP((*_PREG), yl); \ + GONext(); + +#define P_FLOAT_Y_POST_IF \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_FLOAT_Y_FLOAT_Y_UNK \ + (*_PREG) = (*_PREG)->u.yl.F; \ + GONext(); + +#define P_PLUS_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_PLUS_VV_PLUS_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_PLUS_VV_PLUS_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1)); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_PLUS_VV_PLUS_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_PLUS_VV_PLUS_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is _+B"); \ + setregs(); \ + FAIL(); + +#define P_PLUS_VV_PLUS_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); \ + setregs(); \ + FAIL(); + +#define P_PLUS_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_PLUS_VC_PLUS_VC_NVAR_INT \ + d0 = MkIntegerTerm(IntOfTerm(d0) + d1); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_PLUS_VC_PLUS_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_PLUS_VC_PLUS_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_PLUS_Y_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_PLUS_Y_VV_PLUS_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1)); \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_PLUS_Y_VV_PLUS_Y_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_PLUS_Y_VV_PLUS_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); \ + setregs(); \ + FAIL(); + +#define P_PLUS_Y_VV_PLUS_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A+B"); \ + setregs(); \ + FAIL(); + +#define P_PLUS_Y_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_PLUS_Y_VC_PLUS_Y_VC_NVAR_INT \ + d0 = MkIntegerTerm(IntOfTerm(d0) + d1); \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_PLUS_Y_VC_PLUS_Y_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_PLUS_Y_VC_PLUS_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A + " Int_FORMAT, (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_MINUS_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_MINUS_VV_MINUS_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_MINUS_VV_MINUS_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1)); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_MINUS_VV_MINUS_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_MINUS_VV_MINUS_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); + +#define P_MINUS_VV_MINUS_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); + +#define P_MINUS_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_MINUS_CV_MINUS_CV_NVAR_INT \ + d0 = MkIntegerTerm(d1 - IntOfTerm(d0)); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_MINUS_CV_MINUS_CV_NVAR_NOINT \ + saveregs(); \ + d0 = p_minus(MkIntegerTerm(d1),Yap_Eval(d0)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_MINUS_CV_MINUS_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "-A", (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_MINUS_Y_VV_MINUS_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_MINUS_Y_VV_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1)); + +#define P_MINUS_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_MINUS_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_MINUS_Y_VV_MINUS_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_VV_MINUS_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A-B"); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_MINUS_Y_CV_MINUS_Y_CV_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_MINUS_Y_CV_INTTERM \ + d0 = MkIntegerTerm(d1 - IntOfTerm(d0)); + +#define P_MINUS_Y_CV_NOINTTERM \ + saveregs(); \ + d0 = p_minus(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); + +#define P_MINUS_Y_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_MINUS_Y_CV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_MINUS_Y_CV_MINUS_Y_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "-A", (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_TIMES_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_TIMES_VV_TIMES_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_TIMES_VV_TIMES_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = times_int(IntOfTerm(d0), IntOfTerm(d1)); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_TIMES_VV_TIMES_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_TIMES_VV_TIMES_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); + +#define P_TIMES_VV_TIMES_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); + +#define P_TIMES_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_TIMES_VC_TIMES_VC_NVAR_INT \ + d0 = times_int(IntOfTerm(d0), d1); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_TIMES_VC_TIMES_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_TIMES_VC_TIMES_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A* " Int_FORMAT, (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_TIMES_Y_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_TIMES_Y_VV_TIMES_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_TIMES_Y_VV_INTTERM \ + d0 = times_int(IntOfTerm(d0), IntOfTerm(d1)); + +#define P_TIMES_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_TIMES_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_TIMES_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_TIMES_Y_VV_TIMES_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); + +#define P_TIMES_Y_VV_TIMES_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A*B"); \ + setregs(); \ + FAIL(); + +#define P_TIMES_Y_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_TIMES_Y_VC_TIMES_Y_VC_NVAR_INT \ + d0 = times_int(IntOfTerm(d0), d1); \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_TIMES_Y_VC_TIMES_Y_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_TIMES_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_TIMES_Y_VC_TIMES_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A* " Int_FORMAT, (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_DIV_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_DIV_VV_DIV_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_DIV_VV_DIV_VV_NVAR_NVAR_INT \ + BLOCK = (CELL)P_DIV_VV_DIV_VV_NVAR_NVAR_INT; \ + FAILED = 0; \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + Int div = IntOfTerm(d1); \ + if (div == 0) { \ + saveregs(); \ + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); \ + setregs(); \ + YAAM_FAIL; \ + } \ + else { \ + d0 = MkIntTerm(IntOfTerm(d0) / div); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); \ + } + +#define P_DIV_VV_DIV_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_div(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_DIV_VV_DIV_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_VV_DIV_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_DIV_VC_DIV_VC_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_DIV_VC_INTTERM \ + d0 = MkIntTerm(IntOfTerm(d0) / d1); + +#define P_DIV_VC_NOINTTERM \ + saveregs(); \ + d0 = p_div(Yap_Eval(d0),MkIntegerTerm(d1)); \ + setregs(); + +#define P_DIV_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_VC_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_DIV_VC_DIV_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_DIV_CV_DIV_CV_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_DIV_CV_INTTERM_INIT \ + Int div = IntOfTerm(d0); + +#define P_DIV_CV_INTTERM_DIVEQUALS0 \ + saveregs(); \ + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); \ + setregs(); \ + FAIL(); + +#define P_DIV_CV_INTTERM_END \ + d0 = MkIntegerTerm(d1 / div); + +#define P_DIV_CV_NOINTTERM \ + saveregs(); \ + d0 = p_div(MkIntegerTerm(d1),Yap_Eval(d0)); + +#define P_DIV_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_CV_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_DIV_CV_DIV_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "// A", (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_DIV_Y_VV_DIV_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_DIV_Y_VV_INTTERM_INIT \ + Int div = IntOfTerm(d1); + +#define P_DIV_Y_VV_INTTERM_DIVEQUALS0 \ + saveregs(); \ + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VV_INTTERM_END \ + d0 = MkIntTerm(IntOfTerm(d0) / div); + +#define P_DIV_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_div(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_DIV_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_DIV_Y_VV_DIV_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VV_DIV_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_DIV_Y_VC_DIV_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_DIV_Y_VC_INTTERM \ + d0 = MkIntTerm(IntOfTerm(d0)/d1); + +#define P_DIV_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_div(Yap_Eval(d0),MkIntegerTerm(d1)); \ + setregs(); + +#define P_DIV_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_DIV_Y_VC_DIV_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A//B"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_DIV_Y_CV_DIV_Y_CV_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_DIV_Y_CV_INTTERM_INIT \ + Int div = IntOfTerm(d0); + +#define P_DIV_Y_CV_INTTERM_DIVEQUALS0 \ + saveregs(); \ + Yap_NilError(EVALUATION_ERROR_ZERO_DIVISOR,"// /2"); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_CV_INTTERM_END \ + d0 = MkIntegerTerm(d1 / div); + +#define P_DIV_Y_CV_NOINTTERM \ + saveregs(); \ + d0 = p_div(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); + +#define P_DIV_Y_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_DIV_Y_CV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_DIV_Y_CV_DIV_Y_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is " Int_FORMAT "// A", (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_AND_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_AND_VV_AND_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_AND_VV_AND_VV_NVAR_NVAR_INT \ + if (!IsIntTerm(d0) || !IsIntTerm(d1)) { BACK(); } \ + d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1)); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_AND_VV_AND_VV_NVAR_NVAR_NOINT \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_AND_VV_AND_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); + +#define P_AND_VV_AND_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); + +#define P_AND_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_AND_VC_AND_VC_NVAR_INT \ + d0 = MkIntegerTerm(IntOfTerm(d0) & d1); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_AND_VC_AND_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_AND_VC_AND_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A /\\ " Int_FORMAT , (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_AND_Y_VV_AND_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_AND_Y_VV_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1)); + +#define P_AND_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_AND_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_AND_Y_VV_AND_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VV_AND_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A/\\B"); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_AND_Y_VC_AND_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_AND_Y_VC_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) & d1); + +#define P_AND_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_AND_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_AND_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_AND_Y_VC_AND_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A /\\ " Int_FORMAT , (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_OR_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_OR_VV_OR_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_OR_VV_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1)); + +#define P_OR_VV_NOINTTERM \ + saveregs(); \ + d0 = p_or(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_OR_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_OR_VV_NVAR_END \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_OR_VV_OR_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); \ + setregs(); \ + FAIL(); + +#define P_OR_VV_OR_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); \ + setregs(); \ + FAIL(); + +#define P_OR_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_OR_VC_OR_VC_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_OR_VC_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) | d1); + +#define P_OR_VC_NOINTTERM \ + saveregs(); \ + d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1)); + +#define P_OR_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_OR_VC_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_OR_VC_OR_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A \\/ " Int_FORMAT , (*_PREG)->u.xxn.c); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_OR_Y_VV_OR_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_OR_Y_VV_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1)); + +#define P_OR_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_or(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_OR_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_OR_Y_VV_OR_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VV_OR_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A\\/B"); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_OR_Y_VC_OR_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_OR_Y_VC_INTTERM \ + d0 = MkIntegerTerm(IntOfTerm(d0) | d1); + +#define P_OR_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_OR_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_OR_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_OR_Y_VC_OR_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A \\/ " Int_FORMAT , (*_PREG)->u.yxn.c); \ + setregs(); \ + FAIL(); + +#define P_SLL_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_SLL_VV_SLL_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_SLL_VV_INTTERM_INIT \ + Int i2 = IntOfTerm(d1); + +#define P_SLL_VV_INTTERM_LESS \ + d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2)); + +#define P_SLL_VV_INTTERM_GREATER \ + d0 = do_sll(IntOfTerm(d0),i2); + +#define P_SLL_VV_NOINTTERM \ + saveregs(); \ + d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_SLL_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_VV_NVAR_END \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_SLL_VV_SLL_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxn.xi); + +#define P_SLL_VC_SLL_VC_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_SLL_VC_INTTERM \ + d0 = do_sll(IntOfTerm(d0), (Int)d1); + +#define P_SLL_VC_NOINTTERM \ + saveregs(); \ + d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_SLL_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_VC_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLL_VC_SLL_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_SLL_CV_SLL_CV_NVAR_INT \ + Int i2 = IntOfTerm(d0); \ + if (i2 < 0) { \ + d0 = MkIntegerTerm(SLR(d1, -i2)); \ + } else { \ + d0 = do_sll(d1,i2); \ + } \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLL_CV_SLL_CV_NVAR_NOINT \ + saveregs(); \ + d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); \ + XREG((*_PREG->u.xxn.x) = d0; \ + (*_PREG = NEXTOP((*_PREG, xxn); \ + GONext(); + +#define P_SLL_CV_SLL_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.yxx.x1); + +#define P_SLL_Y_VV_SLL_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_SLL_Y_VV_INTTERM_INIT \ + Int i2 = IntOfTerm(d1); + +#define P_SLL_Y_VV_INTERM_LESS \ + d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2)); + +#define P_SLL_Y_VV_INTTERM_GREATER \ + d0 = do_sll(IntOfTerm(d0),i2); + +#define P_SLL_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_SLL_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLL_Y_VV_SLL_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.yxn.xi); + +#define P_SLL_Y_VC_SLL_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_SLL_Y_VC_INTTERM \ + d0 = do_sll(IntOfTerm(d0), Yap_Eval(d1)); + +#define P_SLL_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_SLL_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLL_Y_VC_SLL_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.yxn.xi); + +#define P_SLL_Y_CV_SLL_Y_CV_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_SLL_Y_CV_INTTERM_INIT \ + Int i2 = IntOfTerm(d0); + +#define P_SLL_Y_CV_INTTERM_LESS \ + d0 = MkIntegerTerm(SLR(d1, -i2)); + +#define P_SLL_Y_CV_INTTERM_GREATER \ + d0 = do_sll(d1,i2); + +#define P_SLL_Y_CV_NOINTTERM \ + saveregs(); \ + d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(0)); \ + setregs(); + +#define P_SLL_Y_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLL_Y_CV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLL_Y_CV_SLL_Y_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A<u.xxx.x1); + +#define P_SLR_VV_SLR_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_SLR_VV_INTTERM_INIT \ + Int i2 = IntOfTerm(d1); + +#define P_SLR_VV_INTTERM_LESS \ + d0 = do_sll(IntOfTerm(d0), -i2); + +#define P_SLR_VV_INTTERM_GREATER \ + d0 = MkIntTerm(SLR(IntOfTerm(d0), i2)); + +#define P_SLR_VV_NOINTTERM \ + saveregs(); \ + d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_SLR_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_VV_NVAR_END \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_SLR_VV_SRL_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_VV_SRL_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_SLR_VC_SLR_VC_NVAR_INT \ + d0 = MkIntTerm(SLR(IntOfTerm(d0), d1)); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLR_VC_SLR_VC_NVAR_NOINT \ + saveregs(); \ + d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLR_VC_SRL_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_SLR_CV_SLR_CV_NVAR \ + Int d1 = (*_PREG)->u.xxn.c; + +#define P_SLR_CV_INTTERM_INIT \ + Int i2 = IntOfTerm(d0); + +#define P_SLR_CV_INTTERM_LESS \ + d0 = do_sll(d1, -i2); + +#define P_SLR_CV_INTTERM_GREATER \ + d0 = MkIntegerTerm(SLR(d1, i2)); + +#define P_SLR_CV_NOINTTERM \ + saveregs(); \ + d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); + +#define P_SLR_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_CV_NVAR_END \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); + +#define P_SLR_CV_SLR_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL8 pt0; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_SLR_Y_VV_SLR_Y_VV_NVAR \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_SLR_Y_VV_INTTERM_INIT \ + Int i2 = IntOfTerm(d1); + +#define P_SLR_Y_VV_INTTERM_LESS \ + d0 = do_sll(IntOfTerm(d0), -i2); + +#define P_SLR_Y_VV_INTTERM_GREATER \ + d0 = MkIntTerm(SLR(IntOfTerm(d0), i2)); + +#define P_SLR_Y_VV_NOINTTERM \ + saveregs(); \ + d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1)); \ + setregs(); + +#define P_SLR_Y_VV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLR_Y_VV_SLR_Y_VV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VV_SLR_Y_VV_NVAR_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL8 pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_SLR_Y_VC_SLR_Y_VC_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_SLR_Y_VC_INTTERM \ + d0 = MkIntTerm(SLR(IntOfTerm(d0), d1)); + +#define P_SLR_Y_VC_NOINTTERM \ + saveregs(); \ + d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1)); \ + setregs(); + +#define P_SLR_Y_VC_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_VC_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLR_Y_VC_SLR_Y_VC_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); + +#define P_SLR_Y_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_SLR_Y_CV_SLR_Y_CV_NVAR \ + Int d1 = (*_PREG)->u.yxn.c; + +#define P_SLR_Y_CV_INTTERM_INIT \ + Int i2 = IntOfTerm(d0); + +#define P_SLR_Y_CV_INTTERM_LESS \ + d0 = do_sll(d1, -i2); + +#define P_SLR_Y_CV_INTTERM_GREATER \ + d0 = MkIntegerTerm(SLR(d1, i2)); + +#define P_SLR_Y_CV_NOINTTERM \ + saveregs(); \ + d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0)); \ + setregs(); + +#define P_SLR_Y_CV_D0EQUALS0L \ + saveregs(); \ + Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); \ + setregs(); \ + FAIL(); + +#define P_SLR_Y_CV_NVAR_END \ + pt0 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt0,d0); \ + GONext(); + +#define P_SLR_Y_CV_SLR_Y_CV_UNK \ + saveregs(); \ + Yap_NilError(INSTANTIATION_ERROR, "X is A>>B"); \ + setregs(); \ + FAIL(); + +#define CALL_BFUNC_XX_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL* pt0; \ + d0 = XREG((*_PREG)->u.plxxs.x1); + +#define CALL_BFUNC_XX_CALL_BFUNC_XX_NVAR \ + d1 = XREG((*_PREG)->u.plxxs.x2); + +#define CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT \ + BLOCK = (CELL)CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_INT; \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + COUNT flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plxxs.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + yamop *nextp = NEXTOP((*_PREG), plxxs); \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + else { \ + yamop *nextp = (*_PREG)->u.plxxs.f; \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + } \ + else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + yamop *nextp = NEXTOP((*_PREG), plxxs); \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + else { \ + yamop *nextp = (*_PREG)->u.plxxs.f; \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + } \ + else { \ + if (flags & EQ_OK_IN_CMP) { \ + yamop *nextp = NEXTOP((*_PREG), plxxs); \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + else { \ + yamop *nextp = (*_PREG)->u.plxxs.f; \ + (*_PREG) = nextp; \ + ALWAYS_GONext(); \ + } \ + } \ + } + +#define CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT \ + BLOCK = (CELL)CALL_BFUNC_XX_CALL_BFUNC_XX2_NVAR_NOINT; \ + CmpPredicate f = (*_PREG)->u.plxxs.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + if ((*_PREG) == FAILCODE) { \ + JMPNext(); \ + } \ + else if (!d0) { \ + (*_PREG) = (*_PREG)->u.plxxs.f; \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), plxxs); \ + JMPNext(); \ + } + +#define CALL_BFUNC_XX_CALL_BFUNC_XX_UNK \ + d1 = Deref(d1); + +#define CALL_BFUNC_YX_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.plxys.y; \ + d1 = XREG((*_PREG)->u.plxys.x); \ + d0 = *pt0; + +#define CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT \ + BLOCK = (CELL)CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_INT; \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + int flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plxys.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } else { \ + if (flags & EQ_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } \ + } + +#define CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT \ + BLOCK = (CELL)CALL_BFUNC_YX_CALL_BFUNC_YX2_NVAR_NOINT; \ + CmpPredicate f = (*_PREG)->u.plxys.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + if (!d0 || (*_PREG) == FAILCODE) { \ + if ((*_PREG) != FAILCODE) { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + } \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } + +#define CALL_BFUNC_YX_CALL_BFUNC_YX_UNK \ + d1 = Deref(d1); + +#define CALL_BFUNC_XY_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.plxys.y; \ + d0 = XREG((*_PREG)->u.plxys.x); \ + d1 = *pt0; + +#define CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT \ + BLOCK = (CELL)CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_INT; \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + int flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plxys.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } else { \ + if (flags & EQ_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + JMPNext(); \ + } \ + } \ + } + +#define CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT \ + BLOCK = (CELL)CALL_BFUNC_XY_CALL_BFUNC_XY2_NVAR_NOINT; \ + CmpPredicate f = (*_PREG)->u.plxys.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + if (!d0 || (*_PREG) == FAILCODE) { \ + if ((*_PREG) != FAILCODE) { \ + (*_PREG) = (*_PREG)->u.plxys.f; \ + } \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), plxys); \ + JMPNext(); \ + } + +#define CALL_BFUNC_XY_CALL_BFUNC_XY_UNK \ + d1 = Deref(d1); + +#define CALL_BFUNC_YY_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = YREG + (*_PREG)->u.plyys.y1; \ + pt1 = YREG + (*_PREG)->u.plyys.y2; \ + d0 = *pt0; \ + d1 = *pt1; + +#define CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT \ + BLOCK = (CELL)CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_INT; \ + if (IsIntTerm(d0) && IsIntTerm(d1)) { \ + int flags; \ + Int v = IntOfTerm(d0) - IntOfTerm(d1); \ + flags = (*_PREG)->u.plyys.flags; \ + if (v > 0) { \ + if (flags & GT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + JMPNext(); \ + } \ + } else if (v < 0) { \ + if (flags & LT_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + JMPNext(); \ + } \ + } else { \ + if (flags & EQ_OK_IN_CMP) { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); \ + } else { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + JMPNext(); \ + } \ + } \ + } + +#define CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT \ + BLOCK = (CELL)CALL_BFUNC_YY_CALL_BFUNC_YY2_NVAR_NOINT; \ + CmpPredicate f = (*_PREG)->u.plyys.p->cs.d_code; \ + saveregs(); \ + d0 = (CELL) (f) (d0,d1); \ + setregs(); \ + if (!d0 || (*_PREG) == FAILCODE) { \ + if ((*_PREG) != FAILCODE) { \ + (*_PREG) = (*_PREG)->u.plyys.f; \ + } \ + JMPNext(); \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); \ + } + +#define CALL_BFUNC_YY_NOINTTERM_NOFAILCODE \ + (*_PREG) = (*_PREG)->u.plyys.f; + +#define CALL_BFUNC_YY_NOINTTERM_NOD0 \ + JMPNext(); + +#define CALL_BFUNC_YY_NOINTTERM_END \ + (*_PREG) = NEXTOP((*_PREG), plyys); \ + JMPNext(); + +#define CALL_BFUNC_YY_CALL_BFUNC_YY_UNK \ + d1 = Deref(d1); + +#define P_EQUAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + save_hb(); + +#define P_EQUAL_END \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); + +#include "p_dif.i" + +#include "p_eq.i" + +#define P_ARG_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define P_ARG_VV_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.xxx.x1); \ + H[1] = XREG((*_PREG)->u.xxx.x2); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); +#endif + +#define P_ARG_VV_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_ARG_VV_ARG_ARG1_NVAR \ + FAILED = 0; \ + if (IsIntTerm(d0)) { \ + d0 = IntOfTerm(d0); \ + } else if (IsLongIntTerm(d0)) { \ + d0 = LongIntOfTerm(d0); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); \ + setregs(); \ + YAAM_FAIL; \ + } + +#define P_ARG_VV_TEST_D1 \ + if (!FAILED) { \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_ARG_VV_ARG_ARG2_NVAR \ + BLOCK = (CELL)P_ARG_VV_ARG_ARG2_NVAR; \ + if (IsApplTerm(d1)) { \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + XREG((*_PREG)->u.xxx.x) = pt0[d0]; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); \ + } \ + } \ + else if (IsPairTerm(d1)) { \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + YAAM_FAIL; \ + } \ + else { \ + XREG((*_PREG)->u.xxx.x) = pt0[d0-1]; \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); \ + } \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } + +#define P_ARG_VV_ARG_ARG2_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_VV_ARG_ARG1_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define P_ARG_CV_LOW_LEVEL_TRACER \ + CELL *Ho = HR; \ + Term t = MkIntegerTerm((*_PREG)->u.xxn.c); \ + H[0] = t; \ + H[1] = XREG((*_PREG)->u.xxn.xi); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); \ + H = HRo; +#endif + +#define P_ARG_CV_TEST_D1 \ + register CELL d0, d1; \ + register CELL *pt0; \ + d0 = (*_PREG)->u.xxn.c; \ + d1 = XREG((*_PREG)->u.xxn.xi); + +#define P_ARG_CV_ARG_ARG2_VC_NVAR \ + BLOCK = (CELL)P_ARG_CV_ARG_ARG2_VC_NVAR; \ + FAILED = 0; \ + if (IsApplTerm(d1)) { \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + XREG((*_PREG)->u.xxn.x) = pt0[d0]; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); \ + } \ + } \ + else if (IsPairTerm(d1)) { \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + YAAM_FAIL; \ + } \ + else { \ + XREG((*_PREG)->u.xxn.x) = pt0[d0-1]; \ + (*_PREG) = NEXTOP((*_PREG), xxn); \ + GONext(); \ + } \ + } \ + else { \ + YAAM_FAIL; \ + } + +#define P_ARG_CV_ARG_ARG2_VC_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_Y_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + +#ifdef LOW_LEVEL_TRACER +#define P_ARG_Y_VV_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.yxx.x1); \ + H[1] = XREG((*_PREG)->u.yxx.x2); \ + H[2] = YREG[(*_PREG)->u.yxx.y]; \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); +#endif + +#define P_ARG_Y_VV_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_ARG_Y_VV_ARG_Y_ARG1_NVAR \ + FAILED = 0; \ + if (IsIntTerm(d0)) { \ + d0 = IntOfTerm(d0); \ + } else if (IsLongIntTerm(d0)) { \ + d0 = LongIntOfTerm(d0); \ + } else { \ + saveregs(); \ + Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); \ + setregs(); \ + YAAM_FAIL; \ + } + +#define P_ARG_Y_VV_TEST_D1 \ + if (!FAILED) { \ + d1 = XREG((*_PREG)->u.yxx.x2); + +#define P_ARG_Y_VV_ARG_Y_ARG2_NVAR \ + BLOCK = (CELL)P_ARG_Y_VV_ARG_Y_ARG2_NVAR; \ + if (IsApplTerm(d1)) { \ + pt0 = RepAppl(d1); \ + d1 = *pt0; \ + if (IsExtensionFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else if ((Int)d0 <= 0 || \ + (Int)d0 > ArityOfFunctor((Functor) d1)) { \ + YAAM_FAIL; \ + } \ + else { \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt1,pt0[d0]); \ + GONext(); \ + } \ + } \ + else if (IsPairTerm(d1)) { \ + pt0 = RepPair(d1); \ + if (d0 != 1 && d0 != 2) { \ + if ((Int)d0 < 0) { \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); \ + } \ + YAAM_FAIL; \ + } \ + else { \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt1,pt0[d0-1]); \ + GONext(); \ + } \ + } \ + else { \ + YAAM_FAIL; \ + } \ + } + +#define P_ARG_Y_VV_ARG_Y_ARG2_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_Y_VV_ARG_Y_ARG1_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "arg 1 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_ARG_Y_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_ARG_Y_CV_LOW_LEVEL_TRACER \ + CELL *Ho = HR; \ + Term t = MkIntegerTerm((*_PREG)->u.yxn.c); \ + H[0] = t; \ + H[1] = XREG((*_PREG)->u.yxn.xi); \ + H[2] = YREG[(*_PREG)->u.yxn.y]; \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); \ + H = HRo; +#endif + +#define P_ARG_Y_CV_TEST_D1 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = (*_PREG)->u.yxn.c; \ + d1 = XREG((*_PREG)->u.yxn.xi); + +#define P_ARG_Y_CV_D1APPL_INIT \ + pt0 = RepAppl(d1); \ + d1 = *pt0; + +#define P_ARG_Y_CV_D1APPL_END \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt1,pt0[d0]); \ + GONext(); + +#define P_ARG_Y_CV_D1PAIR_INIT \ + pt0 = RepPair(d1); + +#define P_ARG_Y_CV_D1PAIR_LESS0 \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, \ + MkIntegerTerm(d0),"arg 1 of arg/3"); \ + setregs(); + +#define P_ARG_Y_CV_D1PAIR_END \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP((*_PREG), yxn); \ + INITIALIZE_PERMVAR(pt1,pt0[d0-1]); \ + GONext(); + +#define P_ARG_Y_CV_ARG_Y_ARG2_VC_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1,"arg 2 of arg/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_INSTINIT + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_VV_LOW_LEVEL_TRACER \ + RESET_VARIABLE(HR); \ + H[1] = XREG((*_PREG)->u.xxx.x1); \ + H[2] = XREG((*_PREG)->u.xxx.x2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2S_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xxx.x1); + +#define P_FUNC2S_VV_TEST_D1 \ + d1 = XREG((*_PREG)->u.xxx.x2); + +#define P_FUNC2S_VV_D1INT \ + d1 = IntegerOfTerm(d1); + +#define P_FUNC2S_VV_D1NOTINT \ + saveregs(); + +#define P_FUNC2S_VV_D1BIGINT \ + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + +#define P_FUNC2S_VV_D1NOTBIGINT \ + Yap_Error(TYPE_ERROR_INTEGER, d1, "functor/3"); + +#define P_FUNC2S_VV_D1NOTINT_END \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_D0NOTATOMIC \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_FIRSTIFOK \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxx),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VV_SECONDIFOK_D0NOTATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_SECONDIFOK_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_VV_SECONDIFOK_POST_D0ATOM \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_INIT \ + saveregs(); + +#define P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_VV_SECONDIFOK_FIRSTIFOK_NOIF \ + setregs(); + +#define P_FUNC2S_VV_SECONDIFOK_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_VV_SECONDIFOK_END \ + H = pt1; \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxx),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VV_THIRDIFOK \ + XREG((*_PREG)->u.xxx.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxx),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VV_ELSE \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_FUNC2S_UNK2 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VV_FUNC2S_UNK \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_CV_LOW_LEVEL_TRACER \ + RESET_VARIABLE(HR); \ + H[1] = (*_PREG)->u.xxc.c; \ + H[2] = XREG((*_PREG)->u.xxc.xi); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2S_CV_TEST_D1 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = (*_PREG)->u.xxc.c; \ + d1 = XREG((*_PREG)->u.xxc.xi); + +#define P_FUNC2S_CV_D1INT \ + d1 = IntegerOfTerm(d1); + +#define P_FUNC2S_CV_D1NOTINT \ + saveregs(); + +#define P_FUNC2S_CV_D1NOINT_D1BIGINT \ + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + +#define P_FUNC2S_CV_D1NOTBIGINT \ + Yap_Error(TYPE_ERROR_INTEGER,d1,"functor/3"); + +#define P_FUNC2S_CV_POST_IF \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_CV_FIRSTIFOK \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + XREG((*_PREG)->u.xxc.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxc),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_CV_D1GREATER_D0NOTATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_CV_D1GREATER_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_CV_D1GREATER_POST_IF \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_CV_D1GREATER_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_CV_D1GREATER_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_CV_D1GREATER_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_CV_D1GREATER_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_CV_D1GREATER_END \ + H = pt1; \ + XREG((*_PREG)->u.xxc.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxc),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_CV_D1ISZERO \ + XREG((*_PREG)->u.xxc.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxc),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_CV_ELSE \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_CV_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_VC_LOW_LEVEL_TRACER \ + Term ti; \ + CELL *hi = HR; \ + ti = MkIntegerTerm((*_PREG)->u.xxn.c); \ + RESET_VARIABLE(HR); \ + H[1] = XREG((*_PREG)->u.xxn.xi); \ + H[2] = ti; \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); \ + H = hi; +#endif + +#define P_FUNC2S_VC_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.xxn.xi); + +#define P_FUNC2S_VC_FUNC2S_NVAR_VC \ + d1 = (*_PREG)->u.xxn.c; + +#define P_FUNC2S_VC_D0NOATOMIC \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VC_EQUALS \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxn),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VC_D1ISZERO \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxn),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VC_D0NOATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_VC_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_VC_POST_ELSE \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_VC_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_VC_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_VC_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_VC_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_VC_END1 \ + HR = pt1; \ + XREG((*_PREG)->u.xxn.x) = d0; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), xxn),Osbpp),l); \ + GONext(); + +#define P_FUNC2S_VC_END2 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_Y_VV_LOW_LEVEL_TRACER \ + RESET_VARIABLE(HR); \ + H[1] = XREG((*_PREG)->u.yxx.x1); \ + H[2] = XREG((*_PREG)->u.yxx.x2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2S_Y_VV_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yxx.x1); + +#define P_FUNC2S_Y_VV_TEST_D1 \ + d1 = XREG((*_PREG)->u.yxx.x2); + +#define P_FUNC2S_Y_VV_D1INT \ + d1 = IntegerOfTerm(d1); + +#define P_FUNC2S_Y_VV_D1NOTINT \ + saveregs(); + +#define P_FUNC2S_Y_VV_D1BIGINT \ + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + +#define P_FUNC2S_Y_VV_D1NOTBIGINT \ + Yap_Error(TYPE_ERROR_INTEGER,d1,"functor/3"); + +#define P_FUNC2S_Y_VV_POST_IF \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_D0NOATOMIC \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_EQUALS \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxx),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VV_D1GREATER_D0NOATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_D1GREATER_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_Y_VV_D1GREATER_POST_ELSE \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_Y_VV_D1GREATER_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_Y_VV_D1GREATER_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_Y_VV_D1GREATER_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_Y_VV_D1GREATER_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_Y_VV_D1GREATER_END \ + H = pt1; \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxx),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VV_D1ISZERO \ + pt1 = YREG + (*_PREG)->u.yxx.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxx),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VV_ELSE \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_END1 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VV_END2 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_CV_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_Y_CV_LOW_LEVEL_TRACER \ + RESET_VARIABLE(HR); \ + H[1] = (*_PREG)->u.yxn.c; \ + H[2] = XREG((*_PREG)->u.yxn.xi); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2S_Y_CV_TEST_D1 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = (*_PREG)->u.yxn.c; \ + d1 = XREG((*_PREG)->u.yxn.xi); + +#define P_FUNC2S_Y_CV_D1INT \ + d1 = IntegerOfTerm(d1); + +#define P_FUNC2S_Y_CV_D1NOTINT \ + saveregs(); + +#define P_FUNC2S_Y_CV_D1BIGINT \ + Yap_Error(RESOURCE_ERROR_STACK, d1, "functor/3"); + +#define P_FUNC2S_Y_CV_D1NOTBIGINT \ + Yap_Error(TYPE_ERROR_INTEGER,d1,"functor/3"); + +#define P_FUNC2S_Y_CV_POST_IF \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_CV_EQUALS \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_CV_D1GREATER_D0NOATOM \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_CV_D1GREATER_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_Y_CV_D1GREATER_POST_ELSE \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_Y_CV_D1GREATER_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_Y_CV_D1GREATER_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_Y_CV_D1GREATER_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_Y_CV_D1GREATER_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_Y_CV_D1GREATER_END \ + H = pt1; \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_CV_D1ISZERO \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_CV_ELSE \ + saveregs(); \ + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_CV_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d1, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2S_Y_VC_LOW_LEVEL_TRACER \ + Term ti; \ + CELL *hi = HR; \ + ti = MkIntegerTerm((Int)((*_PREG)->u.yxn.c)); \ + RESET_VARIABLE(HR); \ + H[1] = XREG((*_PREG)->u.yxn.xi); \ + H[2] = ti; \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); \ + H = hi; +#endif + +#define P_FUNC2S_Y_VC_TEST_D0 \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.yxn.xi); + +#define P_FUNC2S_Y_VC_FUNC2S_Y_NVAR_VC \ + d1 = (*_PREG)->u.yxn.c; + +#define P_FUNC2S_Y_VC_D0NOATOMIC \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VC_EQUALS \ + RESET_VARIABLE(HR); \ + RESET_VARIABLE(HR+1); \ + d0 = AbsPair(HR); \ + H += 2; \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VC_D1ISZERO \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VC_D0NOATOM1 \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VC_D0NOATOM2 \ + saveregs(); \ + Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2S_Y_VC_D0ATOM \ + d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1); + +#define P_FUNC2S_Y_VC_POST_ELSE \ + pt1 = HR; \ + *pt1++ = d0; \ + d0 = AbsAppl(HR); + +#define P_FUNC2S_Y_VC_IFOK_INIT \ + saveregs(); + +#define P_FUNC2S_Y_VC_IFOK_IFOK \ + Yap_NilError(OUT_OF_STACK_ERROR,LOCAL_ErrorMessage); \ + setregs(); \ + JMPNext(); + +#define P_FUNC2S_Y_VC_IFOK_NOIF \ + setregs(); + +#define P_FUNC2S_Y_VC_INSIDEWHILE \ + RESET_VARIABLE(pt1); \ + pt1++; + +#define P_FUNC2S_Y_VC_END1 \ + HR = pt1; \ + pt1 = YREG + (*_PREG)->u.yxn.y; \ + (*_PREG) = NEXTOP(NEXTOP(NEXTOP((*_PREG), yxn),Osbpp),l); \ + INITIALIZE_PERMVAR(pt1,d0); \ + GONext(); + +#define P_FUNC2S_Y_VC_END2 \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2F_XX_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2F_XX_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.xxx.x); \ + RESET_VARIABLE(HR+1); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2F_XX_TEST_D0 \ + register CELL d0; \ + register CELL* pt1; \ + d0 = XREG((*_PREG)->u.xxx.x); + +#define P_FUNC2F_XX_D0APPL \ + Functor d1 = FunctorOfTerm(d0); + +#define P_FUNC2F_XX_D0APPL_D1EXTFUNC \ + XREG((*_PREG)->u.xxx.x1) = d0; \ + XREG((*_PREG)->u.xxx.x2) = MkIntTerm(0); \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_FUNC2F_XX_D0APPL_END \ + XREG((*_PREG)->u.xxx.x1) = MkAtomTerm(NameOfFunctor(d1)); \ + XREG((*_PREG)->u.xxx.x2) = MkIntegerTerm(ArityOfFunctor(d1)); \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + + +#define P_FUNC2F_XX_D0PAIR \ + XREG((*_PREG)->u.xxx.x1) = TermDot; \ + XREG((*_PREG)->u.xxx.x2) = MkIntTerm(2); \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_FUNC2F_XX_D0NOCOMPOUND \ + XREG((*_PREG)->u.xxx.x1) = d0; \ + XREG((*_PREG)->u.xxx.x2) = MkIntTerm(0); \ + (*_PREG) = NEXTOP((*_PREG), xxx); \ + GONext(); + +#define P_FUNC2F_XX_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2F_XY_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2F_XY_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.xxy.x); \ + RESET_VARIABLE(HR+1); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2F_XY_TEST_D0 \ + register CELL d0; \ + register CELL *pt1; \ + d0 = XREG((*_PREG)->u.xxy.x); + +#define P_FUNC2F_XY_D0APPL \ + Functor d1 = FunctorOfTerm(d0); \ + CELL *pt0 = YREG+(*_PREG)->u.xxy.y2; + +#define P_FUNC2F_XY_D0APPL_D1EXTFUNC \ + XREG((*_PREG)->u.xxy.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxy); \ + INITIALIZE_PERMVAR(pt0, MkIntTerm(0)); \ + GONext(); + +#define P_FUNC2F_XY_D0APPL_END \ + XREG((*_PREG)->u.xxy.x1) = MkAtomTerm(NameOfFunctor(d1)); \ + (*_PREG) = NEXTOP((*_PREG), xxy); \ + INITIALIZE_PERMVAR(pt0, MkIntegerTerm(ArityOfFunctor(d1))); \ + GONext(); + +#define P_FUNC2F_XY_D0PAIR \ + CELL *pt0 = YREG+(*_PREG)->u.xxy.y2; \ + XREG((*_PREG)->u.xxy.x1) = TermDot; \ + (*_PREG) = NEXTOP((*_PREG), xxy); \ + INITIALIZE_PERMVAR(pt0, MkIntTerm(2)); \ + GONext(); + +#define P_FUNC2F_XY_D0NOCOMPOUND \ + CELL *pt0 = YREG+(*_PREG)->u.xxy.y2; \ + XREG((*_PREG)->u.xxy.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xxy); \ + INITIALIZE_PERMVAR(pt0, MkIntTerm(0)); \ + GONext(); + +#define P_FUNC2F_XY_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2F_YX_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2F_YX_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.yxx.x2); \ + RESET_VARIABLE(HR+1); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2F_YX_TEST_D0 \ + register CELL d0; \ + register CELL *pt1; \ + d0 = XREG((*_PREG)->u.yxx.x2); + +#define P_FUNC2F_YX_D0APPL \ + Functor d1 = FunctorOfTerm(d0); \ + CELL *pt0 = YREG+(*_PREG)->u.yxx.y; + +#define P_FUNC2F_YX_D0APPL_D1EXTFUNC \ + XREG((*_PREG)->u.yxx.x1) = MkIntTerm(0); \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0, d0); \ + GONext(); + +#define P_FUNC2F_YX_D0APPL_END \ + XREG((*_PREG)->u.yxx.x1) = MkIntegerTerm(ArityOfFunctor(d1)); \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1))); \ + GONext(); + +#define P_FUNC2F_YX_D0PAIR \ + CELL *pt0 = YREG+(*_PREG)->u.yxx.y; \ + XREG((*_PREG)->u.yxx.x1) = MkIntTerm(2); \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0 ,TermDot); \ + GONext(); + +#define P_FUNC2F_YX_D0NOCOMPOUND \ + CELL *pt0 = YREG+(*_PREG)->u.yxx.y; \ + XREG((*_PREG)->u.yxx.x1) = MkIntTerm(0); \ + (*_PREG) = NEXTOP((*_PREG), yxx); \ + INITIALIZE_PERMVAR(pt0, d0); \ + GONext(); + +#define P_FUNC2F_YX_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#define P_FUNC2F_YY_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + +#ifdef LOW_LEVEL_TRACER +#define P_FUNC2F_YY_LOW_LEVEL_TRACER \ + H[0] = XREG((*_PREG)->u.yyx.x); \ + RESET_VARIABLE(HR+1); \ + RESET_VARIABLE(HR+2); \ + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); +#endif + +#define P_FUNC2F_YY_TEST_D0 \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.yyx.x); + +#define P_FUNC2F_YY_D0APPL \ + Functor d1 = FunctorOfTerm(d0); \ + CELL *pt0 = YREG+(*_PREG)->u.yyx.y1; \ + CELL *pt1 = YREG+(*_PREG)->u.yyx.y2; + +#define P_FUNC2F_YY_D0APPL_D1EXTFUNC \ + (*_PREG) = NEXTOP((*_PREG), yyx); \ + INITIALIZE_PERMVAR(pt0, d0); \ + INITIALIZE_PERMVAR(pt1, MkIntTerm(0)); \ + GONext(); + +#define P_FUNC2F_YY_D0APPL_END \ + (*_PREG) = NEXTOP((*_PREG), yyx); \ + INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1))); \ + INITIALIZE_PERMVAR(pt1, MkIntegerTerm(ArityOfFunctor(d1))); \ + GONext(); + +#define P_FUNC2F_YY_D0PAIR \ + CELL *pt0 = YREG+(*_PREG)->u.yyx.y1; \ + CELL *pt1 = YREG+(*_PREG)->u.yyx.y2; \ + (*_PREG) = NEXTOP((*_PREG), yyx); \ + INITIALIZE_PERMVAR(pt0, TermDot); \ + INITIALIZE_PERMVAR(pt1, MkIntTerm(2)); \ + GONext(); + +#define P_FUNC2F_YY_D0NOCOMPOUND \ + CELL *pt0 = YREG+(*_PREG)->u.yyx.y1; \ + CELL *pt1 = YREG+(*_PREG)->u.yyx.y2; \ + (*_PREG) = NEXTOP((*_PREG), yyx); \ + INITIALIZE_PERMVAR(pt0, d0); \ + INITIALIZE_PERMVAR(pt1, MkIntTerm(0)); \ + GONext(); + +#define P_FUNC2F_YY_END \ + saveregs(); \ + Yap_Error(INSTANTIATION_ERROR, d0, "functor/3"); \ + setregs(); \ + FAIL(); + +#include "p_functor.i" diff --git a/JIT/HPP/yaam_put.h b/JIT/HPP/yaam_put.h new file mode 100644 index 000000000..050669da4 --- /dev/null +++ b/JIT/HPP/yaam_put.h @@ -0,0 +1,182 @@ +#define PUT_X_VAR_INSTINIT \ + register CELL *pt0; \ + pt0 = HR; \ + XREG((*_PREG)->u.xx.xl) = Unsigned(pt0); \ + HR = pt0 + 1; \ + XREG((*_PREG)->u.xx.xr) = Unsigned(pt0); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + RESET_VARIABLE(pt0); \ + GONext(); + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define PUT_Y_VAR_INSTINIT \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + XREG((*_PREG)->u.yx.x) = (CELL) pt0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + if (Unsigned((Int)(pt0)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + *pt0 = (CELL)STACK_TO_SBA(pt0); \ + } else \ + INITIALIZE_PERMVAR(pt0, (CELL)pt0); \ + GONext(); +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#define PUT_Y_VAR_INSTINIT \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + XREG((*_PREG)->u.yx.x) = (CELL) pt0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + INITIALIZE_PERMVAR(pt0, (CELL)pt0); \ + GONext(); +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#define PUT_X_VAL_INSTINIT \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.xx.xl); \ + XREG((*_PREG)->u.xx.xr) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONext(); + +#define PUT_XX_VAL_INSTINIT \ + register CELL d0, d1; \ + d0 = XREG((*_PREG)->u.xxxx.xl1); \ + d1 = XREG((*_PREG)->u.xxxx.xl2); \ + XREG((*_PREG)->u.xxxx.xr1) = d0; \ + XREG((*_PREG)->u.xxxx.xr2) = d1; \ + (*_PREG) = NEXTOP((*_PREG), xxxx); \ + GONext(); + +#ifdef YAPOR_SBA +#define PUT_Y_VAL_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.yx.y]; \ + if (d0 == 0) { \ + XREG((*_PREG)->u.yx.x) = (CELL)(YREG+(*_PREG)->u.yx.y); \ + } else \ + XREG((*_PREG)->u.yx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); +#else /* YAPOR_SBA */ +#define PUT_Y_VAL_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.yx.y]; \ + XREG((*_PREG)->u.yx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); +#endif /* YAPOR_SBA */ + +#ifdef YAPOR_SBA +#define PUT_Y_VALS_INSTINIT \ + register CELL d0, d1; \ + ALWAYS_START_PREFETCH(yyxx); \ + d0 = YREG[(*_PREG)->u.yyxx.y1]; \ + if (d0 == 0) \ + XREG((*_PREG)->u.yyxx.x1) = (CELL)(YREG+(*_PREG)->u.yyxx.y1); \ + else \ + XREG((*_PREG)->u.yyxx.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yyxx); \ + d1 = YREG[PREVOP((*_PREG),yyxx)->u.yyxx.y2]; \ + if (d1 == 0) \ + XREG(PREVOP((*_PREG)->u.yyxx,yyxx).x2) = (CELL)(YREG+(*_PREG)->u.yyxx.y2); \ + else \ + XREG(PREVOP((*_PREG),yyxx)->u.yyxx.x2) = d1; \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); +#else /* YAPOR_SBA */ +#define PUT_Y_VALS_INSTINIT \ + register CELL d0, d1; \ + ALWAYS_START_PREFETCH(yyxx); \ + d0 = YREG[(*_PREG)->u.yyxx.y1]; \ + XREG((*_PREG)->u.yyxx.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yyxx); \ + d1 = YREG[PREVOP((*_PREG),yyxx)->u.yyxx.y2]; \ + XREG(PREVOP((*_PREG),yyxx)->u.yyxx.x2) = d1; \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); +#endif /* YAPOR_SBA */ + +#define PUT_UNSAFE_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.yx.y; \ + d0 = *pt0; + +#define PUT_UNSAFE_PUNSAFE_NONVAR \ + XREG((*_PREG)->u.yx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); + +#define PUT_UNSAFE_PUNSAFE_UNK \ + if (pt0 <= HR || pt0 >= YREG) { \ + XREG((*_PREG)->u.yx.x) = Unsigned(pt0); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); \ + } \ + else { \ + Bind_Local(pt0, Unsigned(HR)); \ + XREG((*_PREG)->u.yx.x) = (CELL) HR; \ + RESET_VARIABLE(HR); \ + H++; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); \ + } + +#define PUT_ATOM_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.xc.c; \ + XREG((*_PREG)->u.xc.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xc); \ + GONext(); + +#define PUT_DBTERM_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.xD.D; \ + XREG((*_PREG)->u.xD.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xD); \ + GONext(); + +#define PUT_BIGINT_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.xN.b; \ + XREG((*_PREG)->u.xN.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xN); \ + GONext(); + +#define PUT_FLOAT_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.xd.d); \ + XREG((*_PREG)->u.xd.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + GONext(); + +#define PUT_LONGINT_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.xi.i); \ + XREG((*_PREG)->u.xi.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xi); \ + GONext(); + +#define PUT_LIST_INSTINIT \ + register CELL d0; \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = HR; \ + HR += 2; \ + d0 = AbsPair(S_SREG); \ + XREG((*_PREG)->u.x.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), x); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONext(); + +#define PUT_STRUCT_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + XREG((*_PREG)->u.xfa.x) = d0; \ + d0 = (CELL) ((*_PREG)->u.xfa.f); \ + *H++ = d0; \ + (*_SREG) = HR; \ + HR += (*_PREG)->u.xfa.a; \ + (*_PREG) = NEXTOP((*_PREG), xfa); \ + GONext(); + diff --git a/JIT/HPP/yaam_put_d.h b/JIT/HPP/yaam_put_d.h new file mode 100644 index 000000000..12242671f --- /dev/null +++ b/JIT/HPP/yaam_put_d.h @@ -0,0 +1,199 @@ +#define PUT_X_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL *pt0; \ + pt0 = HR; \ + XREG((*_PREG)->u.xx.xl) = Unsigned(pt0); \ + HR = pt0 + 1; \ + XREG((*_PREG)->u.xx.xr) = Unsigned(pt0); \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + RESET_VARIABLE(pt0); \ + GONext(); + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#define PUT_Y_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + XREG((*_PREG)->u.yx.x) = (CELL) pt0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + if (Unsigned((Int)(pt0)-(Int)(H_FZ)) > \ + Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { \ + *pt0 = (CELL)STACK_TO_SBA(pt0); \ + } else \ + INITIALIZE_PERMVAR(pt0, (CELL)pt0); \ + GONext(); +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#define PUT_Y_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL *pt0; \ + pt0 = YREG + (*_PREG)->u.yx.y; \ + XREG((*_PREG)->u.yx.x) = (CELL) pt0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + INITIALIZE_PERMVAR(pt0, (CELL)pt0); \ + GONext(); +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#define PUT_X_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.xx.xl); \ + XREG((*_PREG)->u.xx.xr) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xx); \ + GONext(); + +#define PUT_XX_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + d0 = XREG((*_PREG)->u.xxxx.xl1); \ + d1 = XREG((*_PREG)->u.xxxx.xl2); \ + XREG((*_PREG)->u.xxxx.xr1) = d0; \ + XREG((*_PREG)->u.xxxx.xr2) = d1; \ + (*_PREG) = NEXTOP((*_PREG), xxxx); \ + GONext(); + +#ifdef YAPOR_SBA +#define PUT_Y_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.yx.y]; \ + if (d0 == 0) { \ + XREG((*_PREG)->u.yx.x) = (CELL)(YREG+(*_PREG)->u.yx.y); \ + } else \ + XREG((*_PREG)->u.yx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); +#else /* YAPOR_SBA */ +#define PUT_Y_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.yx.y]; \ + XREG((*_PREG)->u.yx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); +#endif /* YAPOR_SBA */ + +#ifdef YAPOR_SBA +#define PUT_Y_VALS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + ALWAYS_START_PREFETCH(yyxx); \ + d0 = YREG[(*_PREG)->u.yyxx.y1]; \ + if (d0 == 0) \ + XREG((*_PREG)->u.yyxx.x1) = (CELL)(YREG+(*_PREG)->u.yyxx.y1); \ + else \ + XREG((*_PREG)->u.yyxx.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yyxx); \ + d1 = YREG[PREVOP((*_PREG),yyxx)->u.yyxx.y2]; \ + if (d1 == 0) \ + XREG(PREVOP((*_PREG)->u.yyxx,yyxx).x2) = (CELL)(YREG+(*_PREG)->u.yyxx.y2); \ + else \ + XREG(PREVOP((*_PREG),yyxx)->u.yyxx.x2) = d1; \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); +#else /* YAPOR_SBA */ +#define PUT_Y_VALS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + ALWAYS_START_PREFETCH(yyxx); \ + d0 = YREG[(*_PREG)->u.yyxx.y1]; \ + XREG((*_PREG)->u.yyxx.x1) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yyxx); \ + d1 = YREG[PREVOP((*_PREG),yyxx)->u.yyxx.y2]; \ + XREG(PREVOP((*_PREG),yyxx)->u.yyxx.x2) = d1; \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); +#endif /* YAPOR_SBA */ + +#define PUT_UNSAFE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.yx.y; \ + d0 = *pt0; + +#define PUT_UNSAFE_PUNSAFE_NONVAR \ + XREG((*_PREG)->u.yx.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); + +#define PUT_UNSAFE_PUNSAFE_UNK \ + if (pt0 <= HR || pt0 >= YREG) { \ + XREG((*_PREG)->u.yx.x) = Unsigned(pt0); \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); \ + } \ + else { \ + Bind_Local(pt0, Unsigned(HR)); \ + XREG((*_PREG)->u.yx.x) = (CELL) HR; \ + RESET_VARIABLE(HR); \ + H++; \ + (*_PREG) = NEXTOP((*_PREG), yx); \ + GONext(); \ + } + +#define PUT_ATOM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_PREG)->u.xc.c; \ + XREG((*_PREG)->u.xc.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xc); \ + GONext(); + +#define PUT_DBTERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_PREG)->u.xD.D; \ + XREG((*_PREG)->u.xD.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xD); \ + GONext(); + +#define PUT_BIGINT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_PREG)->u.xN.b; \ + XREG((*_PREG)->u.xN.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xN); \ + GONext(); + +#define PUT_FLOAT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.xd.d); \ + XREG((*_PREG)->u.xd.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xd); \ + GONext(); + +#define PUT_LONGINT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.xi.i); \ + XREG((*_PREG)->u.xi.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), xi); \ + GONext(); + +#define PUT_LIST_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = HR; \ + HR += 2; \ + d0 = AbsPair(S_SREG); \ + XREG((*_PREG)->u.x.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), x); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONext(); + +#define PUT_STRUCT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + XREG((*_PREG)->u.xfa.x) = d0; \ + d0 = (CELL) ((*_PREG)->u.xfa.f); \ + *H++ = d0; \ + (*_SREG) = HR; \ + HR += (*_PREG)->u.xfa.a; \ + (*_PREG) = NEXTOP((*_PREG), xfa); \ + GONext(); + diff --git a/JIT/HPP/yaam_unify.h b/JIT/HPP/yaam_unify.h new file mode 100644 index 000000000..578f0069e --- /dev/null +++ b/JIT/HPP/yaam_unify.h @@ -0,0 +1,1266 @@ +#define UNIFY_X_VAR_INSTINIT \ + register CELL d0; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#ifdef YAPOR_SBA +#define UNIFY_X_VAR_YAPOR_SBA \ + if (d0 == 0) { \ + d0 = (CELL)S_SREG; \ + } +#endif + +#define UNIFY_X_VAR_END \ + WRITEBACK_S(S_SREG+1); \ + ALWAYS_START_PREFETCH(ox); \ + XREG((*_PREG)->u.ox.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); \ + ENDCACHE_S(); + +#define UNIFY_X_VAR_WRITE_INSTINIT \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + RESET_VARIABLE(S_SREG); \ + *pt0 = (CELL) S_SREG; \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_X_VAR_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + ALWAYS_START_PREFETCH(ox); \ + d0 = (*_SREG)[0]; \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); + +#ifdef YAPOR_SBA +#define UNIFY_L_X_VAR_YAPOR_SBA \ + if (d0 == 0) { \ + d0 = (CELL)(*_SREG); \ + } +#endif + +#define UNIFY_L_X_VAR_END \ + *pt0 = d0; \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); + +#define UNIFY_L_X_VAR_WRITE_INSTINIT \ + register CELL *pt0; \ + ALWAYS_START_PREFETCH(ox); \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + RESET_VARIABLE(S_SREG); \ + *pt0 = (CELL)S_SREG; \ + ENDCACHE_S(); \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); + +#define UNIFY_X_VAR2_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + ALWAYS_START_PREFETCH(oxx); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + d0 = S_SREG[0]; \ + d1 = S_SREG[1]; + +#ifdef YAPOR_SBA +#define UNIFY_X_VAR2_YAPOR_SBA \ + if (d0 == 0) { \ + d0 = (CELL)S_SREG; \ + } \ + if (d1 == 0) { \ + d1 = (CELL)(S_SREG+1); \ + } +#endif + +#define UNIFY_X_VAR2_END \ + WRITEBACK_S(S_SREG+2); \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + *pt0 = d1; \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); \ + ENDCACHE_S(); + +#define UNIFY_X_VAR2_WRITE_INSTINIT \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + RESET_VARIABLE(S_SREG); \ + XREG((*_PREG)->u.oxx.xl) = (CELL) S_SREG; \ + S_SREG++; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + RESET_VARIABLE(S_SREG); \ + *pt0 = (CELL) S_SREG; \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); + +#ifdef YAPOR_SBA +#define UNIFY_L_X_VAR2_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + d0 = S_SREG[0]; \ + d1 = S_SREG[1]; \ + if (d0 == 0) \ + XREG((*_PREG)->u.oxx.xl) = (CELL)S_SREG; \ + else \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + if (d1 == 0) \ + *pt0 = (CELL)(S_SREG+1); \ + else \ + *pt0 = d1; \ + ENDCACHE_S(); \ + ALWAYS_GONext(); +#else /* YAPOR_SBA */ +#define UNIFY_L_X_VAR2_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + d0 = S_SREG[0]; \ + d1 = S_SREG[1]; \ + { \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + } \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + { \ + *pt0 = d1; \ + } \ + ENDCACHE_S(); \ + ALWAYS_GONext(); +#endif /* YAPOR_SBA */ + +#define UNIFY_L_X_VAR2_WRITE_INSTINIT \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + XREG((*_PREG)->u.oxx.xl) = (CELL) S_SREG; \ + RESET_VARIABLE(S_SREG); \ + S_SREG++; \ + *pt0 = (CELL) S_SREG; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + RESET_VARIABLE(S_SREG); \ + ENDCACHE_S(); \ + GONext(); + +#ifdef YAPOR_SBA +#define UNIFY_Y_VAR_INSTINIT \ + register CELL d0; \ + d0 = *(*_SREG)++; \ + if (d0 == 0) { \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL)((*_SREG)-1)); \ + } else \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#else /* YAPOR_SBA */ +#define UNIFY_Y_VAR_INSTINIT \ + register CELL d0; \ + d0 = *(*_SREG)++; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,d0); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#endif /* YAPOR_SBA */ + +#define UNIFY_Y_VAR_WRITE_INSTINIT \ + CACHE_S(); \ + READ_IN_S(); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL) S_SREG); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); + +#ifdef YAPOR_SBA +#define UNIFY_L_Y_VAR_INSTINIT \ + register CELL d0; \ + d0 = (*_SREG)[0]; \ + if (d0 == 0) { \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL)(*_SREG)); \ + } else \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#else /* YAPOR_SBA */ +#define UNIFY_L_Y_VAR_INSTINIT \ + register CELL d0; \ + d0 = (*_SREG)[0]; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,d0); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#endif /* YAPOR_SBA */ + +#define UNIFY_L_Y_VAR_WRITE_INSTINIT \ + CACHE_S(); \ + READ_IN_S(); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL) S_SREG); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + RESET_VARIABLE(S_SREG); \ + ENDCACHE_S(); \ + GONext(); + +#define UNIFY_X_VAL_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_X_VAL_UVALX_NONVAR \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_VAL_UVALX_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_X_VAL_UVALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_X_VAL_UVALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_X_VAL_UVALX_UNK \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_VAL_UVALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_X_VAL_UVALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define UNIFY_X_VAL_WRITE_INSTINIT \ + *(*_SREG)++ = XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONextW(); + +#define UNIFY_L_X_VAL_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_X_VAL_ULVALX_NONVAR \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_X_VAL_ULVALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_L_X_VAL_ULVALX_UNK \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_VAL_ULVALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_X_VAL_ULVALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define UNIFY_L_X_VAL_WRITE_INSTINIT \ + (*_SREG)[0] = XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONext(); + +#define UNIFY_Y_VAL_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_Y_VAL_UVALY_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_VAL_UVALY_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_Y_VAL_UVALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_Y_VAL_UVALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_Y_VAL_UVALY_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_VAL_UVALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_Y_VAL_UVALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#ifdef YAPOR_SBA +#define UNIFY_Y_VAL_WRITE_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + if (d0 == 0) \ + *(*_SREG)++ = (CELL)(YREG+(*_PREG)->u.oy.y); \ + else \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); +#else /* YAPOR_SBA */ +#define UNIFY_Y_VAL_WRITE_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); +#endif /* YAPOR_SBA */ + +#define UNIFY_L_Y_VAL_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_Y_VAL_ULVALY_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_L_Y_VAL_ULVALY_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_Y_VAL_ULVALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#ifdef YAPOR_SBA +#define UNIFY_L_Y_VAL_WRITE_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + if (d0 == 0) \ + (*_SREG)[0] = (CELL)(YREG+(*_PREG)->u.oy.y); \ + else \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#else /* YAPOR_SBA */ +#define UNIFY_L_Y_VAL_WRITE_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#endif /* YAPOR_SBA */ + +#define UNIFY_X_LOC_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_X_LOC_UVALX_LOC_NONVAR \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_X_LOC_UVALX_LOC_UNK \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_X_LOC_UVALX_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + UnifyCells(pt0, pt1); \ + GONext(); + +#define UNIFY_X_LOC_WRITE_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONextW(); + +#define UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + if (pt0 < HR) { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONextW(); \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + Bind_Local(pt0, Unsigned(S_SREG)); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); \ + } + +#define UNIFY_L_X_LOC_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_X_LOC_ULVALX_LOC_NONVAR \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind(pt0, d0); \ + GONext(); + +#define UNIFY_L_X_LOC_ULVALX_LOC_UNK \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define UNIFY_L_X_LOC_WRITE_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONext(); + +#define UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + if (pt0 < HR) { \ + (*_SREG)[0] = Unsigned(pt0); \ + GONext(); \ + } \ + else { \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + GONext(); \ + } + +#define UNIFY_Y_LOC_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_Y_LOC_UVALY_LOC_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_Y_LOC_UVALY_LOC_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_Y_LOC_UVALY_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + UnifyCells(pt0, pt1); \ + GONext(); + +#define UNIFY_Y_LOC_WRITE_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.oy.y; \ + d0 = *pt0; + +#define UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); + +#define UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + if (pt0 < HR) { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONextW(); \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + Bind_Local(pt0, Unsigned(S_SREG)); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); \ + } + +#define UNIFY_L_Y_LOC_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_L_Y_LOC_ULVALY_LOC_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define UNIFY_L_Y_LOC_WRITE_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.oy.y; \ + d0 = *pt0; + +#define UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); + +#define UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + if (pt0 < HR) { \ + (*_SREG)[0] = Unsigned(pt0); \ + GONext(); \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + Bind_Local(pt0, Unsigned(S_SREG)); \ + RESET_VARIABLE(S_SREG); \ + ENDCACHE_S(); \ + GONext(); \ + } + +#define UNIFY_VOID_INSTINIT \ + START_PREFETCH(o); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + (*_SREG)++; \ + GONext(); \ + END_PREFETCH(); + +#define UNIFY_VOID_WRITE_INSTINIT \ + CACHE_S(); \ + READ_IN_S(); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_VOID_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG), o); \ + GONext(); + +#define UNIFY_L_VOID_WRITE_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG), o); \ + RESET_VARIABLE((*_SREG)); \ + GONext(); + +#define UNIFY_N_VOIDS_INSTINIT \ + (*_SREG) += (*_PREG)->u.os.s; \ + (*_PREG) = NEXTOP((*_PREG), os); \ + GONext(); + +#define UNIFY_N_VOIDS_WRITE_INSTINIT \ + register CELL d0; \ + CACHE_S(); \ + d0 = (*_PREG)->u.os.s; \ + READ_IN_S(); \ + (*_PREG) = NEXTOP((*_PREG), os); \ + for (; d0 > 0; d0--) { \ + RESET_VARIABLE(S_SREG); \ + S_SREG++; \ + } \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_N_VOIDS_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG), os); \ + GONext(); + +#define UNIFY_L_N_VOIDS_WRITE_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.os.s; \ + (*_PREG) = NEXTOP((*_PREG), os); \ + CACHE_S(); \ + READ_IN_S(); \ + for (; d0 > 0; d0--) { \ + RESET_VARIABLE(S_SREG); \ + S_SREG++; \ + } \ + ENDCACHE_S(); \ + GONext(); + +#define UNIFY_ATOM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_ATOM_UATOM_NONVAR \ + BLOCK = (CELL)UNIFY_ATOM_UATOM_NONVAR; \ + FAILED = 0; \ + if (d0 != (*_PREG)->u.oc.c) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONext(); \ + } + +#define UNIFY_ATOM_UATOM_UNK \ + d0 = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + Bind_Global(pt0, d0); \ + GONext(); + +#define UNIFY_ATOM_WRITE_INSTINIT \ + * (*_SREG)++ = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONextW(); + +#define UNIFY_L_ATOM_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = (*_SREG); \ + d0 = *(*_SREG); + +#define UNIFY_L_ATOM_ULATOM_NONVAR \ + BLOCK = (CELL)UNIFY_L_ATOM_ULATOM_NONVAR; \ + FAILED = 0; \ + if (d0 != (*_PREG)->u.oc.c) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONext(); \ + } + +#define UNIFY_L_ATOM_ULATOM_UNK \ + d0 = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + Bind_Global(pt0, d0); \ + GONext(); + +#define UNIFY_L_ATOM_WRITE_INSTINIT \ + (*_SREG)[0] = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONext(); + +#define UNIFY_N_ATOMS_INSTINIT \ + register Int i = (*_PREG)->u.osc.s; \ + register CELL d0, d1; \ + register CELL *pt0; \ + d1 = (*_PREG)->u.osc.c; \ + for (; i > 0; i--) { \ + pt0 = (*_SREG)++; \ + d0 = *pt0; \ + Int nonvar = 1; \ + if(IsVarTerm(d0)) { \ + nonvar = 0; \ + while (Unsigned(pt0) != (d0)) { \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + } \ + if (!nonvar) { \ + Bind_Global(pt0, d1); \ + continue; \ + } \ + } \ + if (nonvar) { \ + if (d0 != d1) { \ + break; \ + } \ + continue; \ + } \ + } \ + (*_PREG) = NEXTOP((*_PREG), osc); \ + GONext(); + +#define UNIFY_N_ATOMS_WRITE_INSTINIT \ + register CELL d0, d1; \ + d0 = (*_PREG)->u.osc.s; \ + d1 = (*_PREG)->u.osc.c; \ + CACHE_S(); \ + READ_IN_S(); \ + (*_PREG) = NEXTOP((*_PREG), osc); \ + for (; d0 > 0; d0--) { \ + *S_SREG++ = d1; \ + } \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_FLOAT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_FLOAT_UFLOAT_NONVAR_INIT \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR \ + pt1 = (*_PREG)->u.od.d; \ + (*_PREG) = NEXTOP((*_PREG), od); + +#define UNIFY_FLOAT_UFLOAT_NONVAR_END \ + GONext(); + +#define UNIFY_FLOAT_UFLOAT_UNK \ + d1 = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_FLOAT_WRITE_INSTINIT \ + * (*_SREG)++ = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + GONextW(); + +#define UNIFY_L_FLOAT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, pt1; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_FLOAT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_L_FLOAT_D0ISFUNC \ + pt1 = (*_PREG)->u.od.d; \ + (*_PREG) = NEXTOP((*_PREG), od); + +#define UNIFY_L_FLOAT_EQUALS \ + GONext(); + +#define UNIFY_L_FLOAT_ULFLOAT_UNK \ + d1 = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + Bind_Global(S_SREG, d1); \ + GONext(); \ + ENDCACHE_S(); + +#define UNIFY_L_FLOAT_WRITE_INSTINIT \ + (*_SREG)[0] = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + GONext(); + +#define UNIFY_LONGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_LONGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_LONGINT_D0ISFUNC \ + pt1 = (*_PREG)->u.oi.i; \ + (*_PREG) = NEXTOP((*_PREG), oi); + +#define UNIFY_LONGINT_EQUALS \ + GONext(); + +#define UNIFY_LONGINT_ULONGINT_UNK \ + d1 = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_LONGINT_WRITE_INSTINIT \ + * (*_SREG)++ = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + GONextW(); + +#define UNIFY_L_LONGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_LONGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_L_LONGINT_D0ISFUNC \ + pt1 = (*_PREG)->u.oi.i; \ + (*_PREG) = NEXTOP((*_PREG), oi); + +#define UNIFY_L_LONGINT_EQUALS \ + GONext(); + +#define UNIFY_L_LONGINT_ULLONGINT_UNK \ + d1 = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + Bind_Global(S_SREG, d1); \ + GONext(); + +#define UNIFY_L_LONGINT_WRITE_INSTINIT \ + (*_SREG)[0] = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + GONext(); + +#ifdef USE_GMP +#define UNIFY_BIGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_BIGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d1 = *pt0; + +#define UNIFY_BIGINT_D1ISFUNC_GMP \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + GONext(); + +#define UNIFY_BIGINT_UBIGINT_UNK \ + d1 = (*_PREG)->u.oN.b; \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + Bind_Global(pt0, d1); \ + GONext(); +#endif + +#ifdef USE_GMP +#define UNIFY_L_BIGINT_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_BIGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_L_BIGINT_D0ISFUNC_GMP \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + GONext(); + +#define UNIFY_L_BIGINT_ULBIGINT_UNK \ + d1 = (*_PREG)->u.oN.b; \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + Bind_Global(S_SREG, d1); \ + GONext(); \ + ENDCACHE_S(); +#endif + +#define UNIFY_DBTERM_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_DBTERM_UDBTERM_NONVAR \ + BLOCK = (CELL)UNIFY_DBTERM_UDBTERM_NONVAR; \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + YAAM_UNIFYBOUND; + +#define UNIFY_DBTERM_UDBTERM_UNK \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_DBTERM_INSTINIT \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_DBTERM_ULDBTERM_NONVAR \ + BLOCK = (CELL)UNIFY_L_DBTERM_ULDBTERM_NONVAR; \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_DBTERM_ULDBTERM_UNK \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + Bind_Global(S_SREG, d1); \ + GONext(); \ + ENDCACHE_S(); + +#define UNIFY_LIST_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + *--SP = Unsigned((*_SREG) + 1); \ + *--SP = READ_MODE; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_LIST_READMODE \ + BLOCK = (CELL)UNIFY_LIST_READMODE; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_SREG) = RepPair(d0); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + GONext(); \ + } + +#define UNIFY_LIST_WRITEMODE \ + START_PREFETCH_W(o); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = HR; \ + (*_PREG) = NEXTOP((*_PREG), o); \ + HR = S_SREG + 2; \ + d0 = AbsPair(S_SREG); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + Bind_Global(pt0, d0); \ + GONextW(); \ + END_PREFETCH_W(); + +#define UNIFY_LIST_WRITE_INSTINIT \ + register CELL d0; \ + (*_PREG) = NEXTOP((*_PREG), o); \ + d0 = AbsPair(HR); \ + CACHE_S(); \ + READ_IN_S(); \ + SP -= 2; \ + SP[0] = WRITE_MODE; \ + SP[1] = Unsigned(S_SREG + 1); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_LIST_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_LIST_READMODE \ + BLOCK = (CELL)UNIFY_L_LIST_READMODE; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), o); \ + (*_SREG) = RepPair(d0); \ + GONext(); \ + } \ + +#define UNIFY_L_LIST_WRITEMODE \ + START_PREFETCH_W(o); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + d0 = AbsPair(S_SREG); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + Bind_Global(pt0, d0); \ + GONextW(); \ + END_PREFETCH_W(); + +#define UNIFY_L_LIST_WRITE_INSTINIT \ + register CELL d0; \ + d0 = AbsPair(HR); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_STRUCT_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + *--SP = Unsigned((*_SREG) + 1); \ + *--SP = READ_MODE; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_STRUCT_READMODE \ + BLOCK = (CELL)UNIFY_STRUCT_READMODE; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = RepAppl(d0); \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + if (*S_SREG != d0) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + WRITEBACK_S(S_SREG+1); \ + GONext(); \ + } \ + ENDCACHE_S(); \ + } + +#define UNIFY_STRUCT_WRITEMODE \ + START_PREFETCH_W(ofa); \ + d1 = AbsAppl(HR); \ + Bind_Global(pt0, d1); \ + pt0 = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *pt0++ = d0; \ + HR = pt0 + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + (*_SREG) = pt0; \ + GONextW(); \ + END_PREFETCH_W(); + +#define UNIFY_STRUCT_WRITE_INSTINIT \ + register CELL d0; \ + CACHE_S(); \ + READ_IN_S(); \ + *--SP = Unsigned(S_SREG + 1); \ + *--SP = WRITE_MODE; \ + d0 = AbsAppl(HR); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *S_SREG++ = d0; \ + HR = S_SREG + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_STRUC_INSTINIT \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_STRUC_READMODE \ + BLOCK = (CELL)UNIFY_L_STRUC_READMODE; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_SREG) = RepAppl(d0); \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + if (*(*_SREG)++ != d0) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + GONext(); \ + } \ + } + +#define UNIFY_L_STRUC_WRITEMODE \ + START_PREFETCH_W(ofa); \ + d1 = AbsAppl(HR); \ + Bind_Global(pt0, d1); \ + pt0 = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *pt0++ = d0; \ + HR = pt0 + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + (*_SREG) = pt0; \ + GONextW(); \ + END_PREFETCH_W(); + +#define UNIFY_L_STRUC_WRITE_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *S_SREG++ = d0; \ + HR = S_SREG + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define SAVE_PAIR_X_INSTINIT \ + XREG((*_PREG)->u.ox.x) = AbsPair((*_SREG)); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONext(); + +#define SAVE_PAIR_X_WRITE_INSTINIT \ + XREG((*_PREG)->u.ox.x) = AbsPair((*_SREG)); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONextW(); + +#define SAVE_PAIR_Y_INSTINIT \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsPair((*_SREG))); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); + +#define SAVE_PAIR_Y_WRITE_INSTINIT \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsPair((*_SREG))); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); + +#define SAVE_APPL_X_INSTINIT \ + XREG((*_PREG)->u.ox.x) = AbsAppl((*_SREG) - 1); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONext(); + +#define SAVE_APPL_X_WRITE_INSTINIT \ + XREG((*_PREG)->u.ox.x) = AbsAppl((*_SREG) - 1); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONextW(); + +#define SAVE_APPL_Y_INSTINIT \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsAppl((*_SREG)-1)); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); + +#define SAVE_APPL_Y_WRITE_INSTINIT \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsAppl((*_SREG)-1)); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); + diff --git a/JIT/HPP/yaam_unify_d.h b/JIT/HPP/yaam_unify_d.h new file mode 100644 index 000000000..8ef117429 --- /dev/null +++ b/JIT/HPP/yaam_unify_d.h @@ -0,0 +1,1341 @@ +#define UNIFY_X_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#ifdef YAPOR_SBA +#define UNIFY_X_VAR_YAPOR_SBA \ + if (d0 == 0) { \ + d0 = (CELL)S_SREG; \ + } +#endif + +#define UNIFY_X_VAR_END \ + WRITEBACK_S(S_SREG+1); \ + ALWAYS_START_PREFETCH(ox); \ + XREG((*_PREG)->u.ox.x) = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); \ + ENDCACHE_S(); + +#define UNIFY_X_VAR_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + RESET_VARIABLE(S_SREG); \ + *pt0 = (CELL) S_SREG; \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_X_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + ALWAYS_START_PREFETCH(ox); \ + d0 = (*_SREG)[0]; \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); + +#ifdef YAPOR_SBA +#define UNIFY_L_X_VAR_YAPOR_SBA \ + if (d0 == 0) { \ + d0 = (CELL)(*_SREG); \ + } +#endif + +#define UNIFY_L_X_VAR_END \ + *pt0 = d0; \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); + +#define UNIFY_L_X_VAR_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL *pt0; \ + ALWAYS_START_PREFETCH(ox); \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + RESET_VARIABLE(S_SREG); \ + *pt0 = (CELL)S_SREG; \ + ENDCACHE_S(); \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); + +#define UNIFY_X_VAR2_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + ALWAYS_START_PREFETCH(oxx); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + d0 = S_SREG[0]; \ + d1 = S_SREG[1]; + +#ifdef YAPOR_SBA +#define UNIFY_X_VAR2_YAPOR_SBA \ + if (d0 == 0) { \ + d0 = (CELL)S_SREG; \ + } \ + if (d1 == 0) { \ + d1 = (CELL)(S_SREG+1); \ + } +#endif + +#define UNIFY_X_VAR2_END \ + WRITEBACK_S(S_SREG+2); \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + *pt0 = d1; \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); \ + ENDCACHE_S(); + +#define UNIFY_X_VAR2_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + RESET_VARIABLE(S_SREG); \ + XREG((*_PREG)->u.oxx.xl) = (CELL) S_SREG; \ + S_SREG++; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + RESET_VARIABLE(S_SREG); \ + *pt0 = (CELL) S_SREG; \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); + +#ifdef YAPOR_SBA +#define UNIFY_L_X_VAR2_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + d0 = S_SREG[0]; \ + d1 = S_SREG[1]; \ + if (d0 == 0) \ + XREG((*_PREG)->u.oxx.xl) = (CELL)S_SREG; \ + else \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + if (d1 == 0) \ + *pt0 = (CELL)(S_SREG+1); \ + else \ + *pt0 = d1; \ + ENDCACHE_S(); \ + ALWAYS_GONext(); +#else /* YAPOR_SBA */ +#define UNIFY_L_X_VAR2_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + d0 = S_SREG[0]; \ + d1 = S_SREG[1]; \ + { \ + XREG((*_PREG)->u.oxx.xl) = d0; \ + } \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + { \ + *pt0 = d1; \ + } \ + ENDCACHE_S(); \ + ALWAYS_GONext(); +#endif /* YAPOR_SBA */ + +#define UNIFY_L_X_VAR2_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + pt0 = &XREG((*_PREG)->u.oxx.xr); \ + XREG((*_PREG)->u.oxx.xl) = (CELL) S_SREG; \ + RESET_VARIABLE(S_SREG); \ + S_SREG++; \ + *pt0 = (CELL) S_SREG; \ + (*_PREG) = NEXTOP((*_PREG), oxx); \ + RESET_VARIABLE(S_SREG); \ + ENDCACHE_S(); \ + GONext(); + +#ifdef YAPOR_SBA +#define UNIFY_Y_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = *(*_SREG)++; \ + if (d0 == 0) { \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL)((*_SREG)-1)); \ + } else \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#else /* YAPOR_SBA */ +#define UNIFY_Y_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = *(*_SREG)++; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,d0); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#endif /* YAPOR_SBA */ + +#define UNIFY_Y_VAR_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_S(); \ + READ_IN_S(); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL) S_SREG); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); + +#ifdef YAPOR_SBA +#define UNIFY_L_Y_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_SREG)[0]; \ + if (d0 == 0) { \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL)(*_SREG)); \ + } else \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#else /* YAPOR_SBA */ +#define UNIFY_L_Y_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_SREG)[0]; \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,d0); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#endif /* YAPOR_SBA */ + +#define UNIFY_L_Y_VAR_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_S(); \ + READ_IN_S(); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,(CELL) S_SREG); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + RESET_VARIABLE(S_SREG); \ + ENDCACHE_S(); \ + GONext(); + +#define UNIFY_X_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_X_VAL_UVALX_NONVAR \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_VAL_UVALX_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_X_VAL_UVALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_X_VAL_UVALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_X_VAL_UVALX_UNK \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_VAL_UVALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_X_VAL_UVALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define UNIFY_X_VAL_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + *(*_SREG)++ = XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONextW(); + +#define UNIFY_L_X_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_X_VAL_ULVALX_NONVAR \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_X_VAL_ULVALX_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_X_VAL_ULVALX_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_L_X_VAL_ULVALX_UNK \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_VAL_ULVALX_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_X_VAL_ULVALX_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define UNIFY_L_X_VAL_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_SREG)[0] = XREG((*_PREG)->u.ox.x); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONext(); + +#define UNIFY_Y_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_Y_VAL_UVALY_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_VAL_UVALY_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_Y_VAL_UVALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_Y_VAL_UVALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_Y_VAL_UVALY_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_VAL_UVALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_Y_VAL_UVALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#ifdef YAPOR_SBA +#define UNIFY_Y_VAL_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + if (d0 == 0) \ + *(*_SREG)++ = (CELL)(YREG+(*_PREG)->u.oy.y); \ + else \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); +#else /* YAPOR_SBA */ +#define UNIFY_Y_VAL_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); +#endif /* YAPOR_SBA */ + +#define UNIFY_L_Y_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_Y_VAL_ULVALY_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_Y_VAL_ULVALY_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_Y_VAL_ULVALY_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_L_Y_VAL_ULVALY_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_VAL_ULVALY_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_Y_VAL_ULVALY_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#ifdef YAPOR_SBA +#define UNIFY_L_Y_VAL_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + if (d0 == 0) \ + (*_SREG)[0] = (CELL)(YREG+(*_PREG)->u.oy.y); \ + else \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#else /* YAPOR_SBA */ +#define UNIFY_L_Y_VAL_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.oy.y]; \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); +#endif /* YAPOR_SBA */ + +#define UNIFY_X_LOC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_X_LOC_UVALX_LOC_NONVAR \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_X_LOC_UVALX_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_X_LOC_UVALX_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_X_LOC_UVALX_LOC_UNK \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_LOC_UVALX_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_X_LOC_UVALX_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + (*_SREG)++; \ + UnifyCells(pt0, pt1); \ + GONext(); + +#define UNIFY_X_LOC_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_X_LOC_WRITE_UNIFY_X_LOC_NONVAR \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONextW(); + +#define UNIFY_X_LOC_WRITE_UNIFY_X_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + if (pt0 < HR) { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONextW(); \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + Bind_Local(pt0, Unsigned(S_SREG)); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); \ + } + +#define UNIFY_L_X_LOC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_X_LOC_ULVALX_LOC_NONVAR \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_X_LOC_ULVALX_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind(pt0, d0); \ + GONext(); + +#define UNIFY_L_X_LOC_ULVALX_LOC_UNK \ + d1 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_LOC_ULVALX_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_X_LOC_ULVALX_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define UNIFY_L_X_LOC_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + d0 = XREG((*_PREG)->u.ox.x); + +#define UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_NONVAR \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONext(); + +#define UNIFY_L_X_LOC_WRITE_ULNIFY_X_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + if (pt0 < HR) { \ + (*_SREG)[0] = Unsigned(pt0); \ + GONext(); \ + } \ + else { \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + GONext(); \ + } + +#define UNIFY_Y_LOC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_Y_LOC_UVALY_LOC_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_Y_LOC_UVALY_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + YAAM_UNIFYBOUND; + +#define UNIFY_Y_LOC_UVALY_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_Y_LOC_UVALY_LOC_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_Y_LOC_UVALY_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_Y_LOC_UVALY_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + (*_SREG)++; \ + UnifyCells(pt0, pt1); \ + GONext(); + +#define UNIFY_Y_LOC_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.oy.y; \ + d0 = *pt0; + +#define UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_NONVAR \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); + +#define UNIFY_Y_LOC_WRITE_UNIFY_Y_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + if (pt0 < HR) { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONextW(); \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + Bind_Local(pt0, Unsigned(S_SREG)); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); \ + } + +#define UNIFY_L_Y_LOC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR \ + BLOCK = (CELL)UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_NONVAR; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_NONVAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind(pt1, d0); \ + GONext(); + +#define UNIFY_L_Y_LOC_ULVALY_LOC_UNK \ + pt1 = YREG+(*_PREG)->u.oy.y; \ + d1 = *pt1; + +#define UNIFY_L_Y_LOC_ULVALY_LOC_VAR_NONVAR \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_Y_LOC_ULVALY_LOC_VAR_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + UnifyGlobalCellToCell(pt0, pt1); \ + GONext(); + +#define UNIFY_L_Y_LOC_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.oy.y; \ + d0 = *pt0; + +#define UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_NONVAR \ + (*_SREG)[0] = d0; \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); + +#define UNIFY_L_Y_LOC_WRITE_ULUNIFY_Y_LOC_UNK \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + if (pt0 < HR) { \ + (*_SREG)[0] = Unsigned(pt0); \ + GONext(); \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + Bind_Local(pt0, Unsigned(S_SREG)); \ + RESET_VARIABLE(S_SREG); \ + ENDCACHE_S(); \ + GONext(); \ + } + +#define UNIFY_VOID_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + START_PREFETCH(o); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + (*_SREG)++; \ + GONext(); \ + END_PREFETCH(); + +#define UNIFY_VOID_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_S(); \ + READ_IN_S(); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + RESET_VARIABLE(S_SREG); \ + WRITEBACK_S(S_SREG+1); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_VOID_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + GONext(); + +#define UNIFY_L_VOID_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + RESET_VARIABLE((*_SREG)); \ + GONext(); + +#define UNIFY_N_VOIDS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_SREG) += (*_PREG)->u.os.s; \ + (*_PREG) = NEXTOP((*_PREG), os); \ + GONext(); + +#define UNIFY_N_VOIDS_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + CACHE_S(); \ + d0 = (*_PREG)->u.os.s; \ + READ_IN_S(); \ + (*_PREG) = NEXTOP((*_PREG), os); \ + for (; d0 > 0; d0--) { \ + RESET_VARIABLE(S_SREG); \ + S_SREG++; \ + } \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_N_VOIDS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_PREG) = NEXTOP((*_PREG), os); \ + GONext(); + +#define UNIFY_L_N_VOIDS_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_PREG)->u.os.s; \ + (*_PREG) = NEXTOP((*_PREG), os); \ + CACHE_S(); \ + READ_IN_S(); \ + for (; d0 > 0; d0--) { \ + RESET_VARIABLE(S_SREG); \ + S_SREG++; \ + } \ + ENDCACHE_S(); \ + GONext(); + +#define UNIFY_ATOM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_ATOM_UATOM_NONVAR \ + BLOCK = (CELL)UNIFY_ATOM_UATOM_NONVAR; \ + FAILED = 0; \ + if (d0 != (*_PREG)->u.oc.c) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONext(); \ + } + +#define UNIFY_ATOM_UATOM_UNK \ + d0 = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + Bind_Global(pt0, d0); \ + GONext(); + +#define UNIFY_ATOM_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + * (*_SREG)++ = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONextW(); + +#define UNIFY_L_ATOM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = (*_SREG); \ + d0 = *(*_SREG); + +#define UNIFY_L_ATOM_ULATOM_NONVAR \ + BLOCK = (CELL)UNIFY_L_ATOM_ULATOM_NONVAR; \ + FAILED = 0; \ + if (d0 != (*_PREG)->u.oc.c) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONext(); \ + } + +#define UNIFY_L_ATOM_ULATOM_UNK \ + d0 = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + Bind_Global(pt0, d0); \ + GONext(); + +#define UNIFY_L_ATOM_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_SREG)[0] = (*_PREG)->u.oc.c; \ + (*_PREG) = NEXTOP((*_PREG), oc); \ + GONext(); + +#define UNIFY_N_ATOMS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register Int i = (*_PREG)->u.osc.s; \ + register CELL d0, d1; \ + register CELL *pt0; \ + d1 = (*_PREG)->u.osc.c; \ + for (; i > 0; i--) { \ + pt0 = (*_SREG)++; \ + d0 = *pt0; \ + Int nonvar = 1; \ + if(IsVarTerm(d0)) { \ + nonvar = 0; \ + while (Unsigned(pt0) != (d0)) { \ + (pt0) = (CELL *)(d0); \ + (d0) = *(CELL *)(d0); \ + if(!IsVarTerm(d0)) { \ + nonvar = 1; \ + break; \ + } \ + } \ + if (!nonvar) { \ + Bind_Global(pt0, d1); \ + continue; \ + } \ + } \ + if (nonvar) { \ + if (d0 != d1) { \ + break; \ + } \ + continue; \ + } \ + } \ + (*_PREG) = NEXTOP((*_PREG), osc); \ + GONext(); + +#define UNIFY_N_ATOMS_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + d0 = (*_PREG)->u.osc.s; \ + d1 = (*_PREG)->u.osc.c; \ + CACHE_S(); \ + READ_IN_S(); \ + (*_PREG) = NEXTOP((*_PREG), osc); \ + for (; d0 > 0; d0--) { \ + *S_SREG++ = d1; \ + } \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_FLOAT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_FLOAT_UFLOAT_NONVAR_INIT \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_FLOAT_UFLOAT_NONVAR_D0ISFUNCTOR \ + pt1 = (*_PREG)->u.od.d; \ + (*_PREG) = NEXTOP((*_PREG), od); + +#define UNIFY_FLOAT_UFLOAT_NONVAR_END \ + GONext(); + +#define UNIFY_FLOAT_UFLOAT_UNK \ + d1 = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_FLOAT_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + * (*_SREG)++ = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + GONextW(); + +#define UNIFY_L_FLOAT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, pt1; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_FLOAT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_L_FLOAT_D0ISFUNC \ + pt1 = (*_PREG)->u.od.d; \ + (*_PREG) = NEXTOP((*_PREG), od); + +#define UNIFY_L_FLOAT_EQUALS \ + GONext(); + +#define UNIFY_L_FLOAT_ULFLOAT_UNK \ + d1 = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + Bind_Global(S_SREG, d1); \ + GONext(); \ + ENDCACHE_S(); + +#define UNIFY_L_FLOAT_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_SREG)[0] = AbsAppl((*_PREG)->u.od.d); \ + (*_PREG) = NEXTOP((*_PREG), od); \ + GONext(); + +#define UNIFY_LONGINT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_LONGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_LONGINT_D0ISFUNC \ + pt1 = (*_PREG)->u.oi.i; \ + (*_PREG) = NEXTOP((*_PREG), oi); + +#define UNIFY_LONGINT_EQUALS \ + GONext(); + +#define UNIFY_LONGINT_ULONGINT_UNK \ + d1 = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_LONGINT_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + * (*_SREG)++ = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + GONextW(); + +#define UNIFY_L_LONGINT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0, *pt1; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_LONGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_L_LONGINT_D0ISFUNC \ + pt1 = (*_PREG)->u.oi.i; \ + (*_PREG) = NEXTOP((*_PREG), oi); + +#define UNIFY_L_LONGINT_EQUALS \ + GONext(); + +#define UNIFY_L_LONGINT_ULLONGINT_UNK \ + d1 = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + Bind_Global(S_SREG, d1); \ + GONext(); + +#define UNIFY_L_LONGINT_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_SREG)[0] = AbsAppl((*_PREG)->u.oi.i); \ + (*_PREG) = NEXTOP((*_PREG), oi); \ + GONext(); + +#ifdef USE_GMP +#define UNIFY_BIGINT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_BIGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d1 = *pt0; + +#define UNIFY_BIGINT_D1ISFUNC_GMP \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + GONext(); + +#define UNIFY_BIGINT_UBIGINT_UNK \ + d1 = (*_PREG)->u.oN.b; \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + Bind_Global(pt0, d1); \ + GONext(); +#endif + +#ifdef USE_GMP +#define UNIFY_L_BIGINT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_BIGINT_D0ISAPPL \ + pt0 = RepAppl(d0); \ + d0 = *pt0; + +#define UNIFY_L_BIGINT_D0ISFUNC_GMP \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + GONext(); + +#define UNIFY_L_BIGINT_ULBIGINT_UNK \ + d1 = (*_PREG)->u.oN.b; \ + (*_PREG) = NEXTOP((*_PREG), oN); \ + Bind_Global(S_SREG, d1); \ + GONext(); \ + ENDCACHE_S(); +#endif + +#define UNIFY_DBTERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = (*_SREG)++; \ + d0 = *pt0; + +#define UNIFY_DBTERM_UDBTERM_NONVAR \ + BLOCK = (CELL)UNIFY_DBTERM_UDBTERM_NONVAR; \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + YAAM_UNIFYBOUND; + +#define UNIFY_DBTERM_UDBTERM_UNK \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + Bind_Global(pt0, d1); \ + GONext(); + +#define UNIFY_L_DBTERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + register CELL *pt0; \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = *S_SREG; + +#define UNIFY_L_DBTERM_ULDBTERM_NONVAR \ + BLOCK = (CELL)UNIFY_L_DBTERM_ULDBTERM_NONVAR; \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + YAAM_UNIFYBOUND; + +#define UNIFY_L_DBTERM_ULDBTERM_UNK \ + d1 = (*_PREG)->u.oD.D; \ + (*_PREG) = NEXTOP((*_PREG), oD); \ + Bind_Global(S_SREG, d1); \ + GONext(); \ + ENDCACHE_S(); + +#define UNIFY_LIST_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + *--SP = Unsigned((*_SREG) + 1); \ + *--SP = READ_MODE; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_LIST_READMODE \ + BLOCK = (CELL)UNIFY_LIST_READMODE; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_SREG) = RepPair(d0); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + GONext(); \ + } + +#define UNIFY_LIST_WRITEMODE \ + START_PREFETCH_W(o); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = HR; \ + (*_PREG) = NEXTOP((*_PREG), o); \ + HR = S_SREG + 2; \ + d0 = AbsPair(S_SREG); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + Bind_Global(pt0, d0); \ + GONextW(); \ + END_PREFETCH_W(); + +#define UNIFY_LIST_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + (*_PREG) = NEXTOP((*_PREG), o); \ + d0 = AbsPair(HR); \ + CACHE_S(); \ + READ_IN_S(); \ + SP -= 2; \ + SP[0] = WRITE_MODE; \ + SP[1] = Unsigned(S_SREG + 1); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_LIST_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_LIST_READMODE \ + BLOCK = (CELL)UNIFY_L_LIST_READMODE; \ + FAILED = 0; \ + if (!IsPairTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), o); \ + (*_SREG) = RepPair(d0); \ + GONext(); \ + } \ + +#define UNIFY_L_LIST_WRITEMODE \ + START_PREFETCH_W(o); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + d0 = AbsPair(S_SREG); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + Bind_Global(pt0, d0); \ + GONextW(); \ + END_PREFETCH_W(); + +#define UNIFY_L_LIST_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsPair(HR); \ + (*_PREG) = NEXTOP((*_PREG), o); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + HR = S_SREG + 2; \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_STRUCT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + *--SP = Unsigned((*_SREG) + 1); \ + *--SP = READ_MODE; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_STRUCT_READMODE \ + BLOCK = (CELL)UNIFY_STRUCT_READMODE; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG = RepAppl(d0); \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + if (*S_SREG != d0) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + WRITEBACK_S(S_SREG+1); \ + GONext(); \ + } \ + ENDCACHE_S(); \ + } + +#define UNIFY_STRUCT_WRITEMODE \ + START_PREFETCH_W(ofa); \ + d1 = AbsAppl(HR); \ + Bind_Global(pt0, d1); \ + pt0 = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *pt0++ = d0; \ + HR = pt0 + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + (*_SREG) = pt0; \ + GONextW(); \ + END_PREFETCH_W(); + +#define UNIFY_STRUCT_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + CACHE_S(); \ + READ_IN_S(); \ + *--SP = Unsigned(S_SREG + 1); \ + *--SP = WRITE_MODE; \ + d0 = AbsAppl(HR); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *S_SREG++ = d0; \ + HR = S_SREG + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define UNIFY_L_STRUC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0, d1; \ + register CELL *pt0; \ + pt0 = (*_SREG); \ + d0 = *pt0; + +#define UNIFY_L_STRUC_READMODE \ + BLOCK = (CELL)UNIFY_L_STRUC_READMODE; \ + FAILED = 0; \ + if (!IsApplTerm(d0)) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_SREG) = RepAppl(d0); \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + if (*(*_SREG)++ != d0) { \ + YAAM_FAIL; \ + } \ + else { \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + GONext(); \ + } \ + } + +#define UNIFY_L_STRUC_WRITEMODE \ + START_PREFETCH_W(ofa); \ + d1 = AbsAppl(HR); \ + Bind_Global(pt0, d1); \ + pt0 = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *pt0++ = d0; \ + HR = pt0 + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + (*_SREG) = pt0; \ + GONextW(); \ + END_PREFETCH_W(); + +#define UNIFY_L_STRUC_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + CACHE_S(); \ + READ_IN_S(); \ + S_SREG[0] = d0; \ + S_SREG = HR; \ + d0 = (CELL) ((*_PREG)->u.ofa.f); \ + *S_SREG++ = d0; \ + HR = S_SREG + (*_PREG)->u.ofa.a; \ + (*_PREG) = NEXTOP((*_PREG), ofa); \ + WRITEBACK_S(S_SREG); \ + ENDCACHE_S(); \ + GONextW(); + +#define SAVE_PAIR_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + XREG((*_PREG)->u.ox.x) = AbsPair((*_SREG)); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONext(); + +#define SAVE_PAIR_X_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + XREG((*_PREG)->u.ox.x) = AbsPair((*_SREG)); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONextW(); + +#define SAVE_PAIR_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsPair((*_SREG))); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); + +#define SAVE_PAIR_Y_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsPair((*_SREG))); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); + +#define SAVE_APPL_X_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + XREG((*_PREG)->u.ox.x) = AbsAppl((*_SREG) - 1); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONext(); + +#define SAVE_APPL_X_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + XREG((*_PREG)->u.ox.x) = AbsAppl((*_SREG) - 1); \ + (*_PREG) = NEXTOP((*_PREG), ox); \ + GONextW(); + +#define SAVE_APPL_Y_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsAppl((*_SREG)-1)); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONext(); + +#define SAVE_APPL_Y_WRITE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.oy.y,AbsAppl((*_SREG)-1)); \ + (*_PREG) = NEXTOP((*_PREG), oy); \ + GONextW(); + diff --git a/JIT/HPP/yaam_write.h b/JIT/HPP/yaam_write.h new file mode 100644 index 000000000..c1c425753 --- /dev/null +++ b/JIT/HPP/yaam_write.h @@ -0,0 +1,297 @@ +#define WRITE_X_VAR_INSTINIT \ + XREG((*_PREG)->u.x.x) = Unsigned((*_SREG)); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); + +#define WRITE_VOID_INSTINIT \ + (*_PREG) = NEXTOP((*_PREG), e); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); + +#define WRITE_N_VOIDS_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.s.s; \ + (*_PREG) = NEXTOP((*_PREG), s); \ + for (; d0 > 0; d0--) { \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + } \ + GONext(); + +#define WRITE_Y_VAR_INSTINIT \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.y.y,Unsigned((*_SREG))); \ + (*_PREG) = NEXTOP((*_PREG), y); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); + +#define WRITE_X_VAL_INSTINIT \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.x.x); \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), x); \ + GONext(); + +#define WRITE_X_LOC_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.x.x); \ + (*_PREG) = NEXTOP((*_PREG), x); + +#define WRITE_X_LOC_W_X_BOUND \ + *(*_SREG)++ = d0; \ + GONext(); + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#ifdef FROZEN_STACKS +#define WRITE_X_LOC_W_X_UNK \ + if (pt0 > HR && pt0<(CELL *)B_FZ) { \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#else /* FROZEN_STACKS */ +#define WRITE_X_LOC_W_X_UNK \ + if (pt0 > HR && pt0<(CELL *)B_FZ) { \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + *pt0 = Unsigned((*_SREG)); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#ifdef FROZEN_STACKS +#define WRITE_X_LOC_W_X_UNK \ + if (pt0 > HR) { \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#else /* FROZEN_STACKS */ +#define WRITE_X_LOC_W_X_UNK \ + if (pt0 > HR) { \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + *pt0 = Unsigned((*_SREG)); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /*defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#ifdef YAPOR_SBA +#define WRITE_Y_VAL_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.y.y]; \ + if (d0 == 0) \ + *(*_SREG)++ = (CELL)(YREG+(*_PREG)->u.y.y); \ + else \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONext(); +#else /* YAPOR_SBA */ +#define WRITE_Y_VAL_INSTINIT \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.y.y]; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONext(); +#endif /* YAPOR_SBA */ + +#define WRITE_Y_LOC_INSTINIT \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.y.y; \ + d0 = *pt0; + +#define WRITE_Y_LOC_W_Y_BOUND \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = d0; \ + GONext(); + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#ifdef FROZEN_STACKS +#define WRITE_Y_LOC_W_Y_UNK \ + if (pt0 > HR \ + && pt0<(CELL *)B_FZ \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#else /* FROZEN_STACKS */ +#define WRITE_Y_LOC_W_Y_UNK \ + if (pt0 > HR \ + && pt0<(CELL *)B_FZ \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *pt0 = Unsigned((*_SREG)); \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#ifdef FROZEN_STACKS +#define WRITE_Y_LOC_W_Y_UNK \ + if (pt0 > HR \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#else /* FROZEN_STACKS */ +#define WRITE_Y_LOC_W_Y_UNK \ + if (pt0 > HR \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *pt0 = Unsigned((*_SREG)); \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#define WRITE_ATOM_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.c.c; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), c); \ + GONext(); + +#define WRITE_BIGINT_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.N.b; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), N); \ + GONext(); + +#define WRITE_DBTERM_INSTINIT \ + register CELL d0; \ + d0 = (*_PREG)->u.D.D; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), D); \ + GONext(); + +#define WRITE_FLOAT_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.d.d); \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), d); \ + GONext(); + +#define WRITE_LONGIT_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.i.i); \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), i); \ + GONext(); + +#define WRITE_N_ATOMS_INSTINIT \ + register CELL d0, d1; \ + d0 = (*_PREG)->u.sc.s; \ + d1 = (*_PREG)->u.sc.c; \ + for (; d0 > 0; d0--) { \ + *(*_SREG)++ = d1; \ + } \ + (*_PREG) = NEXTOP((*_PREG), sc); \ + GONext(); + +#define WRITE_LIST_INSTINIT \ + register CELL d0; \ + d0 = AbsPair(HR); \ + *(*_SREG)++ = d0; \ + SP[-1] = Unsigned((*_SREG)); \ + SP[-2] = 1; \ + SP -= 2; \ + (*_SREG) = HR; \ + HR += 2; \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); + +#define WRITE_L_LIST_INSTINIT \ + register CELL d0; \ + ALWAYS_START_PREFETCH(e); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = AbsPair(HR); \ + *S_SREG = d0; \ + WRITEBACK_S(HR); \ + HR += 2; \ + ENDCACHE_S(); \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); + +#define WRITE_STRUCT_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + *(*_SREG)++ = d0; \ + SP[-1] = Unsigned((*_SREG)); \ + SP[-2] = 1; \ + SP -= 2; \ + d0 = (CELL) ((*_PREG)->u.fa.f); \ + *H++ = d0; \ + d0 = (*_PREG)->u.fa.a; \ + (*_PREG) = NEXTOP((*_PREG), fa); \ + (*_SREG) = HR; \ + HR += d0; \ + GONext(); + +#define WRITE_L_STRUC_INSTINIT \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + *(*_SREG) = d0; \ + d0 = (CELL) ((*_PREG)->u.fa.f); \ + *H++ = d0; \ + (*_SREG) = HR; \ + d0 = (*_PREG)->u.fa.a; \ + (*_PREG) = NEXTOP((*_PREG), fa); \ + HR += d0; \ + GONext(); + diff --git a/JIT/HPP/yaam_write_d.h b/JIT/HPP/yaam_write_d.h new file mode 100644 index 000000000..36c703ff7 --- /dev/null +++ b/JIT/HPP/yaam_write_d.h @@ -0,0 +1,316 @@ +#define WRITE_X_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + XREG((*_PREG)->u.x.x) = Unsigned((*_SREG)); \ + (*_PREG) = NEXTOP((*_PREG), x); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); + +#define WRITE_VOID_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); + +#define WRITE_N_VOIDS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_PREG)->u.s.s; \ + (*_PREG) = NEXTOP((*_PREG), s); \ + for (; d0 > 0; d0--) { \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + } \ + GONext(); + +#define WRITE_Y_VAR_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + INITIALIZE_PERMVAR(YREG+(*_PREG)->u.y.y,Unsigned((*_SREG))); \ + (*_PREG) = NEXTOP((*_PREG), y); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); + +#define WRITE_X_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = XREG((*_PREG)->u.x.x); \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), x); \ + GONext(); + +#define WRITE_X_LOC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + d0 = XREG((*_PREG)->u.x.x); \ + (*_PREG) = NEXTOP((*_PREG), x); + +#define WRITE_X_LOC_W_X_BOUND \ + *(*_SREG)++ = d0; \ + GONext(); + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#ifdef FROZEN_STACKS +#define WRITE_X_LOC_W_X_UNK \ + if (pt0 > HR && pt0<(CELL *)B_FZ) { \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#else /* FROZEN_STACKS */ +#define WRITE_X_LOC_W_X_UNK \ + if (pt0 > HR && pt0<(CELL *)B_FZ) { \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + *pt0 = Unsigned((*_SREG)); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#ifdef FROZEN_STACKS +#define WRITE_X_LOC_W_X_UNK \ + if (pt0 > HR) { \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#else /* FROZEN_STACKS */ +#define WRITE_X_LOC_W_X_UNK \ + if (pt0 > HR) { \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + *pt0 = Unsigned((*_SREG)); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } \ + else { \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /*defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#ifdef YAPOR_SBA +#define WRITE_Y_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.y.y]; \ + if (d0 == 0) \ + *(*_SREG)++ = (CELL)(YREG+(*_PREG)->u.y.y); \ + else \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONext(); +#else /* YAPOR_SBA */ +#define WRITE_Y_VAL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = YREG[(*_PREG)->u.y.y]; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), y); \ + GONext(); +#endif /* YAPOR_SBA */ + +#define WRITE_Y_LOC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + register CELL *pt0; \ + pt0 = YREG+(*_PREG)->u.y.y; \ + d0 = *pt0; + +#define WRITE_Y_LOC_W_Y_BOUND \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = d0; \ + GONext(); + +#if defined(YAPOR_SBA) && defined(FROZEN_STACKS) +#ifdef FROZEN_STACKS +#define WRITE_Y_LOC_W_Y_UNK \ + if (pt0 > HR \ + && pt0<(CELL *)B_FZ \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#else /* FROZEN_STACKS */ +#define WRITE_Y_LOC_W_Y_UNK \ + if (pt0 > HR \ + && pt0<(CELL *)B_FZ \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *pt0 = Unsigned((*_SREG)); \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#endif /* FROZEN_STACKS */ +#else /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ +#ifdef FROZEN_STACKS +#define WRITE_Y_LOC_W_Y_UNK \ + if (pt0 > HR \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + Bind_Local(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#else /* FROZEN_STACKS */ +#define WRITE_Y_LOC_W_Y_UNK \ + if (pt0 > HR \ + ) { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *pt0 = Unsigned((*_SREG)); \ + TRAIL_LOCAL(pt0, Unsigned((*_SREG))); \ + RESET_VARIABLE((*_SREG)); \ + (*_SREG)++; \ + GONext(); \ + } else { \ + (*_PREG) = NEXTOP((*_PREG), y); \ + *(*_SREG)++ = Unsigned(pt0); \ + GONext(); \ + } +#endif /* FROZEN_STACKS */ +#endif /* defined(YAPOR_SBA) && defined(FROZEN_STACKS) */ + +#define WRITE_ATOM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_PREG)->u.c.c; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), c); \ + GONext(); + +#define WRITE_BIGINT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_PREG)->u.N.b; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), N); \ + GONext(); + +#define WRITE_DBTERM_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = (*_PREG)->u.D.D; \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), D); \ + GONext(); + +#define WRITE_FLOAT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.d.d); \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), d); \ + GONext(); + +#define WRITE_LONGIT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsAppl((*_PREG)->u.i.i); \ + *(*_SREG)++ = d0; \ + (*_PREG) = NEXTOP((*_PREG), i); \ + GONext(); + +#define WRITE_N_ATOMS_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0, d1; \ + d0 = (*_PREG)->u.sc.s; \ + d1 = (*_PREG)->u.sc.c; \ + for (; d0 > 0; d0--) { \ + *(*_SREG)++ = d1; \ + } \ + (*_PREG) = NEXTOP((*_PREG), sc); \ + GONext(); + +#define WRITE_LIST_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsPair(HR); \ + *(*_SREG)++ = d0; \ + SP[-1] = Unsigned((*_SREG)); \ + SP[-2] = 1; \ + SP -= 2; \ + (*_SREG) = HR; \ + HR += 2; \ + (*_PREG) = NEXTOP((*_PREG), e); \ + GONext(); + +#define WRITE_L_LIST_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + ALWAYS_START_PREFETCH(e); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + CACHE_S(); \ + READ_IN_S(); \ + d0 = AbsPair(HR); \ + *S_SREG = d0; \ + WRITEBACK_S(HR); \ + HR += 2; \ + ENDCACHE_S(); \ + ALWAYS_GONext(); \ + ALWAYS_END_PREFETCH(); + +#define WRITE_STRUCT_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + *(*_SREG)++ = d0; \ + SP[-1] = Unsigned((*_SREG)); \ + SP[-2] = 1; \ + SP -= 2; \ + d0 = (CELL) ((*_PREG)->u.fa.f); \ + *H++ = d0; \ + d0 = (*_PREG)->u.fa.a; \ + (*_PREG) = NEXTOP((*_PREG), fa); \ + (*_SREG) = HR; \ + HR += d0; \ + GONext(); + +#define WRITE_L_STRUC_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + register CELL d0; \ + d0 = AbsAppl(HR); \ + *(*_SREG) = d0; \ + d0 = (CELL) ((*_PREG)->u.fa.f); \ + *H++ = d0; \ + (*_SREG) = HR; \ + d0 = (*_PREG)->u.fa.a; \ + (*_PREG) = NEXTOP((*_PREG), fa); \ + HR += d0; \ + GONext(); + diff --git a/JIT/JIT_Compiler.cpp b/JIT/JIT_Compiler.cpp new file mode 100644 index 000000000..0fd4fec23 --- /dev/null +++ b/JIT/JIT_Compiler.cpp @@ -0,0 +1,876 @@ +#include "JIT_Compiler.hpp" +#include +#include +#include + +using namespace std; + +#define FREE_ALLOCATED() \ + free(buffer); \ + free(p->u.jhc.jh->cmd); \ + free(outputfilename); \ + free(optoutputfilename); \ + free(cmd1); \ + free(cmd2); + +#define ADD_PASS_ACCORDING_TO_KIND() \ + switch (Kind) { \ + case PT_BasicBlock: \ + fprintf(stderr, "Oops -- basicblock printer\n"); \ + exit(1); \ + case PT_Region: \ + Pass.add(new RegionPassPrinter(PI)); \ + break; \ + case PT_Loop: \ + Pass.add(new LoopPassPrinter(PI)); \ + break; \ + case PT_Function: \ + Pass.add(new FunctionPassPrinter(PI)); \ + break; \ + case PT_CallGraphSCC: \ + Pass.add(new CallGraphSCCPassPrinter(PI)); \ + break; \ + default: \ + Pass.add(new ModulePassPrinter(PI)); \ + break; \ + } + +#define TREAT_CASE_FOR(PASS) \ + PI = PassRegistry::getPassRegistry()->getPassInfo(PASS->getPassID()); \ + Kind = PASS->getPassKind(); \ + ADD_PASS_ACCORDING_TO_KIND(); + +#include "PassPrinters.hpp" + +void JIT_Compiler::analyze_module(llvm::Module* &M) +{ + PassManager Pass; // 'Pass' stores analysis passes to be applied + TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple())); + + const PassInfo *PI; + PassKind Kind; + + Pass.add(TLI); // First, I add on 'Pass' the Target Info of Module + Pass.add(new TargetData(M)); // Second, I must add Target Data on 'Pass' + for (int i = 0; i < ExpEnv.analysis_struc.n; i++) { + /* + * 'ExpEnv.analysis_struc.act_an' contains sorted analysis passes * + * 'ExpEnv.analysis_struc.act_an' is filled by analysis predicates * + * What must I do? * + * 1. Pass over 'ExpEnv.analysis_struc.act_an' (by previous 'for') * + * 2. For each unity within 'ExpEnv.analysis_struc.act_an' * + * 2.1. Check its type * + * 2.2. Add analysis pass on 'Pass' accordingly the type checked * + */ + switch (ExpEnv.analysis_struc.act_an[i]) { + case e_createAAEvalPass: + TREAT_CASE_FOR(createAAEvalPass()); + break; + case e_createBasicAliasAnalysisPass: + TREAT_CASE_FOR(createBasicAliasAnalysisPass()); + break; + case e_createAliasAnalysisCounterPass: + TREAT_CASE_FOR(createAliasAnalysisCounterPass()); + break; + case e_createGlobalsModRefPass: + TREAT_CASE_FOR(createGlobalsModRefPass()); + break; + case e_createInstCountPass: + TREAT_CASE_FOR(createInstCountPass()); + break; + case e_createIVUsersPass: + TREAT_CASE_FOR(createIVUsersPass()); + break; + case e_createLazyValueInfoPass: + TREAT_CASE_FOR(createLazyValueInfoPass()); + break; + case e_createLoopDependenceAnalysisPass: + TREAT_CASE_FOR(createLoopDependenceAnalysisPass()); + break; + case e_createLibCallAliasAnalysisPass: + TREAT_CASE_FOR(createLibCallAliasAnalysisPass(NULL)); + break; + case e_createLintPass: + TREAT_CASE_FOR(createLintPass()); + break; + case e_createMemDepPrinter: + TREAT_CASE_FOR(createMemDepPrinter()); + break; + case e_createModuleDebugInfoPrinterPass: + TREAT_CASE_FOR(createModuleDebugInfoPrinterPass()); + break; + case e_createNoAAPass: + TREAT_CASE_FOR(createNoAAPass()); + break; + case e_createNoPathProfileInfoPass: + TREAT_CASE_FOR(createNoPathProfileInfoPass()); + break; + case e_createNoProfileInfoPass: + TREAT_CASE_FOR(createNoProfileInfoPass()); + break; + case e_createObjCARCAliasAnalysisPass: + TREAT_CASE_FOR(createObjCARCAliasAnalysisPass()); + break; + case e_createProfileEstimatorPass: + TREAT_CASE_FOR(createProfileEstimatorPass()); + break; + case e_createProfileLoaderPass: + TREAT_CASE_FOR(createProfileLoaderPass()); + break; + case e_createProfileVerifierPass: + TREAT_CASE_FOR(createProfileVerifierPass()); + break; + case e_createRegionInfoPass: + TREAT_CASE_FOR(createRegionInfoPass()); + break; + case e_createScalarEvolutionAliasAnalysisPass: + TREAT_CASE_FOR(createScalarEvolutionAliasAnalysisPass()); + break; + case e_createTypeBasedAliasAnalysisPass: + TREAT_CASE_FOR(createTypeBasedAliasAnalysisPass()); + break; + case e_createDbgInfoPrinterPass: + TREAT_CASE_FOR(createDbgInfoPrinterPass()); + break; + case e_createCFGPrinterPass: + TREAT_CASE_FOR(createCFGPrinterPass()); + break; + case e_createCFGOnlyPrinterPass: + TREAT_CASE_FOR(createCFGOnlyPrinterPass()); + break; + case e_createDomPrinterPass: + TREAT_CASE_FOR(createDomPrinterPass()); + break; + case e_createDomOnlyPrinterPass: + TREAT_CASE_FOR(createDomOnlyPrinterPass()); + break; + case e_createPostDomPrinterPass: + TREAT_CASE_FOR(createPostDomPrinterPass()); + break; + case e_createPostDomOnlyPrinterPass: + TREAT_CASE_FOR(createPostDomOnlyPrinterPass()); + break; + case e_createRegionPrinterPass: + TREAT_CASE_FOR(createRegionPrinterPass()); + break; + case e_createRegionOnlyPrinterPass: + TREAT_CASE_FOR(createRegionOnlyPrinterPass()); + break; + case e_createPathProfileLoaderPass: + TREAT_CASE_FOR(createPathProfileLoaderPass()); + break; + case e_createPathProfileVerifierPass: + TREAT_CASE_FOR(createPathProfileVerifierPass()); + break; + default:; + } + } + + /* if 'llvm::TimePassesIsEnabled' is 'true', llvm time passes are printed on 'shutdown_llvm()' (p_halt -- stdpreds.c) */ + llvm::TimePassesIsEnabled = ExpEnv.analysis_struc.time_pass_enabled; + /* Use 'llvm::EnableStatistics()' so that llvm stats are printed on 'shutdown_llvm()' (p_halt -- stdpreds.c) */ + if (ExpEnv.analysis_struc.stats_enabled) llvm::EnableStatistics(); + + /* + * Here, I configure resulting analysis output -- default: stderr * + * Use analysis_output_file/1 to change * + */ + if (strcmp(((char*)ExpEnv.analysis_struc.outfile), "STDERR")) { // print to file that is not stderr + int stderrcopy = dup(2); // stderr backup + if (strcmp(((char*)ExpEnv.analysis_struc.outfile), "STDOUT") == 0) { // print to stdout + dup2(1, 2); // 2 is stderr; 1 is stdout -- dup2(1,2) redirects stderr output to stdout + Pass.run(*M); // Run passes (results will be printed on stdout) + dup2(stderrcopy, 2); // Recovers stderr + } + else { + int Outputfile = open(((char*)ExpEnv.analysis_struc.outfile), O_CREAT | O_TRUNC | O_WRONLY, 0777); + // Openning Output file, whose name is on 'ExpEnv.analysis_struc.outfile' + if (Outputfile < 0) { + fprintf(stderr, "Error:: I can not write analysis passes's output on %s...\n", ((char*)ExpEnv.analysis_struc.outfile)); + fprintf(stderr, " %s...\n", strerror(errno)); + errno = 0; + exit(1); + } + dup2(Outputfile, 2); // 2 is stderr; Outputfile is any other file -- dup2(Outputfile,2) redirects stderr output to Outputfile + Pass.run(*M); // Run passes (results will be printed on Outputfile) + close(Outputfile); + dup2(stderrcopy, 2); // Recovers stderr + } + close(stderrcopy); + } + else // print to stderr + Pass.run(*M); // Run passes (results will be printed on stderr) +} + +void JIT_Compiler::optimize_module(llvm::Module* &M) +{ + if (ExpEnv.transform_struc.optlevel > -1) { /* Do I need to apply transform level? */ + /* Yes, I do, so... */ + + /* Initializes PassManager for Function */ + OwningPtr FPM; + FPM.reset(new FunctionPassManager(M)); + FPM->add(new TargetData(M)); + PassManagerBuilder Builder; // aid to 'FPM' and 'MPM' + + /* Initializes PassManager for Function */ + PassManager MPM; + TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple())); + MPM.add(TLI); + MPM.add(new TargetData(M)); + + /* Populates 'Builder' */ + Builder.OptLevel = ExpEnv.transform_struc.optlevel; + Builder.DisableUnitAtATime = !ExpEnv.transform_struc.unit_at_time_enabled; + Builder.DisableSimplifyLibCalls = !ExpEnv.transform_struc.simplify_libcalls_enabled; + /* inline and unrool only be enabled if 'ExpEnv.transform_struc.optlevel' > 0 */ + if (ExpEnv.transform_struc.optlevel) Builder.Inliner = + createFunctionInliningPass(ExpEnv.transform_struc.opt_args.inline_threshold); + Builder.DisableUnrollLoops = (ExpEnv.transform_struc.optlevel == 0); + /***/ + /***/ + + /* Populates 'FPM' from 'Builder' */ + Builder.populateFunctionPassManager(*FPM); + /* Populates 'MPM' from 'Builder' */ + Builder.populateModulePassManager(MPM); + + /* + * Enabling link-time optimizations -- default is no * + * Use 'link_time_opt/1', 'link_time_opt/3', 'enable_link_time_opt/0', or 'enable_link_time_opt/2' to change * + */ + if (ExpEnv.transform_struc.link_time_opt.enabled) + Builder.populateLTOPassManager(MPM, + (bool)ExpEnv.transform_struc.link_time_opt.internalize, + (bool)ExpEnv.transform_struc.link_time_opt.runinliner); + /***/ + + //set_regalloc_pass(MPM); + + /* Pass over all functions within Module and run passes */ + FPM->doInitialization(); + for (Module::iterator F = M->begin(), E = M->end(); F != E; ++F) + FPM->run(*F); + FPM->doFinalization(); + /***/ + + MPM.run(*M); // Run passes on module + } + else { + /* No, I need to apply transform passes accordingly transform predicates but transform_level/1 */ + std::vector GVvector; // 'createGVExtractionPass' argument + PassManager Pass; // 'Pass' stores transform passes to be applied + TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple())); + Pass.add(TLI); // First, I add on 'Pass' the Target Info of Module + Pass.add(new TargetData(M)); // Second, I must add Target Data on 'Pass' + for (int i = 0; i < ExpEnv.transform_struc.n; i++) { + /* + * 'ExpEnv.transform_struc.act_tr' contains sorted transform passes * + * 'ExpEnv.transform_struc.act_tr' is filled by transform predicates * + * What must I do? * + * 1. Pass over 'ExpEnv.transform_struc.act_tr' (by previous 'for') * + * 2. For each unity within 'ExpEnv.analysis_struc.act_an', add transform pass on 'Pass' * + */ + switch (ExpEnv.transform_struc.act_tr[i]) { + case t_createAggressiveDCEPass: + Pass.add(createAggressiveDCEPass()); + break; + case t_createArgumentPromotionPass: + Pass.add(createArgumentPromotionPass((Int)ExpEnv.transform_struc.opt_args.arg_promotion_max_elements)); + break; + case t_createBBVectorizePass: + Pass.add(createBBVectorizePass()); + break; + case t_createBlockExtractorPass: + Pass.add(createBlockExtractorPass()); + break; + case t_createBlockPlacementPass: + Pass.add(createBlockPlacementPass()); + break; + case t_createBreakCriticalEdgesPass: + Pass.add(createBreakCriticalEdgesPass()); + break; + case t_createCFGSimplificationPass: + Pass.add(createCFGSimplificationPass()); + break; + case t_createCodeGenPreparePass: + Pass.add(createCodeGenPreparePass()); + break; + case t_createConstantMergePass: + Pass.add(createConstantMergePass()); + break; + case t_createConstantPropagationPass: + Pass.add(createConstantPropagationPass()); + break; + case t_createCorrelatedValuePropagationPass: + Pass.add(createCorrelatedValuePropagationPass()); + break; + case t_createDeadArgEliminationPass: + Pass.add(createDeadArgEliminationPass()); + break; + case t_createDeadArgHackingPass: + Pass.add(createDeadArgHackingPass()); + break; + case t_createDeadCodeEliminationPass: + Pass.add(createDeadCodeEliminationPass()); + break; + case t_createDeadInstEliminationPass: + Pass.add(createDeadInstEliminationPass()); + break; + case t_createDeadStoreEliminationPass: + Pass.add(createDeadStoreEliminationPass()); + break; + case t_createDemoteRegisterToMemoryPass: + Pass.add(createDemoteRegisterToMemoryPass()); + break; + case t_createEarlyCSEPass: + Pass.add(createEarlyCSEPass()); + break; + case t_createFunctionAttrsPass: + Pass.add(createFunctionAttrsPass()); + break; + case t_createFunctionInliningPass: + Pass.add(createFunctionInliningPass(ExpEnv.transform_struc.opt_args.inline_threshold)); + break; + case t_createGlobalDCEPass: + Pass.add(createGlobalDCEPass()); + break; + case t_createGlobalOptimizerPass: + Pass.add(createGlobalOptimizerPass()); + break; + case t_createGVExtractionPass: + Pass.add(createGVExtractionPass(GVvector)); + break; + case t_createGVNPass: + Pass.add(createGVNPass()); + break; + case t_createIndVarSimplifyPass: + Pass.add(createIndVarSimplifyPass()); + break; + case t_createInstructionCombiningPass: + Pass.add(createInstructionCombiningPass()); + break; + case t_createInstructionNamerPass: + Pass.add(createInstructionNamerPass()); + break; + case t_createInstructionSimplifierPass: + Pass.add(createInstructionSimplifierPass()); + break; + case t_createInternalizePass: + Pass.add(createInternalizePass(true)); + break; + case t_createIPConstantPropagationPass: + Pass.add(createIPConstantPropagationPass()); + break; + case t_createIPSCCPPass: + Pass.add(createIPSCCPPass()); + break; + case t_createJumpThreadingPass: + Pass.add(createJumpThreadingPass()); + break; + case t_createLCSSAPass: + Pass.add(createLCSSAPass()); + break; + case t_createLICMPass: + Pass.add(createLICMPass()); + break; + case t_createLoopDeletionPass: + Pass.add(createLoopDeletionPass()); + break; + case t_createLoopExtractorPass: + Pass.add(createLoopExtractorPass()); + break; + case t_createLoopIdiomPass: + Pass.add(createLoopIdiomPass()); + break; + case t_createLoopInstSimplifyPass: + Pass.add(createLoopInstSimplifyPass()); + break; + case t_createLoopRotatePass: + Pass.add(createLoopRotatePass()); + break; + case t_createLoopSimplifyPass: + Pass.add(createLoopSimplifyPass()); + break; + case t_createLoopStrengthReducePass: + Pass.add(createLoopStrengthReducePass()); + break; + case t_createLoopUnrollPass: + Pass.add(createLoopUnrollPass((Int)ExpEnv.transform_struc.opt_args.loop_unroll_threshold)); + break; + case t_createLoopUnswitchPass: + Pass.add(createLoopUnswitchPass((bool)ExpEnv.transform_struc.opt_args.loop_unswitch_optimize_for_size)); + break; + case t_createLowerAtomicPass: + Pass.add(createLowerAtomicPass()); + break; + case t_createLowerExpectIntrinsicPass: + Pass.add(createLowerExpectIntrinsicPass()); + break; + case t_createLowerInvokePass: + Pass.add(createLowerInvokePass()); + break; + case t_createLowerSwitchPass: + Pass.add(createLowerSwitchPass()); + break; + case t_createMemCpyOptPass: + Pass.add(createMemCpyOptPass()); + break; + case t_createMergeFunctionsPass: + Pass.add(createMergeFunctionsPass()); + break; + case t_createObjCARCAPElimPass: + Pass.add(createObjCARCAPElimPass()); + break; + case t_createObjCARCContractPass: + Pass.add(createObjCARCContractPass()); + break; + case t_createObjCARCExpandPass: + Pass.add(createObjCARCExpandPass()); + break; + case t_createObjCARCOptPass: + Pass.add(createObjCARCOptPass()); + break; + case t_createPartialInliningPass: + Pass.add(createPartialInliningPass()); + break; + case t_createPromoteMemoryToRegisterPass: + Pass.add(createPromoteMemoryToRegisterPass()); + break; + case t_createPruneEHPass: + Pass.add(createPruneEHPass()); + break; + case t_createReassociatePass: + Pass.add(createReassociatePass()); + break; + case t_createScalarReplAggregatesPass: + Pass.add(createScalarReplAggregatesPass((Int)ExpEnv.transform_struc.opt_args.scalar_replace_aggregates_threshold)); + break; + case t_createSCCPPass: + Pass.add(createSCCPPass()); + break; + case t_createSimplifyLibCallsPass: + Pass.add(createSimplifyLibCallsPass()); + break; + case t_createSingleLoopExtractorPass: + Pass.add(createSingleLoopExtractorPass()); + break; + case t_createSinkingPass: + Pass.add(createSinkingPass()); + break; + case t_createStripDeadDebugInfoPass: + Pass.add(createStripDeadDebugInfoPass()); + break; + case t_createStripDeadPrototypesPass: + Pass.add(createStripDeadPrototypesPass()); + break; + case t_createStripDebugDeclarePass: + Pass.add(createStripDebugDeclarePass()); + break; + case t_createStripNonDebugSymbolsPass: + Pass.add(createStripNonDebugSymbolsPass()); + break; + case t_createStripSymbolsPass: + Pass.add(createStripSymbolsPass((bool)ExpEnv.transform_struc.opt_args.strip_symbols_pass_type)); + break; + case t_createTailCallEliminationPass: + Pass.add(createTailCallEliminationPass()); + break; + default:; + } + } + //set_regalloc_pass(Pass); + Pass.run(*M); // Run passes + } +} + +void JIT_Compiler::set_regalloc_pass(PassManager &PM) { + // 'ExpEnv.codegen_struc.struc_enginebuilder.regallocator' contains the active register allocator to be used + switch(ExpEnv.codegen_struc.struc_enginebuilder.regallocator) { + case REG_ALLOC_BASIC: + PM.add(createBasicRegisterAllocator()); + break; + case REG_ALLOC_FAST: + PM.add(createFastRegisterAllocator()); + break; + case REG_ALLOC_GREEDY: + PM.add(createGreedyRegisterAllocator()); + break; + case REG_ALLOC_PBQP: + PM.add(createDefaultPBQPRegisterAllocator()); + break; + } +} + +void* JIT_Compiler::compile_all(LLVMContext* &Context, yamop* p) +{ + /* Init llvm code generation, analysis and transform passes */ + InitializeNativeTarget(); + PassRegistry &Registry = *PassRegistry::getPassRegistry(); + initializeCore(Registry); + initializeScalarOpts(Registry); + initializeVectorization(Registry); + initializeIPO(Registry); + initializeAnalysis(Registry); + initializeIPA(Registry); + initializeTransformUtils(Registry); + initializeInstCombine(Registry); + initializeInstrumentation(Registry); + initializeTarget(Registry); + sys::Process::PreventCoreFiles(); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wwrite-strings" + /* CLANG arguments */ + char *clang_args[] = +{ + "clang", "-fomit-frame-pointer", "-O0", +#if CUT_C + "-DCUT_C=1", +#endif +#if COROUTINING + "-DCOROUTINING=1", +#endif +#if RATIONAL_TREES + "-DRATIONAL_TREES=1", +#endif +#if DEBUG + "-DDEBUG=1", +#endif +#if DEPTH_LIMIT + "-DDEPTH_LIMIT=1", +#endif +#if YAP_DBG_PREDS + "-DYAP_DBG_PREDS=1", +#endif +#if YAP_STAT_PREDS + "-DYAP_STAT_PREDS=1", +#endif +#if TABLING + "-DTABLING=1", +#endif +#if _YAP_NOT_INSTALLED_ + "-D_YAP_NOT_INSTALLED_=1", +#endif +#ifdef HAVE_CONFIG_H + "-DHAVE_CONFIG_H", +#endif + "-DYAP_JIT", "-D_NATIVE=1", "-I.", "-I./H", "-I./include", "-I./os", "-I./OPTYap", "-I./BEAM", "-I./MYDDAS", "-I./HPP", "-xc", "-c", "-", "-o", "-", "-emit-llvm", NULL +}; +#pragma GCC diagnostic pop + + std::string errStr; + llvm::error_code e; + OwningPtr bf; + + /* Pipe to communicate 'echo' with 'clang' */ + int pipe1[2]; + int pid_echo, pid_clang ; + + /* 'clang' out file */ + char* outputfilename = (char*)malloc(33*sizeof(char)); + sprintf(outputfilename, "%lx.bc", (CELL)p); + int Output = open(outputfilename, O_CREAT | O_RDWR, 0644); + + /* Creating pipes */ + if (pipe(pipe1)<0) { + perror(" ERROR!!\n ERROR") ; + exit(1); + } + + /* Calls echo. */ + pid_echo = fork() ; + if (pid_echo < 0) { + perror(" ERROR!!\n ERROR") ; + exit(1); + } + if (!pid_echo) { + /* Setting echo's output to 1st pipe */ + dup2(pipe1[1], 1); + + /* Closing pipes */ + close(pipe1[0]); + close(pipe1[1]); + + execlp("echo", "echo", p->u.jhc.jh->tcc.cmd, NULL); + } + else { + /* Calls clang. */ + pid_clang = fork() ; + if (pid_clang < 0) { + perror(" ERROR!!\n ERROR") ; + exit(1); + } + if (!pid_clang) { + /* Setting clang's input from 1st pipe */ + dup2(pipe1[0], 0) ; + + /* Setting clang's output to Output */ + dup2(Output, 1) ; + + /* Closing pipes */ + close(pipe1[0]); + close(pipe1[1]); + + execvp(*clang_args, clang_args); + } + } + /* Closing pipes */ + close(pipe1[0]); + close(pipe1[1]); + + /* waiting for completion of processes */ + int i; + int *status = NULL; + // 2 means two processes: 'echo' and 'clang' + for (i = 0; i < 2; i++) wait(status); + /***/ + + /* + * At this point, the compiled code (O0) is on 'Output' * + * I need to read it to main memory * + * for this, I'll use 'MemoryBuffer::getOpenFile' * + */ + lseek(Output, 0, SEEK_SET); + e = MemoryBuffer::getOpenFile(Output, outputfilename, bf); + if (e) { + errs() << "ERROR::Unable to MemoryBuffer from " << outputfilename << " -- " << e.message() << "\n"; + exit(1); + } + + /* + * At this point, the compiled code (O0) is on main memory * + * I need to read it to Module * + * for this, I'll use 'ParseBitcodeFile' * + */ + Module *Mod = ParseBitcodeFile(bf.get(), *Context); + + /* + * verify module correctness * + * predicates: * + * enable_module_correctness/1 * + * verify_module_before/0 * + * verify_module_both/0 * + */ + if (ExpEnv.analysis_struc.pointtoverifymodule == BEFORE || ExpEnv.analysis_struc.pointtoverifymodule == BOTH) { + if (verifyModule(*Mod)) { + errs() << "ERROR:: Module not built correctly!\n"; + exit(1); + } + } + /***/ + +#if YAP_DBG_PREDS + /* for debug... print module before optimizing it */ + if (ExpEnv.debug_struc.pprint_llva.print_llva_before) + errs() << "Module before optimization::\n" << *Mod; +#endif + + /* Analyze module -- analysis predicates */ + analyze_module(Mod); + /* Optimize module -- transform predicates */ + optimize_module(Mod); + + /* Computing size of optimized module */ + { + /* Open file 'tmp.bc' which will be filled by optimized Module */ + OwningPtr Out; + std::string ErrorInfo; + Out.reset(new tool_output_file("tmp.bc", ErrorInfo, raw_fd_ostream::F_Binary)); + if (!ErrorInfo.empty()) { + errs() << ErrorInfo << '\n'; + exit(1); + } + /* 'createPrintModulePass(arg)' will print Module (now optimized) to on file represented by 'arg' */ + PassManager Pass; + Pass.add(createPrintModulePass(&Out->os())); + Pass.run(*Mod); + /* 'Out->keep()' will keep printed module to file and will close file */ + Out->keep(); + + /* Open file 'tmp.bc' */ + int Outtmp = open("tmp.bc", O_CREAT | O_RDWR, 0644); +#if YAP_STAT_PREDS + /* for statistics... compute file size and store value on 'NativeArea->area.native_size_bytes' */ + NativeArea->area.native_size_bytes[p->u.jhc.jh->caa.naddress][NativeArea->area.nrecomp[p->u.jhc.jh->caa.naddress]-1] = lseek(Outtmp, 0, SEEK_END); +#endif + close(Outtmp); + remove("tmp.bc"); + } + /***/ + +#if YAP_DBG_PREDS + /* for debug... print module after optimizing it */ + if (ExpEnv.debug_struc.pprint_llva.print_llva_after) + errs() << "Module after optimization::\n" << *Mod; +#endif + + /* + * verify module correctness * + * predicates: * + * enable_module_correctness/0 * + * enable_module_correctness/1 * + * verify_module_after/0 * + * verify_module_both/0 * + */ + if (ExpEnv.analysis_struc.pointtoverifymodule == AFTER || ExpEnv.analysis_struc.pointtoverifymodule == BOTH) { + if (verifyModule(*Mod)) { + errs() << "ERROR:: Module not built correctly!\n"; + exit(1); + } + } + /***/ + + // MaterializeAllPermanently -- Make sure all GlobalValues in this Module are fully read + if (Mod->MaterializeAllPermanently(&errStr)) { + errs() <<"Error:: bitcode didn't read correctly. -- " << errStr << "\n"; + exit(1); + } + + /* Creating EngineBuilder -- called 'builder' */ + Function *EntryFn; + EngineBuilder builder(Mod); + builder.setErrorStr(&errStr); + builder.setJITMemoryManager(JITMemoryManager::CreateDefaultMemManager()); + builder.setEngineKind(EngineKind::JIT); + // codegen predicate 'engine_opt_level/1' + switch(ExpEnv.codegen_struc.struc_enginebuilder.engineoptlevel) { + case 0: + builder.setOptLevel(CodeGenOpt::None); + break; + case 1: + builder.setOptLevel(CodeGenOpt::Less); + break; + case 2: + builder.setOptLevel(CodeGenOpt::Default); + break; + case 3: + builder.setOptLevel(CodeGenOpt::Aggressive); + break; + } + // codegen predicate 'relocmodel/1' + switch(ExpEnv.codegen_struc.struc_enginebuilder.relocmodel) { + case 0: + builder.setRelocationModel(Reloc::Default); + break; + case 1: + builder.setRelocationModel(Reloc::Static); + break; + case 2: + builder.setRelocationModel(Reloc::PIC_); + break; + case 3: + builder.setRelocationModel(Reloc::DynamicNoPIC); + break; + } + // codegen predicate 'codemodel/1' + switch(ExpEnv.codegen_struc.struc_enginebuilder.codemodel) { + case 0: + builder.setCodeModel(CodeModel::Default); + break; + case 1: + builder.setCodeModel(CodeModel::JITDefault); + break; + case 2: + builder.setCodeModel(CodeModel::Small); + break; + case 3: + builder.setCodeModel(CodeModel::Kernel); + break; + case 4: + builder.setCodeModel(CodeModel::Medium); + break; + case 5: + builder.setCodeModel(CodeModel::Large); + break; + } + // codegen predicates 'enable_mcjit/0' or 'disable_mcjit/0' + builder.setUseMCJIT((bool)ExpEnv.codegen_struc.struc_enginebuilder.usemcjit); + llvm::TargetOptions Options; + { + /* codegen predicates 'enable_framepointer_elimination/0' or 'disable_framepointer_elimination/0' */ + Options.NoFramePointerElim = (bool)ExpEnv.codegen_struc.struc_targetopt.noframepointerelim; + Options.NoFramePointerElimNonLeaf = (bool)ExpEnv.codegen_struc.struc_targetopt.noframepointerelim; + /***/ + // codegen predicates 'less_precise_fp_mad_option/0' or 'more_precise_fp_mad_option/0' + Options.LessPreciseFPMADOption = (bool)ExpEnv.codegen_struc.struc_targetopt.lessprecisefpmadoption; + // codegen predicates 'no_excess_fp_precision/0' or 'excess_fp_precision/0' + Options.NoExcessFPPrecision = (bool)ExpEnv.codegen_struc.struc_targetopt.noexcessfpprecision; + // codegen predicates 'unsafe_fp_math/0' or 'safe_fp_math/0' + Options.UnsafeFPMath = (bool)ExpEnv.codegen_struc.struc_targetopt.unsafefpmath; + // codegen predicates 'rounding_mode_dynamically_changed/0' or 'rounding_mode_not_changed/0' + Options.HonorSignDependentRoundingFPMathOption = + (bool)ExpEnv.codegen_struc.struc_targetopt.honorsigndependentroundingfpmathoption; + // codegen predicates 'no_use_soft_float/0' or 'use_soft_float/0' + Options.UseSoftFloat = (bool)ExpEnv.codegen_struc.struc_targetopt.usesoftfloat; + // codegen predicates 'enable_jit_exception_handling/0' or 'disable_jit_exception_handling/0' + Options.JITExceptionHandling = (bool)ExpEnv.codegen_struc.struc_targetopt.jitexceptionhandling; + // codegen predicates 'enable_jit_emit_debug_info/0' or 'disable_jit_emit_debug_info/0' + Options.JITEmitDebugInfo = (bool)ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfo; + // codegen predicates 'enable_jit_emit_debug_info_to_disk/0' or 'disable_jit_emit_debug_info_to_disk/0' + Options.JITEmitDebugInfoToDisk = (bool)ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfotodisk; + // codegen predicates 'guaranteed_tail_call_opt/0' or 'no_guaranteed_tail_call_opt/0' + Options.GuaranteedTailCallOpt = (bool)ExpEnv.codegen_struc.struc_targetopt.guaranteedtailcallopt; + // codegen predicates 'enable_tail_calls/0' or 'disable_tail_calls/0' + Options.DisableTailCalls = (bool)ExpEnv.codegen_struc.struc_targetopt.disabletailcalls; + // codegen predicates 'enable_fast_isel/0' or 'disable_fast_isel/0' + Options.EnableFastISel = (bool)ExpEnv.codegen_struc.struc_targetopt.fastisel; + } + // codegen predicates 'fp_abitype/1' or 'default_fp_abitype/0' + switch(ExpEnv.codegen_struc.struc_targetopt.floatabitype) { + case 0: + Options.FloatABIType = FloatABI::Default; + break; + case 1: + Options.FloatABIType = FloatABI::Soft; + break; + case 2: + Options.FloatABIType = FloatABI::Hard; + break; + } + builder.setTargetOptions(Options); + /***/ + + /* Creating ExecutionEngine from EngineBuilder (builder) */ + ExecutionEngine *EE = builder.create(); + if (!EE) { + if (!errStr.empty()) + errs() << "Error creating Execution Engine: " << errStr << "\n"; + else + errs() << "Unknown error creating Execution Engine!\n"; + exit(1); + } + /***/ + + // 'clause' is our function -- getting it from Module + EntryFn = Mod->getFunction("clause"); + if (!EntryFn) { + /* + * Theoretically, every Module is correct, but * + * for some reason, llvm can not compile some of them * + */ + close(Output); + remove(outputfilename); + free(p->u.jhc.jh->tcc.cmd); + free(outputfilename); + return NULL; + } + + /* Here, we know that Module was be successfully compiled, so... */ + // 1. execute all of the static constructors or destructors for program + EE->runStaticConstructorsDestructors(false); + global++; + + close(Output); + remove(outputfilename); + free(p->u.jhc.jh->tcc.cmd); + free(outputfilename); + // 2. get native pointer from 'clause' (our function within Module) and return it + return EE->getPointerToFunction(EntryFn); +} + +void* JIT_Compiler::compile(yamop* p) { + /* LLVMContext must be declared here, otherwise LLVM will crash on x86_64 machines */ + LLVMContext *Context = new LLVMContext(); + return compile_all(Context, p); +} diff --git a/JIT/configure.in b/JIT/configure.in new file mode 100644 index 000000000..f63d45e6a --- /dev/null +++ b/JIT/configure.in @@ -0,0 +1,111 @@ +dnl +dnl JIT CONFIGURATION +dnl + +AC_SUBST(JITFLAGS) +AC_SUBST(JITLD) +AC_SUBST(JITLIBS) +AC_SUBST(JITDEBUGPREDS) +AC_SUBST(JITSTATISTICPREDS) +AC_SUBST(JITCOMPILER) +AC_SUBST(JITCONFIGPREDS) +AC_SUBST(JITANALYSISPREDS) +AC_SUBST(JITTRANSFORMPREDS) +AC_SUBST(JITCODEGENPREDS) +AC_SUBST(PAPILIB) + +AC_ARG_ENABLE(jit, + [ --enable-jit support just-in-time (JIT) compilation], + yap_jit="$enableval", yap_jit=no) + +AC_ARG_ENABLE(debug-predicates, + [ --enable-debug-predicates support debug predicates ], + dbg_preds="$enableval", dbg_preds=no) + +AC_ARG_ENABLE(statistic-predicates, + [ --enable-statistic-predicates support statistic predicates ], + stat_preds="$enableval", stat_preds=no) + +if test "$yap_jit" = "yes" +then + + AC_CHECK_PROG(LLVM, llvm-config, [yes],[no]) + + if test "$LLVM" = "no" ;then + AC_MSG_ERROR([--enable-jit was given, but test for LLVM 3.1 failed]) + + else + LLVM_VERSION="`llvm-config --version`" + if test "$LLVM_VERSION" != "3.1";then + AC_MSG_ERROR([Test for LLVM 3.1 failed]) + fi + + fi + + AC_CHECK_PROG(CLANG, clang, [yes],[no]) + + if test "$CLANG" = "no" ;then + AC_MSG_ERROR([--enable-jit was given, but test for clang faild]) + fi + + YAP_EXTRAS="$YAP_EXTRAS -DYAP_JIT=1" + JITCOMPILER="JIT_Compiler.o" + JITCONFIGPREDS="jit_configpreds.o" + JITANALYSISPREDS="jit_analysispreds.o" + JITTRANSFORMPREDS="jit_transformpreds.o" + JITCODEGENPREDS="jit_codegenpreds.o" + JITFLAGS="`llvm-config --cxxflags`" + JITLD="`llvm-config --ldflags`" + JITLIBS="`llvm-config --libs all`" + +fi + +if test "$dbg_preds" = "yes" + then + + if test "$yap_jit" = "no" + then + + AC_MSG_ERROR([--enable-debug-predicates was given, but --enable-jit was not given]) + + fi + + YAP_EXTRAS="$YAP_EXTRAS -DYAP_DBG_PREDS=1" + JITDEBUGPREDS="jit_debugpreds.o" +fi + +if test "$stat_preds" = "yes" + then + + if test "$yap_jit" = "no" + then + + AC_MSG_ERROR([--enable-statistic-predicates was given, but --enable-jit was not given]) + + fi + + AC_CHECK_HEADER([papi.h], + [], + [if test "$stat_preds" != "no"; then + AC_MSG_ERROR( + [--enable-statistic-predicates was given, but papi.h not found]) + fi + ]) + + AC_CHECK_LIB([papi], [PAPI_start], + [if test "$stat_preds" != "no"; then + PAPILIB="-lpapi" + fi + ], + [if test "$stat_preds" != "no"; then + AC_MSG_ERROR( + [--enable-statistic-predicates was given, but test for papi failed]) + fi + ]) + + YAP_EXTRAS="$YAP_EXTRAS -DYAP_STAT_PREDS=1" + JITSTATISTICPREDS="jit_statisticpreds.o" + PAPILIB="-lpapi" + +fi + diff --git a/JIT/examples/append.pl b/JIT/examples/append.pl new file mode 100644 index 000000000..a1dc75383 --- /dev/null +++ b/JIT/examples/append.pl @@ -0,0 +1,27 @@ +:- initialization(main). + +:- use_module(library(random)). + +generate(L, N) :- + generate(L, [], N). + +generate(L, L, 0) :- !. +generate(L, X, N) :- + A is N - 1, + random(0, 1000000, B), + generate(L, [B|X], A). + +append_([],L,L). +append_([X|L1],L2,[X|L3]) :- + append_(L1,L2,L3). + +main :- + unix( argv([H|_]) ), number_atom(N,H), + + generate(List, N), + + append_(List, [], _), + + statistics, + statistics_jit, + halt. diff --git a/JIT/examples/binary_trees.pl b/JIT/examples/binary_trees.pl new file mode 100644 index 000000000..db591dcf6 --- /dev/null +++ b/JIT/examples/binary_trees.pl @@ -0,0 +1,89 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% +% Contributed by Anthony Borla +% Modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- initialization(main). + +main :- + unix( argv([H|_]) ), number_atom(N,H), + + MIN_DEPTH is 4, set_limits(N, MIN_DEPTH, MAX_DEPTH, STRETCH_DEPTH), + + bottom_up_tree(0, STRETCH_DEPTH, ST), + + check_tree(ST, ITS), + format('stretch tree of depth ~w\t check: ~w~n', [STRETCH_DEPTH, ITS]), + + bottom_up_tree(0, MAX_DEPTH, LLT), + + descend_trees(MIN_DEPTH, MIN_DEPTH, MAX_DEPTH), + + check_tree(LLT, ITL), + format('long lived tree of depth ~w\t check: ~w~n', [MAX_DEPTH, ITL]), + + statistics, + statistics_jit. + +% ------------------------------- % + +set_limits(N, MinDepth, MaxDepth, StretchDepth) :- + MinDepth1 is MinDepth + 2, + (MinDepth1 > N -> MaxDepth is MinDepth1 ; MaxDepth is N), + StretchDepth is MaxDepth + 1. + +% ------------------------------- % + +descend_trees(CurrentDepth, MinDepth, MaxDepth) :- +( + CurrentDepth =< MaxDepth -> + N is integer(2 ** (MaxDepth - CurrentDepth + MinDepth)), Iterations is 2 * N, + sum_trees(N, CurrentDepth, 0, Sum), + format('~w\t trees of depth ~w\t check: ~w~n', [Iterations, CurrentDepth, Sum]), + NewDepth is CurrentDepth + 2, !, descend_trees(NewDepth, MinDepth, MaxDepth) +; + true +). + +% ------------- % + +sum_trees(0, _, AccSum, AccSum) :- !. + +sum_trees(N, CurrentDepth, AccSum, Sum) :- + bottom_up_tree(N, CurrentDepth, TreeLeft), + Nneg is -1 * N, bottom_up_tree(Nneg, CurrentDepth, TreeRight), + check_tree(TreeLeft, ItemLeft), check_tree(TreeRight, ItemRight), + AccSum1 is AccSum + ItemLeft + ItemRight, + N1 is N - 1, !, sum_trees(N1, CurrentDepth, AccSum1, Sum). + +% ------------------------------- % + +make_tree(Item, Left, Right, tree(Item, Left, Right)). + +% ------------- % + +bottom_up_tree(Item, 0, tree(Item, nil, nil)) :- !. + +bottom_up_tree(Item, Depth, Tree) :- + ItemLeft is 2 * Item - 1, DepthLeft is Depth - 1, + bottom_up_tree(ItemLeft, DepthLeft, TreeLeft), + ItemRight is 2 * Item, DepthRight is Depth - 1, + bottom_up_tree(ItemRight, DepthRight, TreeRight), + make_tree(Item, TreeLeft, TreeRight, Tree). + +% ------------- % + +check_tree(tree(Item, nil, _), Item) :- !. +check_tree(tree(Item, _, nil), Item) :- !. + +check_tree(tree(Item, Left, Right), ItemNew) :- + check_tree(Left, ItemLeft), + check_tree(Right, ItemRight), + ItemNew is Item + ItemLeft - ItemRight. + +% ------------------------------- % diff --git a/JIT/examples/fannkuch.pl b/JIT/examples/fannkuch.pl new file mode 100644 index 000000000..2f3f6e160 --- /dev/null +++ b/JIT/examples/fannkuch.pl @@ -0,0 +1,108 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ + +% Contributed by Anthony Borla +% Modified by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- use_module(library(lists)). + +:- initialization(main). + +main :- + unix( argv([H|_]) ), number_atom(N,H), + + f_permutations(N, MaxFlips), + format('Pfannkuchen(~d) = ~d~n', [N, MaxFlips]), + + statistics, + statistics_jit. + +% ------------------------------- % + +f_permutations(N, MaxFlips) :- + numlist(1, N, L), + f_permutations_(L, N, 0, 0, MaxFlips, 0, _). + +% ------------- % + +f_permutations_(L, N, I, MaxFlips0, MaxFlips, PermN0, PermN) :- +(I < N -> + ( + N =:= 1 -> + !, processPerm(L, MaxFlips0, MaxFlips, PermN0, PermN) + ; + N1 is N - 1, + f_permutations_(L, N1, 0, MaxFlips0, MaxFlips1, PermN0, PermN1), + split_list(L, N, Lt, Ld), + rotateLeft(Lt, LtRL), append(LtRL, Ld, La), Ii is I + 1, + !, f_permutations_(La, N, Ii, MaxFlips1, MaxFlips, PermN1, PermN) + ) +; + !, MaxFlips = MaxFlips0, PermN = PermN0 +). + +% ------------------------------- % + +flips(L, Flips) :- flips_(L, 0, Flips). + +flips_([1|_], Fla, Fla) :- !. + +flips_([N|T], Fla, Flips) :- + take_drop([N|T], N, Lt, Ld), append(Lt, Ld, La), + Fla1 is Fla + 1, !, flips_(La, Fla1, Flips). + +% ------------------------------- % + +rotateLeft([H|T], RL) :- append(T, [H], RL). +rotateLeft([], []). + +% ------------------------------- % + +numlist(N, M, [N|Ls]) :- N < M, !, N1 is N + 1, numlist(N1, M, Ls). +numlist(M, M, [M]). + +% ------------------------------- % + +printPerm([L|Ls]) :- write(L), printPerm(Ls). +printPerm([]) :- nl. + +% ------------------------------- % + +processPerm(L, MaxFlips0, MaxFlips, PermN0, PermN) :- + flips(L, Flips), + ( + Flips > MaxFlips0 -> + MaxFlips = Flips + ; + MaxFlips = MaxFlips0 + ), + ( + PermN0 < 30 -> + printPerm(L), + PermN is PermN0 + 1 + ; + PermN = PermN0 + ). + +% ------------------------------- % + +split_list([L|Ls], N, [L|Hs], Ts) :- + N > 0, !, N1 is N - 1, + split_list(Ls, N1, Hs, Ts). + +split_list(Ls, 0, [], Ls) :- !. + +% ------------------------------- % + +take_drop(L, N, Taken, Rest) :- take_drop_(L, N, 0, [], Taken, Rest). + +take_drop_(L, N, N, Ta, Ta, L) :- !. + +take_drop_([H|T], N, Nc, Ta, Taken, Rest) :- + Nc1 is Nc + 1, !, take_drop_(T, N, Nc1, [H|Ta], Taken, Rest). + +% ------------------------------- % diff --git a/JIT/examples/fasta.pl b/JIT/examples/fasta.pl new file mode 100644 index 000000000..faf781e3b --- /dev/null +++ b/JIT/examples/fasta.pl @@ -0,0 +1,130 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% Contributed by Anthony Borla +% Modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- initialization(main). + +main :- + unix( argv([H|_]) ), number_atom(N,H), + + init_fasta(ALU, IUB, HOMOSAPIENS, RAND0), + + N1 is N * 2, + N2 is N * 3, + N3 is N * 5, + + repeat_fasta('ONE', 'Homo sapiens alu', N1, ALU), + + make_cumulative(IUB, CVIUB), + + random_fasta('TWO', 'IUB ambiguity codes', N2, CVIUB, RAND0, RAND1), + + make_cumulative(HOMOSAPIENS, CVHOMOSAPIENS), + + random_fasta('THREE', 'Homo sapiens frequency', N3, CVHOMOSAPIENS, RAND1, RAND), + + statistics, + statistics_jit. + +% ------------------------------- % + +init_fasta(ALU, IUB, HOMOSAP, RAND) :- + ALU = 'GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA', + IUB = [a:0.27, c:0.12, g:0.12, t:0.27, + 'B':0.02, 'D':0.02, 'H':0.02, 'K':0.02, 'M':0.02, + 'N':0.02, 'R':0.02, 'S':0.02, 'V':0.02, 'W':0.02, 'Y':0.02], + HOMOSAP = [a:0.3029549426680, c:0.1979883004921, + g:0.1975473066391, t:0.3015094502008], + init_gen_random(42, RAND). + +% ------------------------------- % + +repeat_fasta(Id, Desc, N, ALU) :- + LineLength = 60, + atom_length(ALU, ALULength), + write('>'), write(Id), tab(1), write(Desc), nl, + repeat_fasta_(N, 0, LineLength, ALU, ALULength). + +% ------------- % + +repeat_fasta_(N, _, _, _, _) :- N =< 0, !. + +repeat_fasta_(N, Q, L, ALU, ALULength) :- + (N < L -> L1 = N ; L1 = L), + (L1 + Q < ALULength -> + sub_atom(ALU, Q, L1, Lineout), Q1 is L1 + Q, + write(Lineout), nl + ; + Rest is ALULength - Q, sub_atom(ALU, Q, Rest, Prefix), + atom_length(Prefix, PrefixLength), Q1 is L1 - PrefixLength, + sub_atom(ALU, 0, Q1, Segment), + write(Prefix), write(Segment), nl), + + N1 is N - L1, !, repeat_fasta_(N1, Q1, L1, ALU, ALULength). + +% ------------------------------- % + +random_fasta(Id, Desc, N, CumTbl, RAND0, RAND) :- + LineLength = 60, + write('>'), write(Id), tab(1), write(Desc), nl, + random_fasta_(N, LineLength, CumTbl, RAND0, RAND). + +% ------------- % + +random_fasta_(N, _, _, RAND, RAND) :- N =< 0, !. + +random_fasta_(N, L, CumTbl, RAND0, RAND) :- + (N < L -> L1 = N ; L1 = L), + gen_line(L1, CumTbl, Codesout, RAND0, RAND1), + atom_chars(Lineout, Codesout), write(Lineout), nl, + N1 is N - L1, !, random_fasta_(N1, L1, CumTbl, RAND1, RAND). + +% ------------- % + +gen_line(0, _, [], RAND, RAND). +gen_line(N, CumTbl, K, RAND0, RAND) :- + select_random(CumTbl, C, RAND0, RAND1), + char_code(C, C1), K = [C1|T1], N1 is N - 1, !, + gen_line(N1, CumTbl, T1, RAND1, RAND). + +% ------------------------------- % + +make_cumulative(L, RL) :- make_cumulative_(L, RL, 0). + +make_cumulative_([], [], _) :- !. +make_cumulative_([K:V|T], L, CV) :- + CV1 is CV + V, L = [K:CV1|T1], !, make_cumulative_(T, T1, CV1). + +% ------------- % + +select_random(L, RK, RAND0, RAND) :- + gen_random(1.0, R, RAND0, RAND), + select_random_(L, R, RK). + +select_random_([], _, _) :- !. +select_random_([K:V|T], R, RK) :- + (R < V -> RK = K ; !, select_random_(T, R, RK)). + +% ------------------------------- % + +init_gen_random(Seed, [3877, 29573, 139968, Seed]). + +% ------------- % + +gen_random(UB, R, RAND0, RAND) :- + RAND0 = [IA, IC, IM, LAST], + LAST1 is (LAST * IA + IC) mod IM, + RAND = [IA, IC, IM, LAST1], + R is UB * LAST1 / IM. + +% ------------------------------- % +% BUG FIX - sub_atom/5 errors out if Size = 0. + +sub_atom(_,_,0,'') :- !. +sub_atom(A,Bef,Size,Aout) :- sub_atom(A,Bef,Size,_,Aout). + diff --git a/JIT/examples/hanoi.pl b/JIT/examples/hanoi.pl new file mode 100644 index 000000000..60b1e2270 --- /dev/null +++ b/JIT/examples/hanoi.pl @@ -0,0 +1,16 @@ +:- initialization(main). + +han(N,_,_,_) :- N =< 0. + +han(N,A,B,C) :- N > 0, + N1 is N-1, + han(N1,A,C,B), + han(N1,C,B,A). + +main :- + unix( argv([H|_]) ), + number_atom(N,H), + han(N,4,5,6), + + statistics, + statistics_jit. diff --git a/JIT/examples/k_nucleotide.pl b/JIT/examples/k_nucleotide.pl new file mode 100644 index 000000000..d744e7f9c --- /dev/null +++ b/JIT/examples/k_nucleotide.pl @@ -0,0 +1,172 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% +% contributed by Anthony Borla +% modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- use_module(library(readutil)). +:- use_module(library(lists)). +:- use_module(library(assoc)). + +:- initialization(main). + +main :- + current_input(Cin), + load_sequence(Cin, Seq), + + FragmentLengths = [1, 2], + forall(member(E, FragmentLengths), (print_frequencies(Seq, E), nl)), + + Fragments = ["GGT", "GGTA", "GGTATT", "GGTATTTTAATT", "GGTATTTTAATTTATAGT"], + forall(member(E, Fragments), print_count(Seq, E)), + + statistics, + statistics_jit. + +% ------------------------------- % + +print_frequencies(Seq, KeyLen) :- + generate_counts(Seq, KeyLen, CountTable), + sum_counts_(CountTable, 0, SumCounts), + make_freq_table_(CountTable, SumCounts, [], FTable), + keysort(FTable, SFTable), reverse(SFTable, FreqTable), + print_freq_table_(FreqTable). + +% ------------- % + +sum_counts_([_-C|T], Acc, Sum) :- Acc1 is Acc + C, !, sum_counts_(T, Acc1, Sum). +sum_counts_([], Acc, Acc). + +% ------------- % + +make_freq_table_([K-C|T], SumCounts, FTA, FreqTable) :- + F is C / SumCounts * 100.0, append([F-K], FTA, FTA1), + !, make_freq_table_(T, SumCounts, FTA1, FreqTable). +make_freq_table_([], _, FTA, FTA). + +% ------------- % + +print_freq_table_([F-K|T]) :- + format('~w ~3f\n', [K, F]), + !, print_freq_table_(T). +print_freq_table_([]). + +% ------------------------------- % + +print_count(Seq, Fragment) :- + length(Fragment, FragLen), + generate_counts(Seq, FragLen, CountTable), + atom_codes(FragKey, Fragment), + ( + select(FragKey-Count, CountTable, _) + ; + Count = 0 + ), !, + format('~d\t~s\n', [Count, Fragment]). + +% ------------- % + +generate_counts(Seq, Length, CountTable) :- + length(Seq, SeqLen), Last is SeqLen - Length + 1, + make_count_table(Length, Last, Seq, CountTable). + +% ------------------------------- % + +make_count_table(Length, Last, Seq, CountTable) :- + empty_assoc(A), + mct_i_loop_(0, Length, Last, Seq, A, ACT), + assoc_to_list(ACT, CountTable). + +% ------------- % + +mct_i_loop_(I, Length, Last, Seq, CTA, CountTable) :- + I < Length, !, + mct_j_loop_(Last, Length, Seq, CTA, CTA1), + I1 is I + 1, !, + Seq = [_|Ss], Last1 is Last - 1, + mct_i_loop_(I1, Length, Last1, Ss, CTA1, CountTable). +mct_i_loop_(Length, Length, _, _, CTA, CTA). + + +% ------------- % + +mct_j_loop_(Last, Length, Seq, CTA, CountTable) :- + Last > 0, !, + sub_list_(Seq, Length, KeyString, Rest), atom_codes(Key, KeyString), + ( + get_assoc(Key, CTA, Value) -> + V1 is Value + 1, put_assoc(Key, CTA, V1, CTA1) + ; + put_assoc(Key, CTA, 1, CTA1) + ), + !, Last1 is Last - Length, + mct_j_loop_(Last1, Length, Rest, CTA1, CountTable). +mct_j_loop_(Last, _, _, CTA, CTA) :- Last =< 0, !. + +% ------------------------------- % + +load_sequence(S, Seq) :- load_sequence_(S, fail, "", Seq). + +% ------------- % + +load_sequence_(S, Loading, Seq, RetSeq) :- + catch(read_line_to_codes(S, L), _, fail), is_list(L), !, + ( + Loading -> + process_sequence(L, S, Seq, RetSeq) + ; + ignore_sequence(L, S, Seq, RetSeq) + ). +load_sequence_(S, _, Seq, Seq). + +% ------------- % + +ignore_sequence([62,84,72,82,69,69|_], S, Seq, RetSeq) :- !, + load_sequence_(S, true, Seq, RetSeq). +ignore_sequence(_, S, Seq, RetSeq) :- !, + load_sequence_(S, fail, Seq, RetSeq). + +process_sequence([62|_], _, Seq, Seq) :- !. +process_sequence([59|_], S, Seq, RetSeq) :- !, + load_sequence_(S, true, Seq, RetSeq). + +process_sequence(L, S, Seq, RetSeq) :- + to_upper(L, UL), + append(Seq, UL, NewSeq), + !, load_sequence_(S, true, NewSeq, RetSeq). + +% ------------------------------- % + +to_upper(L, U) :- to_upper_(L, [], U). + +% ------------- % + +to_upper_([], UA, U) :- reverse(UA, U), !. + +to_upper_([C|T], UA, U) :- + is_lower(C), C1 is C - 32, + !, to_upper_(T, [C1|UA], U). + +to_upper_([C|T], UA, U) :- + !, to_upper_(T, [C|UA], U). + +% ------------- % + +is_lower(C) :- C >= 97, C =< 122. + +% ------------------------------- % + +forall(Gen, Proc) :- findall(_,(Gen, Proc), _). + +% ------------- % + +sub_list_([S|Seq], L, [S|Ks], Rs) :- L > 0, !, + L1 is L - 1, + sub_list_(Seq, L1, Ks, Rs). +sub_list_(Rs, 0, [], Rs). + +% ------------------------------- % diff --git a/JIT/examples/mandelbrot.pl b/JIT/examples/mandelbrot.pl new file mode 100644 index 000000000..34ec53031 --- /dev/null +++ b/JIT/examples/mandelbrot.pl @@ -0,0 +1,107 @@ +0% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ + +% Modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- initialization(main). + +main :- + unix( argv([H|_]) ), number_atom(Height,H), Width = Height, + + format('P4~N~d ~d~N',[Height, Width]), + pointsY(Height, Width, 0, 0, 0, 0, 0), + + statistics, + statistics_jit. + +% ------------------------------- % + +pointsY(Height, Width, Y, X, + OUTFLAG0, + BYTEOUT0, + BITN0) :- + Y1 is Y + 1, Height >= Y1, !, + pointsX(Height, Width, Y, 0, + OUTFLAG0, OUTFLAG, + BYTEOUT0, BYTEOUT, + BITN0, BITN), + pointsY(Height, Width, Y1, X, + OUTFLAG, + BYTEOUT, + BITN). + +pointsY(_, _, _, _, _, _, _) :- !. + +% ------------- % + +pointsX(Height, Width, Y, X, + OUTFLAG0, OUTFLAG, + BYTEOUT0, BYTEOUT, + BITN0, BITN) :- + + X1 is X + 1, Width >= X1, !, + + (mandel(Height, Width, Y, X, 50) -> LimitAdj = 0 ; LimitAdj = 1), + + BITN1 is BITN0 + 1, + (BITN1 == 8 -> OUTFLAG1 = 1 ; OUTFLAG1 = OUTFLAG0), + + BYTEOUT1 is BYTEOUT0 * 2 + LimitAdj, + ( + (Width == X1, BITN1 \== 8) -> + (BYTEOUT2 is BYTEOUT1 * integer(2 ** (8 - Width mod 8)), OUTFLAG2 = 1) + ; + (BYTEOUT2 = BYTEOUT1, OUTFLAG2 = OUTFLAG1) + ), + + output(OUTFLAG2, OUTFLAG3, BYTEOUT2, BYTEOUT3, BITN1, BITN2), + + pointsX(Height, Width, Y, X1, + OUTFLAG3, OUTFLAG, + BYTEOUT3, BYTEOUT, + BITN2, BITN). + +pointsX(_, _, _, _, OUTFLAG, OUTFLAG, BYTEOUT, BYTEOUT, BITN, BITN) :- !. + +% ------------- % + +mandel(Height, Width, Y, X, Repetitions) :- + Cr is (2.0 * X / Width - 1.5), Ci is (2.0 * Y / Height - 1.0), + mandel_(Cr, Ci, 0.0, 0.0, Repetitions, 0). + +mandel_(_, _, Zr, Zi, Repetitions, Repetitions) :- !, + Limit is Zr * Zr + Zi * Zi, Limit > 4.0. + +mandel_(Cr, Ci, Zr, Zi, Repetitions, N) :- + Zr1 is Zr * Zr - Zi * Zi + Cr, + Zi1 is 2.0 * Zr * Zi + Ci, + Limit is Zr1 * Zr1 + Zi1 * Zi1, + Limit =< 4.0, N1 is N + 1, !, + mandel_(Cr, Ci, Zr1, Zi1, Repetitions, N1). + +mandel_(_, _, _, _, _, _) :- !. + +% ------------- % + +output(OUTFLAG0, OUTFLAG, BYTEOUT0, BYTEOUT, BITN0, BITN) :- +( + OUTFLAG0 =:= 1 -> + ( + put_byte(BYTEOUT0), + BITN = 0, + BYTEOUT = 0, + OUTFLAG = 0 + ) +; + ( + BYTEOUT = BYTEOUT0, + BITN = BITN0, + OUTFLAG = OUTFLAG0 + ) +). + +% ------------------------------- % diff --git a/JIT/examples/n-body.pl b/JIT/examples/n-body.pl new file mode 100644 index 000000000..d10ce4cdd --- /dev/null +++ b/JIT/examples/n-body.pl @@ -0,0 +1,145 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% Contributed by Anthony Borla +% Modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- initialization(main). + +main :- + unix( argv([H|_]) ), number_atom(N,H), + + make_bodies(Bodies0), + + energy(Bodies0, EnergyStart), + + loop_advance(N, 0.01, Bodies0, Bodies), + + energy(Bodies, EnergyAfter), + + format('~9f~N~9f~N', [EnergyStart, EnergyAfter]), + + statistics, + statistics_jit. + +% ------------------------------- % + +energy(Bodies, Energy) :- energy_(Bodies, 0.0, Energy). + +energy_([ _:B | Bs], Energy0, Energy) :- + !, B = [_X, _Y, _Z, VX, VY, VZ, Mass], + Energy1 is Energy0 + 0.5 * Mass * (VX * VX + VY * VY + VZ * VZ), + energy_diff_(B, Bs, Energy1, Energy2), + energy_(Bs, Energy2, Energy). + +energy_([], Energy, Energy). + +energy_diff_(Planet, [_:B | Bs], Energy0, Energy) :- + Planet = [X, Y, Z, _VX, _VY, _VZ, Mass], + B = [XT, YT, ZT, _VXT, _VYT, _VZT, MassT], + DX is X - XT, DY is Y - YT, DZ is Z - ZT, + DISTANCE is sqrt(DX * DX + DY * DY + DZ * DZ), + Energy1 is Energy0 - (Mass * MassT) / DISTANCE, + energy_diff_(Planet, Bs, Energy1, Energy). + +energy_diff_(_, [], Energy, Energy). + +% ------------------------------- % + +loop_advance(N, Dt, Bodies0, Bodies) :- + N > 0, !, + advance(Dt, Bodies0, Bodies1), + N1 is N - 1, + loop_advance(N1, Dt, Bodies1, Bodies). + +loop_advance(_, _, Bodies, Bodies). + +advance(Dt, Bodies0, Bodies) :- + Bodies0 = [B0 | B0s], !, + advance_(Dt, B0, B1, B0s, B1s), + advance(Dt, B1s, Bs), + B1 = E:[X, Y, Z, VX, VY, VZ, Mass], + X1 is X + Dt * VX, + Y1 is Y + Dt * VY, + Z1 is Z + Dt * VZ, + B = E:[X1, Y1, Z1, VX, VY, VZ, Mass], + Bodies = [ B | Bs]. + +advance(_, Bodies, Bodies). + +advance_(Dt, Planet0, Planet, Bodies0, Bodies) :- + Bodies0 = [B0 | B0s], !, + Planet0 = E:[X, Y, Z, VX, VY, VZ, Mass], + B0 = ET:[XT, YT, ZT, VXT, VYT, VZT, MassT], + + DX is X - XT, DY is Y - YT, DZ is Z - ZT, + DISTANCE is sqrt(DX * DX + DY * DY + DZ * DZ), + Mag is Dt / (DISTANCE * DISTANCE * DISTANCE), + + VX1 is VX - DX * MassT * Mag, + VY1 is VY - DY * MassT * Mag, + VZ1 is VZ - DZ * MassT * Mag, + VXT1 is VXT + DX * Mass * Mag, + VYT1 is VYT + DY * Mass * Mag, + VZT1 is VZT + DZ * Mass * Mag, + + Planet3 = E:[X, Y, Z, VX1, VY1, VZ1, Mass], + advance_(Dt, Planet3, Planet, B0s, Bs), + + B = ET:[XT, YT, ZT, VXT1, VYT1, VZT1, MassT], + Bodies = [B | Bs]. + +advance_(_, P, P, Bs, Bs). + +% ------------------------------- % + +make_bodies(Bodies) :- + SOLAR_MASS = 3.9478417604357432000e+01, + Bodies0 = + [ + jupiter:[4.84143144246472090e+00, -1.16032004402742839e+00, + -1.03622044471123109e-01, 6.06326392995832020e-01, + 2.811986844916260200e+00, -2.5218361659887636e-02, + 3.7693674870389486e-02], + saturn:[8.34336671824457987e+00, 4.12479856412430479e+00, + -4.03523417114321381e-01, -1.010774346178792400e+00, + 1.825662371230411900e+00, 8.415761376584154e-03, + 1.1286326131968767e-02], + uranus:[1.28943695621391310e+01, -1.51111514016986312e+01, + -2.23307578892655734e-01, 1.082791006441535600e+00, + 8.68713018169607890e-01, -1.0832637401363636e-02, + 1.723724057059711e-03], + neptune:[1.53796971148509165e+01, -2.59193146099879641e+01, + 1.79258772950371181e-01, 9.79090732243897980e-01, + 5.94698998647676060e-01, -3.4755955504078104e-02, + 2.033686869924631e-03] + ], + + Sun0 = sun:[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, SOLAR_MASS], + offset_momentum(Sun0, Sun, Bodies0, SOLAR_MASS), + Bodies = [Sun | Bodies0]. + +% ------------- % + +offset_momentum(Sun0, Sun, Bodies, SOLAR_MASS) :- + offset_momentum_(Bodies, [0.0, 0.0, 0.0], [PX, PY, PZ]), + Sun0 = E:[X, Y, Z, VX, VY, VZ, Mass], + VX1 is -(PX / SOLAR_MASS), + VY1 is -(PY / SOLAR_MASS), + VZ1 is -(PZ / SOLAR_MASS), + Sun = E:[X, Y, Z, VX1, VY1, VZ1, Mass]. + +offset_momentum_([_:E|Bs], Pt0, Pt) :- + E = [_X, _Y, _Z, VX, VY, VZ, Mass], + Pt0 = [PX, PY, PZ], + PX1 is PX + VX * Mass, + PY1 is PY + VY * Mass, + PZ1 is PZ + VZ * Mass, + offset_momentum_(Bs, [PX1, PY1, PZ1], Pt). + +offset_momentum_([], Pt, Pt). + +% ------------------------------- % diff --git a/JIT/examples/nreverse.pl b/JIT/examples/nreverse.pl new file mode 100644 index 000000000..929b18f95 --- /dev/null +++ b/JIT/examples/nreverse.pl @@ -0,0 +1,4014 @@ +:- initialization(main). + +nreverse([],[]). +nreverse([X|L0],L):- nreverse(L0,L1), + append(L1,[X],L). + +append([],L,L). +append([X|L1],L2,[X|L3]) :- append(L1,L2,L3). + +main :- + nreverse([7206, 52507, 55812, 1651, 16855, 44416, 47278, 6387, 45094, 31922, 42807, 3517, 12998, 4462, 30656 +, 13774, 23125, 35652, 37936, 46296, 44761, 14066, 5827, 11107, 49348, 41311, 21160, 3920, 19014, 29566 +, 10888, 2572, 58425, 6700, 4224, 51632, 27468, 27854, 58019, 48914, 59776, 17178, 28784, 49127, 21640 +, 59440, 2901, 44766, 11444, 17189, 31062, 32557, 31255, 36890, 43664, 56956, 18201, 41176, 876, 13567 +, 47094, 11764, 16139, 21871, 54816, 56715, 13503, 58636, 24570, 11522, 23903, 24346, 28701, 52687, 13473 +, 26693, 28479, 52726, 11459, 16275, 9915, 18874, 48833, 41171, 55764, 32497, 38127, 50317, 50026, 39003 +, 40236, 37120, 27120, 32727, 58992, 58288, 29443, 12495, 56925, 54013, 370, 57180, 54711, 5423, 49867 +, 44537, 32116, 54698, 37263, 43576, 10973, 47179, 38802, 36158, 4702, 10918, 8656, 42829, 37587, 35034 +, 58184, 17823, 12154, 1656, 50550, 11146, 59945, 19993, 59994, 33222, 50358, 364, 30402, 45070, 5787 +, 56621, 29607, 14255, 27671, 6870, 34183, 38644, 30401, 12985, 51155, 35103, 23903, 36163, 54284, 1490 +, 11197, 28821, 55665, 23351, 30477, 46216, 10850, 6774, 42561, 10844, 39996, 32920, 11208, 46750, 17990 +, 53347, 43371, 23949, 7602, 11042, 7171, 18138, 26039, 37573, 31123, 53546, 12676, 31379, 29709, 43313 +, 9221, 40906, 12134, 4887, 4257, 18963, 27455, 15107, 25738, 10016, 25951, 42086, 19288, 13511, 28837 +, 13630, 43210, 48560, 37579, 27165, 35955, 44751, 45303, 38346, 58676, 16426, 31892, 47704, 24157, 1601 +, 31017, 33379, 42507, 19503, 38266, 23116, 38467, 5721, 14576, 40557, 52089, 16879, 22643, 11378, 6743 +, 27832, 1360, 49953, 16393, 15292, 17118, 52348, 36395, 2421, 30694, 35071, 55200, 38938, 22775, 19357 +, 40539, 30145, 52736, 59398, 26000, 7354, 58866, 40819, 49427, 13442, 21376, 41517, 30322, 20372, 29247 +, 37065, 48204, 30607, 3370, 4597, 22251, 20489, 33297, 58646, 59262, 40343, 33717, 30814, 19281, 32845 +, 26524, 36172, 39342, 55612, 35570, 5342, 2967, 10789, 22514, 52394, 24231, 20242, 10263, 30905, 40614 +, 39510, 44322, 5171, 46470, 47693, 46120, 8721, 44534, 19418, 7368, 20148, 36113, 17437, 27315, 55395 +, 26634, 53839, 7919, 5976, 49451, 19842, 47671, 28770, 30631, 46537, 21165, 54862, 6779, 31428, 2120 +, 47394, 47291, 46442, 28917, 33761, 10487, 15037, 18834, 31373, 10807, 2554, 27874, 46921, 56344, 55189 +, 18668, 22978, 49028, 26587, 5307, 14831, 46429, 29330, 43602, 53412, 15867, 41119, 48275, 22646, 12547 +, 26747, 46392, 36190, 13189, 51661, 46303, 29, 6699, 5138, 31402, 17506, 44044, 59276, 40779, 40388 +, 30817, 35799, 39719, 19845, 38739, 21378, 11029, 1520, 50708, 30983, 54933, 42927, 12102, 43208, 41925 +, 1001, 9955, 4670, 37192, 59496, 56331, 23495, 59525, 3030, 4985, 7280, 56889, 49030, 42908, 14020 +, 5770, 13726, 49820, 21841, 9923, 28559, 43219, 20952, 30079, 10279, 28287, 25012, 29558, 40389, 44572 +, 11484, 41391, 30879, 52506, 54935, 6728, 48837, 54782, 42605, 28220, 59768, 49885, 1461, 25150, 32794 +, 15481, 30920, 22872, 41653, 29114, 32795, 46564, 12333, 30100, 16644, 58965, 58387, 18008, 28523, 38777 +, 38933, 16359, 56520, 46164, 8865, 27807, 52892, 57703, 22589, 35498, 2275, 22357, 1735, 3736, 23859 +, 10881, 55569, 31132, 33753, 37223, 246, 42901, 23787, 48931, 13001, 16783, 47896, 11388, 11144, 16420 +, 26517, 50077, 32779, 59389, 36241, 41645, 27196, 5486, 15700, 49786, 40984, 17975, 48495, 19071, 58063 +, 48707, 29953, 53632, 19839, 40058, 30855, 20085, 22959, 30995, 9016, 35960, 47778, 33265, 47349, 58922 +, 49685, 50218, 25351, 58816, 49608, 37945, 16813, 53156, 43431, 8865, 19294, 767, 3192, 7790, 19838 +, 1255, 32849, 26143, 54888, 52688, 6202, 2095, 49125, 29161, 9442, 58141, 5122, 33573, 7758, 28823 +, 32495, 57443, 55393, 34199, 32612, 45001, 12144, 25777, 38158, 31927, 34643, 57452, 32694, 37835, 41594 +, 28884, 15443, 14443, 55028, 46683, 43483, 1230, 25130, 32608, 6743, 34573, 7102, 48217, 8146, 14860 +, 53392, 16993, 48656, 48786, 51192, 57620, 10139, 39688, 23397, 48297, 47967, 34392, 22102, 20661, 12228 +, 40048, 49546, 4023, 30844, 20926, 50706, 50679, 22156, 15836, 23288, 28899, 26761, 6742, 53469, 34907 +, 21602, 46861, 28253, 46610, 35647, 55797, 44230, 45787, 35486, 43980, 10436, 23453, 18372, 8890, 20467 +, 6952, 25291, 46365, 10975, 56135, 7291, 38033, 46814, 5799, 30222, 46454, 11050, 56983, 53196, 4519 +, 8243, 51151, 51381, 36496, 14113, 3380, 32293, 34696, 49167, 44131, 18676, 35956, 7585, 13400, 44846 +, 4404, 20353, 10137, 50769, 7680, 42624, 34412, 45714, 29439, 40211, 52288, 52245, 51261, 49271, 21794 +, 55781, 33866, 49297, 47162, 10362, 3410, 50542, 42656, 38106, 16062, 3139, 33134, 52018, 47076, 46535 +, 13216, 51480, 43240, 23354, 18601, 50920, 5978, 53013, 12986, 11769, 33224, 5274, 40367, 24486, 30898 +, 2161, 56619, 4764, 51458, 20133, 51479, 31220, 47027, 10487, 45679, 3089, 13626, 18813, 31459, 703 +, 41700, 44676, 52183, 1292, 44382, 10785, 52213, 50360, 40150, 41551, 38482, 13375, 23178, 18849, 14213 +, 30428, 57362, 10832, 35192, 25172, 7317, 3023, 56392, 54344, 13510, 42071, 33786, 27137, 37237, 5245 +, 27840, 18937, 26273, 56375, 20230, 10655, 43512, 48795, 37368, 23663, 6698, 15850, 13390, 6228, 11051 +, 27603, 36656, 8413, 14787, 48201, 33585, 22104, 51224, 6329, 16448, 4735, 24753, 50234, 8224, 1990 +, 31832, 36064, 57279, 58105, 8791, 53861, 8761, 52304, 19008, 46129, 52319, 25707, 38331, 5709, 8287 +, 49382, 9664, 44944, 34147, 803, 9497, 44084, 22907, 37073, 50413, 15707, 41808, 51518, 42294, 26384 +, 53508, 50478, 38800, 27140, 48583, 47592, 21001, 33696, 16248, 40010, 56177, 8567, 42069, 34508, 50628 +, 26708, 242, 36644, 11652, 34389, 37447, 57501, 54825, 36706, 34575, 21591, 28765, 52735, 13109, 47411 +, 19120, 42970, 37889, 57920, 10110, 26473, 21864, 31111, 36521, 38112, 47473, 32699, 23031, 5894, 7207 +, 50011, 32603, 7450, 3007, 44255, 18191, 16806, 18109, 49369, 29864, 52684, 10960, 58630, 45419, 421 +, 46041, 4539, 43391, 283, 38812, 53501, 26756, 37028, 24613, 39629, 51493, 48438, 12328, 50876, 54333 +, 55888, 40888, 26936, 39690, 20247, 47543, 57881, 37054, 5652, 23602, 6918, 34688, 34562, 41900, 20108 +, 11336, 27942, 999, 54727, 4577, 16163, 48229, 31333, 53192, 49194, 47314, 44685, 37632, 59643, 35561 +, 8317, 55531, 52801, 11605, 35221, 49401, 59149, 9454, 26455, 41153, 33057, 33373, 15842, 43971, 51626 +, 12302, 55307, 19568, 13301, 50035, 24145, 29465, 14616, 31830, 59009, 40162, 55496, 20046, 17794, 55139 +, 55607, 2464, 50670, 24761, 14069, 2243, 14162, 49570, 11698, 16969, 30724, 21107, 26694, 22918, 41430 +, 18320, 35220, 36738, 14240, 24873, 3125, 14737, 30690, 54093, 46567, 29699, 34255, 18416, 49745, 28401 +, 13555, 21705, 30865, 40578, 46466, 44935, 19173, 36980, 34505, 30871, 53949, 41581, 28330, 20643, 4499 +, 9761, 38964, 39719, 22851, 53204, 40945, 2328, 7942, 11635, 56421, 30861, 41335, 30676, 49277, 7432 +, 59077, 39185, 5489, 29943, 19763, 28307, 51230, 38936, 5287, 2087, 46160, 35588, 43669, 50842, 56232 +, 48168, 36955, 11548, 4240, 59806, 41104, 21537, 2134, 49046, 33172, 58555, 56260, 50859, 5583, 21889 +, 34644, 4661, 1074, 40133, 10956, 57189, 8441, 2186, 12478, 13728, 40625, 34990, 25669, 24294, 2184 +, 21901, 48815, 39140, 9801, 29407, 38946, 50905, 50944, 17433, 16304, 468, 52340, 12564, 51328, 57924 +, 34453, 25972, 38937, 11880, 42457, 26245, 45421, 50898, 4783, 57899, 40979, 45408, 9241, 6648, 9703 +, 11426, 4901, 34870, 50566, 14702, 4277, 5864, 5607, 31573, 59649, 21911, 32041, 28342, 10827, 59721 +, 26266, 21633, 2045, 41555, 9865, 44503, 7800, 55286, 11753, 12583, 29538, 52732, 57991, 15131, 35732 +, 44046, 26557, 40633, 18916, 53475, 31687, 59545, 35692, 13647, 7470, 11693, 11910, 15864, 40035, 22738 +, 15585, 42653, 20723, 53983, 560, 30588, 38486, 8360, 2226, 26591, 57295, 8116, 19324, 31639, 23248 +, 31408, 15685, 26157, 48394, 10954, 19633, 20081, 46851, 31677, 33728, 54322, 19722, 21991, 10186, 59758 +, 21081, 2123, 18763, 41804, 56106, 19324, 48744, 10944, 27684, 50970, 37536, 1332, 59087, 33212, 32971 +, 58687, 4620, 25008, 24844, 53014, 12314, 20829, 49448, 59166, 28858, 59528, 29840, 48581, 21519, 16378 +, 48339, 42600, 18501, 43454, 756, 50960, 2778, 49500, 1904, 6815, 16823, 39440, 8147, 52262, 49004 +, 17470, 50949, 53625, 42478, 15793, 22991, 54793, 12975, 12439, 30311, 41833, 48320, 36503, 30414, 9839 +, 52881, 55105, 28792, 47734, 38560, 29548, 38694, 41338, 55401, 40599, 24505, 12224, 56391, 32652, 4486 +, 45396, 50122, 31787, 15373, 8953, 23932, 38364, 40098, 36907, 27156, 46761, 18741, 15476, 23264, 25507 +, 1667, 52497, 20613, 6811, 40231, 35525, 36360, 55278, 53215, 31761, 12229, 17721, 20337, 8620, 50373 +, 1175, 30368, 16848, 32962, 45741, 2153, 56894, 458, 42251, 10154, 3966, 5364, 5247, 55794, 28628 +, 30754, 33813, 21125, 27719, 40625, 37708, 39596, 53337, 32986, 32812, 25098, 45215, 50533, 21787, 30188 +, 17258, 22962, 556, 10458, 32276, 22650, 12611, 29170, 59460, 31214, 15676, 39778, 36578, 20923, 35572 +, 41558, 51678, 9385, 39035, 55749, 26362, 16744, 35346, 19699, 26082, 8158, 21149, 47650, 35043, 42936 +, 17838, 28653, 42250, 54746, 39112, 14526, 53748, 28075, 20049, 53208, 59290, 35725, 9338, 12220, 56649 +, 44910, 53779, 24679, 30648, 9166, 20428, 57010, 2262, 32126, 16710, 28345, 16636, 37859, 15995, 51679 +, 57148, 10185, 56685, 39398, 4931, 35797, 53925, 58680, 40224, 50326, 28240, 15866, 26051, 37579, 4439 +, 59052, 58841, 58218, 23731, 29489, 43736, 20512, 2852, 45999, 28990, 19562, 14344, 45627, 33773, 6691 +, 13658, 30921, 16876, 10343, 46672, 58159, 22492, 40597, 33191, 39069, 30923, 37784, 54935, 33326, 15363 +, 59374, 32379, 50556, 33944, 32462, 56398, 17681, 29326, 59250, 40032, 58317, 55164, 54376, 20296, 28937 +, 37419, 10306, 36211, 54295, 57002, 22883, 28806, 19494, 39832, 1998, 34915, 47107, 39782, 29851, 20433 +, 31497, 5577, 29164, 22053, 15874, 37979, 18451, 9907, 43657, 54053, 49939, 18326, 49217, 20667, 38622 +, 54507, 58086, 25281, 30718, 28733, 22283, 29953, 57539, 18129, 9785, 35889, 53045, 33244, 15671, 59248 +, 30029, 47168, 41177, 59194, 45574, 57051, 13525, 40377, 6958, 57182, 34431, 56897, 15509, 23648, 17564 +, 30483, 18155, 52002, 55764, 25225, 20735, 54399, 55178, 54627, 12529, 41315, 30516, 5574, 14559, 46188 +, 41174, 44589, 9708, 22351, 20135, 55282, 19403, 33660, 35660, 2713, 7194, 46443, 59611, 59055, 10091 +, 53527, 29539, 4599, 45530, 1655, 29824, 42617, 56055, 1355, 37244, 44936, 42670, 7761, 50510, 57230 +, 53949, 8036, 18171, 40009, 30387, 38306, 35292, 26142, 48318, 47304, 28856, 55512, 33747, 28467, 54568 +, 20190, 58346, 24107, 1141, 43876, 2114, 30966, 2846, 34521, 8673, 40090, 19457, 51343, 47851, 46319 +, 24925, 41800, 54355, 43096, 21810, 1095, 21402, 33454, 27237, 9720, 57110, 56093, 41585, 7209, 912 +, 36153, 3751, 59259, 36612, 4893, 19487, 38726, 12211, 22333, 49600, 20884, 2424, 9057, 12227, 50275 +, 55377, 13505, 8428, 26084, 56601, 6590, 27179, 54356, 16396, 54417, 40428, 13506, 50510, 22013, 57067 +, 51423, 58166, 818, 27034, 11130, 5711, 46521, 26209, 17922, 45207, 15809, 38806, 47631, 24866, 27386 +, 14258, 56595, 40891, 59038, 22680, 13844, 5628, 49859, 8200, 22024, 20628, 48629, 11882, 11139, 46994 +, 8949, 38914, 21513, 46120, 42300, 32643, 51831, 5173, 58852, 46106, 50380, 14661, 1264, 14363, 15880 +, 28650, 28622, 12475, 45893, 27660, 11507, 59738, 9641, 1367, 44290, 8017, 58347, 9271, 56252, 9486 +, 56266, 41553, 24752, 17779, 27673, 43404, 50422, 55857, 48578, 25627, 41963, 38958, 16640, 43227, 53322 +, 32520, 48230, 58296, 21348, 10475, 2308, 32855, 46565, 48301, 10574, 30856, 32671, 8922, 40127, 28923 +, 54760, 12745, 10476, 19513, 30524, 14502, 39269, 57299, 10359, 27847, 59278, 52322, 43158, 15918, 11901 +, 12832, 48439, 36483, 47480, 9787, 23311, 49788, 18994, 9876, 14442, 29569, 40732, 47113, 38491, 57212 +, 16036, 33251, 9957, 2864, 29116, 16834, 17366, 8386, 50485, 27725, 36233, 49763, 56399, 55743, 5681 +, 44653, 8575, 30472, 21136, 56055, 16611, 44447, 22196, 35606, 30676, 36638, 5175, 11408, 23751, 43666 +, 44972, 16139, 16917, 54930, 19003, 46034, 48116, 12722, 54420, 38601, 16799, 7005, 28364, 13199, 39101 +, 10397, 57852, 47676, 40870, 55340, 20084, 57481, 16140, 42280, 9439, 46816, 55270, 14614, 34576, 55373 +, 58280, 55901, 11512, 51550, 27183, 6867, 37584, 15299, 55941, 8356, 53900, 12741, 51713, 58616, 25940 +, 30814, 45365, 144, 54843, 2587, 31836, 14927, 36421, 24328, 33559, 45860, 47496, 28829, 475, 22073 +, 554, 58755, 54326, 48418, 50305, 21509, 31637, 4241, 36808, 27579, 48949, 7060, 40320, 40663, 42028 +, 42612, 47829, 27393, 42756, 42672, 29981, 14592, 57599, 6402, 15273, 7510, 52262, 2769, 12691, 29089 +, 24842, 13245, 27845, 19168, 1663, 54502, 17029, 33301, 35096, 53837, 880, 24045, 37249, 17552, 41060 +, 19277, 164, 5242, 23023, 42920, 47914, 29356, 33864, 21866, 12110, 49137, 29376, 4372, 51907, 18420 +, 9814, 53101, 31665, 37659, 48622, 9681, 8513, 5651, 42982, 19961, 35841, 20214, 44007, 13090, 37766 +, 1419, 8720, 14282, 6661, 31743, 57202, 30928, 1099, 7418, 52794, 13209, 32908, 58522, 53933, 1167 +, 16942, 3747, 30620, 24960, 17758, 19242, 34641, 2624, 1246, 53975, 22585, 13439, 50541, 42944, 26529 +, 4659, 20716, 35249, 18941, 27377, 43344, 52495, 34657, 20795, 59913, 27451, 34004, 9173, 2326, 4290 +, 10340, 55620, 44389, 40961, 20580, 2148, 36555, 31573, 41124, 14153, 1900, 3709, 27592, 52441, 23006 +, 30474, 33452, 43722, 42075, 52393, 47451, 25420, 21240, 22109, 46215, 21154, 25912, 56572, 6679, 4590 +, 862, 17020, 211, 45251, 34333, 57143, 23751, 10888, 5069, 4875, 25042, 6969, 44937, 52634, 35763 +, 44295, 23108, 9215, 28017, 41536, 37961, 51820, 6956, 59201, 50281, 29523, 56707, 16194, 26095, 3387 +, 57136, 26957, 56759, 33699, 48561, 31092, 30843, 48664, 41980, 12264, 29892, 43374, 55585, 14829, 36009 +, 31348, 59124, 35469, 16916, 3493, 17005, 31229, 31665, 313, 30430, 21947, 29837, 3490, 38141, 55932 +, 6877, 35277, 59242, 39988, 8977, 24155, 11080, 16172, 12819, 53060, 4788, 42711, 12787, 373, 33892 +, 48796, 8074, 9368, 617, 1342, 49213, 53975, 32571, 20879, 54288, 39353, 42826, 477, 42843, 57319 +, 32762, 26072, 8948, 8356, 6060, 54277, 32511, 53492, 46801, 21682, 22905, 51589, 40746, 35692, 28315 +, 50990, 840, 36389, 359, 1457, 37731, 25924, 31784, 46654, 46803, 2425, 26007, 29629, 2902, 45203 +, 3300, 12016, 11275, 12249, 20372, 53688, 6526, 29235, 47180, 29680, 50918, 10085, 21269, 8016, 22129 +, 49584, 59006, 22969, 2325, 35717, 779, 16408, 1642, 32563, 3062, 48445, 34988, 5422, 54427, 14243 +, 50625, 57727, 26259, 1900, 46328, 22984, 31940, 29207, 52219, 55473, 58887, 19489, 5558, 20156, 3857 +, 4040, 46093, 2864, 27009, 24770, 38581, 27788, 41179, 16575, 352, 44241, 5021, 11692, 49663, 35800 +, 25935, 40288, 33527, 28547, 18541, 56208, 27883, 26833, 25415, 56454, 22306, 24302, 52296, 4217, 20810 +, 56153, 8257, 43255, 35369, 35266, 8026, 50303, 3055, 49205, 6878, 39759, 9798, 11899, 51451, 35814 +, 47699, 53739, 52454, 57579, 22286, 10995, 53787, 26521, 14181, 55554, 22975, 36487, 19856, 15271, 40704 +, 17018, 11425, 48961, 274, 23146, 24228, 8300, 13449, 3635, 57505, 20328, 43394, 43655, 32227, 34845 +, 19469, 56279, 28584, 11924, 30210, 27222, 59271, 23997, 30095, 13452, 19551, 53071, 49940, 15759, 8342 +, 30644, 32777, 56119, 55958, 33051, 19266, 20186, 17703, 32715, 173, 51560, 29395, 43567, 35216, 1623 +, 54764, 54685, 34254, 59701, 42961, 4464, 3275, 42233, 28461, 33371, 55685, 24364, 26442, 21977, 40123 +, 11136, 28974, 49252, 43608, 24932, 58656, 39226, 21470, 16359, 11941, 21643, 7920, 41337, 41562, 43136 +, 19312, 36326, 14173, 29918, 36027, 57135, 34382, 39303, 39368, 39195, 49026, 11405, 39911, 51820, 9735 +, 20034, 2956, 38709, 45638, 22916, 3641, 44294, 2142, 1463, 654, 50436, 23106, 8574, 31773, 4668 +, 28062, 27437, 17346, 42235, 57355, 29726, 15722, 8089, 45381, 31442, 47284, 34407, 42848, 27195, 26227 +, 52583, 23581, 5535, 7644, 45571, 28452, 47637, 29866, 30594, 49100, 30520, 21030, 48558, 15446, 29155 +, 29578, 19860, 56592, 46924, 38447, 30299, 16650, 54170, 14740, 2031, 25612, 2024, 12790, 44812, 5571 +, 39017, 13747, 5504, 44553, 21391, 51076, 13005, 45380, 20942, 19951, 34480, 27814, 40982, 23038, 19612 +, 10137, 28968, 39472, 43082, 15893, 17919, 49733, 8895, 48441, 4474, 47279, 50406, 42850, 69, 35218 +, 48422, 39087, 25318, 53926, 59992, 23061, 45002, 49349, 8442, 42296, 9300, 19274, 46462, 50282, 18665 +, 6074, 36772, 47633, 21898, 19854, 3526, 39818, 45939, 48774, 4611, 50413, 36053, 55017, 33264, 36122 +, 6588, 58038, 51561, 8258, 51964, 27905, 31319, 13319, 17254, 16113, 31967, 26555, 35388, 18430, 53189 +, 30405, 24504, 29961, 18038, 46403, 26167, 57917, 2573, 12107, 46691, 43536, 38872, 59096, 38554, 48488 +, 35218, 21494, 46526, 3132, 29752, 14843, 31037, 37423, 4514, 24644, 29889, 36481, 51199, 41629, 31263 +, 20740, 12034, 55768, 50702, 30072, 18523, 53221, 27989, 57448, 41680, 51032, 40984, 20553, 50128, 55890 +, 45393, 1699, 17384, 31920, 41183, 23488, 23115, 48572, 37264, 3981, 13216, 7153, 40462, 40767, 48782 +, 48078, 1508, 37168, 20198, 28562, 7240, 38721, 58135, 11582, 36169, 39816, 38966, 53505, 36721, 29095 +, 49396, 22114, 7146, 43132, 30386, 48329, 42973, 29853, 36901, 20237, 33834, 26470, 3742, 50649, 7237 +, 28876, 38727, 45097, 6044, 58925, 13659, 49636, 13998, 48147, 37570, 26519, 27963, 16537, 20024, 41036 +, 21984, 45772, 39502, 29130, 5257, 46241, 53811, 48230, 16094, 7064, 44819, 26281, 33534, 48561, 16930 +, 17124, 53789, 32009, 2221, 59833, 7286, 52233, 25821, 57636, 40380, 3392, 24155, 44695, 19929, 20531 +, 25731, 18265, 42656, 5233, 47395, 47913, 51474, 41206, 12495, 43921, 24622, 57314, 10202, 58157, 22227 +, 3484, 15281, 16016, 35493, 53854, 52201, 19131, 46087, 54374, 16767, 26467, 57766, 17274, 11162, 54047 +, 14157, 13245, 12312, 56813, 18479, 36059, 44726, 46305, 53617, 33573, 30226, 18240, 30887, 40428, 52749 +, 29466, 43912, 8030, 21834, 55757, 38236, 50387, 51240, 24324, 44762, 44359, 27143, 18880, 1633, 14658 +, 49280, 15791, 27903, 37944, 48956, 46382, 14004, 33683, 32688, 43973, 43608, 2914, 2213, 50848, 19695 +, 54962, 20314, 39959, 39344, 18501, 35717, 17581, 8888, 3309, 18257, 30002, 47669, 45400, 25235, 25654 +, 58, 50867, 41445, 27962, 28811, 30402, 50696, 19167, 40437, 59736, 3141, 24045, 2651, 41706, 14893 +, 58698, 13021, 11560, 38657, 28717, 30061, 50726, 22650, 15301, 54036, 40907, 21656, 18057, 2660, 46891 +, 43711, 39070, 37758, 1509, 7032, 42921, 31911, 34081, 2089, 48700, 33817, 41582, 49097, 12820, 23288 +, 40343, 11518, 12661, 28255, 50176, 41379, 58316, 40902, 4029, 49969, 11290, 44937, 11625, 29347, 23949 +, 34868, 13059, 3019, 48978, 14568, 46404, 31900, 22831, 20485, 10341, 47883, 30654, 28275, 36980, 43475 +, 27915, 53675, 54993, 40577, 21930, 21521, 21956, 56598, 2424, 25985, 46568, 50066, 47274, 34545, 19414 +, 11223, 45766, 8825, 50595, 34744, 23393, 36999, 42996, 22576, 33836, 29689, 10459, 4490, 57964, 23791 +, 47965, 25880, 17467, 19311, 6457, 39397, 40832, 28413, 12348, 19608, 30750, 35268, 9675, 18025, 9813 +, 5441, 5600, 31931, 14266, 56195, 6676, 14011, 9546, 49672, 36587, 43382, 19362, 47046, 24225, 53678 +, 10837, 48542, 19558, 4656, 7853, 26015, 20406, 25038, 30780, 32754, 20998, 1531, 8022, 7025, 55908 +, 54187, 12466, 37860, 2471, 26732, 34056, 9147, 40743, 19954, 35171, 53682, 3337, 30885, 40728, 3914 +, 24564, 27918, 52456, 20474, 32574, 36662, 46490, 29332, 1700, 53622, 2086, 59050, 31505, 46460, 6076 +, 27413, 17000, 18542, 5274, 19471, 21627, 15682, 4970, 38722, 35636, 40141, 32405, 15325, 47379, 49485 +, 19239, 48295, 17403, 48048, 8769, 26330, 24710, 55259, 55662, 2762, 25234, 34101, 1812, 56739, 56913 +, 44240, 505, 50265, 2783, 5779, 9736, 762, 57813, 51058, 39484, 33449, 31200, 48241, 25127, 54931 +, 37727, 20718, 43226, 31482, 45118, 51995, 34164, 46180, 23607, 29827, 48942, 48841, 40280, 27107, 21932 +, 13545, 11347, 22437, 3811, 50482, 28216, 13547, 51244, 2381, 40958, 7081, 12183, 12158, 55322, 37310 +, 43441, 33049, 34380, 26667, 4532, 19499, 18662, 38696, 5679, 18621, 44875, 30974, 7462, 1507, 58081 +, 29395, 15053, 45780, 51832, 18864, 12615, 56401, 8763, 3859, 58782, 49721, 47292, 10965, 38231, 42615 +, 24627, 58024, 52016, 59008, 24691, 56548, 54859, 19706, 11597, 538, 38327, 32824, 31512, 22142, 10684 +, 5945, 27889, 25737, 28078, 56073, 20953, 40693, 28826, 6068, 20904, 3961, 32142, 8197, 51278, 46725 +, 27164, 15906, 44750, 19180, 51266, 45793, 52081, 46125, 41851, 3678, 23015, 56531, 12854, 30880, 18673 +, 23538, 36825, 22914, 25627, 4903, 55339, 22932, 21948, 24166, 29001, 19205, 4479, 37495, 27402, 55757 +, 24220, 54566, 48015, 45322, 50098, 15633, 31116, 42179, 38110, 12967, 22209, 1126, 9498, 35064, 32006 +, 4523, 34954, 45183, 3789, 582, 26439, 59129, 23514, 24739, 59647, 28867, 43944, 4126, 6362, 11346 +, 59883, 6935, 42264, 24251, 52257, 32363, 39884, 59725, 50894, 17995, 49045, 13104, 55473, 58543, 48168 +, 3831, 39419, 23122, 25366, 43208, 56, 51805, 42337, 59923, 16545, 41984, 28790, 489, 22462, 11505 +, 48188, 22346, 18440, 6804, 46597, 47049, 15519, 2833, 23127, 6414, 57180, 12172, 55870, 52653, 10715 +, 44038, 32836, 50134, 43512, 58203, 9695, 19921, 26360, 52032, 19844, 19257, 10369, 24986, 56099, 32831 +, 36491, 44287, 31529, 31283, 27443, 54478, 18333, 42963, 57312, 17812, 25729, 30844, 29984, 21599, 59850 +, 40699, 41989, 32686, 7186, 1853, 7241, 16881, 21774, 33602, 45265, 17970, 29211, 31986, 42957, 25310 +, 4818, 19448, 45949, 36347, 50732, 13393, 7178, 45417, 32708, 40842, 39581, 34789, 11686, 9565, 56388 +, 11536, 50264, 14729, 20575, 33802, 52934, 27816, 27035, 14709, 37770, 48653, 32679, 6982, 20639, 51988 +, 8644, 25457, 11437, 54594, 38157, 38521, 44339, 21687, 290, 17047, 2529, 39871, 51836, 14215, 49436 +, 24576, 2104, 16052, 15657, 22679, 26207, 8591, 26847, 53242, 59652, 4618, 41895, 8684, 47952, 2535 +, 672, 56596, 4344, 48461, 27542, 18853, 26982, 11881, 40540, 3624, 5280, 43069, 19847, 33468, 33637 +, 9283, 34396, 35741, 1688, 50053, 58420, 27895, 34997, 25267, 57489, 34649, 6237, 15737, 43333, 30541 +, 18272, 44006, 3490, 58968, 32467, 31032, 54174, 35802, 19266, 34714, 39426, 24546, 54136, 59274, 58015 +, 27773, 44909, 32411, 39866, 22949, 58817, 38286, 50844, 33814, 39905, 24686, 8463, 46143, 40423, 28149 +, 53036, 35047, 12155, 56526, 34015, 20974, 27559, 28189, 33128, 46825, 39256, 48907, 47723, 33392, 24533 +, 45738, 37517, 9442, 54502, 17383, 8744, 53319, 32021, 59588, 27133, 11926, 626, 35596, 34421, 41049 +, 3745, 27458, 16096, 52252, 23984, 50112, 49579, 27895, 54653, 22707, 51072, 33909, 11614, 38796, 43653 +, 12499, 24534, 57522, 21942, 19036, 14905, 7038, 12355, 23278, 6626, 15840, 35205, 43605, 51437, 45978 +, 24654, 31534, 49788, 40751, 139, 13773, 7215, 49718, 18020, 38220, 48777, 9093, 12130, 36744, 47889 +, 32135, 49243, 48775, 29658, 47537, 44164, 20915, 54575, 32871, 44194, 37554, 48712, 55751, 21159, 40149 +, 41729, 45813, 48035, 31518, 2916, 48174, 21643, 10131, 14244, 16015, 48352, 3022, 25108, 36834, 39766 +, 49349, 45321, 29009, 14477, 14979, 16547, 58641, 12247, 11122, 31512, 56441, 25028, 56576, 28544, 46187 +, 36725, 10273, 32001, 1113, 18143, 34917, 49287, 16138, 21401, 3532, 32154, 46105, 42906, 33614, 59291 +, 22672, 59316, 44612, 28033, 13793, 35944, 44580, 12434, 48191, 32055, 20298, 20984, 57083, 16875, 49528 +, 43271, 29952, 36153, 51624, 7417, 30649, 2893, 33057, 46787, 24294, 12941, 55293, 46751, 55847, 28908 +, 46042, 18519, 28224, 30655, 46552, 42017, 6599, 7485, 30803, 31142, 15892, 27453, 28478, 12975, 20680 +, 18006, 32598, 26985, 30511, 574, 34402, 1160, 3468, 7459, 47948, 4114, 20400, 43241, 50866, 16247 +, 48501, 36908, 11118, 16725, 43915, 34023, 35094, 26866, 17860, 42249, 34360, 33752, 46055, 2838, 23079 +, 6735, 57196, 32030, 33720, 27708, 32604, 44475, 28868, 36072, 51934, 16816, 16539, 48687, 36410, 43757 +, 4934, 1263, 57017, 52405, 17989, 40933, 2780, 29435, 44151, 20640, 48037, 18512, 30744, 34092, 21350 +, 30175, 17179, 18547, 2205, 27252, 22607, 34810, 11727, 51475, 47234, 3661, 44644, 3773, 52348, 57406 +, 23882, 33635, 58669, 20900, 2392, 53010, 38185, 5172, 58798, 22336, 2164, 46835, 40848, 9260, 57279 +, 38551, 39435, 50810, 33450, 41641, 18062, 56057, 52803, 29789, 23884, 40037, 9803, 8528, 20163, 2151 +, 5934, 44045, 12138, 40956, 41297, 50882, 33966, 19482, 56054, 32764, 41819, 34570, 19599, 59019, 20182 +, 53230, 13922, 59618, 44041, 47372, 17611, 2103, 19781, 10414, 8245, 43666, 26803, 18048, 28546, 46966 +, 56551, 10833, 7364, 45042, 51789, 48661, 35924, 25755, 8144, 8331, 58520, 26315, 19253, 54471, 25334 +, 39436, 24054, 15609, 39054, 8095, 2981, 33017, 46550, 59115, 43431, 54795, 19133, 46586, 49195, 47679 +, 9905, 45747, 58512, 17269, 7141, 50301, 42282, 43065, 52409, 26778, 51396, 27281, 29445, 10650, 58104 +, 31132, 50086, 22158, 46741, 5492, 6605, 26074, 14861, 29508, 25189, 34644, 655, 44322, 21230, 49851 +, 32002, 31135, 11950, 6866, 24756, 19091, 33520, 43391, 38508, 2281, 46521, 29905, 29562, 15967, 16907 +, 27666, 47099, 43345, 26177, 10192, 25189, 9134, 36266, 40050, 38642, 1456, 51046, 39298, 22130, 12276 +, 5501, 30484, 19764, 53803, 13703, 44520, 49246, 47223, 4263, 27754, 49504, 50785, 34011, 55418, 6752 +, 50918, 59436, 30203, 10615, 25613, 40395, 35804, 34748, 16661, 52206, 49742, 54469, 43252, 5392, 52952 +, 31881, 47245, 23436, 51645, 41048, 37139, 12517, 30294, 714, 53133, 34401, 50218, 43918, 8412, 21988 +, 27022, 35683, 21425, 33577, 46298, 47038, 13972, 58455, 58138, 6985, 27013, 24233, 37807, 10266, 29625 +, 30759, 18499, 53223, 30547, 10144, 34271, 7687, 59013, 40918, 44753, 52146, 15319, 34972, 12416, 83 +, 56960, 39438, 35766, 18385, 13015, 58417, 41776, 3339, 56872, 16266, 46677, 23885, 40499, 836, 10503 +, 46477, 31595, 29002, 39700, 38494, 15498, 50323, 22533, 50864, 7593, 7287, 43010, 22912, 18611, 31779 +, 59348, 51923, 11217, 11466, 46661, 585, 9883, 28437, 40276, 43107, 21055, 26953, 43345, 37907, 27789 +, 53848, 24384, 35736, 59203, 40436, 50583, 51053, 7111, 13116, 41917, 14705, 20403, 1280, 13969, 15366 +, 33059, 13317, 7290, 20628, 24784, 53951, 57565, 34667, 58740, 37842, 17775, 56147, 41147, 37472, 34054 +, 45289, 31320, 34790, 57377, 6875, 15226, 47960, 57929, 22338, 1077, 39846, 13395, 57832, 17478, 27364 +, 49551, 50537, 40682, 56841, 47518, 5466, 27144, 45083, 16485, 2236, 22925, 10612, 58383, 40425, 48084 +, 32438, 25714, 55757, 7228, 23091, 2632, 58807, 11052, 561, 57497, 48481, 16760, 10892, 22665, 34238 +, 38256, 12216, 1128, 18938, 45409, 24998, 756, 12553, 10081, 53594, 14789, 9359, 4206, 13173, 49784 +, 28643, 21963, 15498, 24400, 5543, 14941, 27032, 4350, 25993, 3946, 38199, 50826, 57058, 49091, 13492 +, 31296, 3700, 2060, 8776, 58990, 47470, 33774, 36099, 23, 20208, 29693, 51165, 5919, 33899, 40690 +, 55703, 38894, 2653, 47553, 3294, 8196, 2494, 6679, 48899, 4840, 10625, 27098, 55666, 7683, 52542 +, 45510, 15331, 56242, 47571, 460, 31584, 35041, 10586, 7683, 11416, 7146, 37376, 2581, 13065, 47628 +, 43271, 45120, 26522, 45924, 32673, 6169, 30473, 11520, 12848, 19372, 16360, 59825, 22822, 48378, 43860 +, 15364, 33889, 59191, 47958, 21460, 36003, 19543, 32853, 46590, 3578, 44269, 53736, 40955, 23203, 43154 +, 28583, 6474, 28274, 31457, 28751, 948, 37626, 35576, 48820, 50474, 31300, 5180, 26651, 54122, 29910 +, 10511, 45839, 3799, 9703, 10149, 1611, 22058, 6044, 10816, 8648, 9623, 31438, 38737, 26930, 54641 +, 21891, 31865, 37467, 50165, 3322, 42570, 27465, 17301, 18146, 16285, 7775, 25798, 57817, 34427, 56273 +, 27728, 44938, 42112, 7879, 30993, 28613, 45843, 53052, 34658, 56659, 38052, 20633, 28097, 16789, 47563 +, 59090, 15032, 19428, 36558, 41550, 59102, 55480, 9015, 16403, 49979, 1653, 531, 15777, 59470, 11310 +, 12050, 3550, 32600, 30514, 11430, 3594, 35480, 57273, 32998, 46490, 30284, 47402, 7123, 58382, 4192 +, 31038, 33824, 55576, 50466, 10382, 37126, 25920, 42215, 22494, 42324, 32194, 24147, 42855, 24323, 59969 +, 54165, 36374, 39872, 3117, 43240, 27654, 6711, 18720, 1279, 16061, 41562, 31563, 3464, 48685, 6297 +, 44008, 19723, 40122, 15936, 46541, 26856, 53063, 12462, 9071, 51909, 31138, 17617, 16056, 50345, 41941 +, 52377, 20862, 54667, 32249, 23979, 14259, 36255, 7043, 9332, 37534, 23104, 50894, 9098, 2920, 39580 +, 51747, 46928, 35655, 31869, 39217, 58549, 35078, 32280, 47363, 20501, 24189, 18501, 38119, 16597, 8846 +, 56412, 45326, 29708, 51079, 53928, 30039, 5338, 30183, 37082, 51022, 7718, 187, 41917, 16816, 39459 +, 57849, 44915, 2740, 33504, 16785, 41957, 8405, 28215, 50589, 55768, 48716, 14778, 50621, 3187, 7727 +, 59467, 59599, 53053, 5527, 27030, 46981, 11919, 8721, 17165, 49001, 59743, 1235, 25540, 41660, 54403 +, 5000, 39509, 39318, 7740, 49366, 32455, 26049, 57771, 670, 16638, 29892, 25739, 7768, 20513, 28926 +, 15495, 19981, 28526, 44900, 1860, 31908, 8234, 13779, 40629, 1751, 39133, 40373, 2986, 4673, 22033 +, 57389, 46025, 37895, 36707, 53765, 3613, 9163, 19814, 1384, 46185, 36452, 31276, 11924, 44220, 51790 +, 40851, 36067, 48123, 45729, 20968, 26335, 17637, 5554, 16467, 34619, 7305, 55600, 14992, 10291, 36625 +, 13377, 44032, 22651, 51272, 20739, 52768, 54885, 6254, 12583, 32622, 52440, 25387, 40250, 40716, 45960 +, 8392, 57919, 58379, 32867, 20000, 19347, 35555, 13990, 1253, 52022, 48609, 8558, 23974, 3601, 55201 +, 36951, 16978, 39233, 59602, 44603, 59973, 28723, 15840, 42579, 41306, 24814, 35019, 43045, 5065, 52088 +, 5357, 49809, 50007, 3737, 22677, 10008, 59436, 58232, 23998, 690, 26606, 12607, 45600, 26932, 16208 +, 40802, 3883, 9538, 20035, 39838, 30493, 20008, 8561, 46334, 38940, 26219, 11148, 13959, 45616, 52565 +, 42399, 27326, 42375, 32407, 31063, 5052, 42415, 6851, 39636, 42765, 43893, 42594, 55372, 29494, 9526 +, 47932, 10296, 49761, 33822, 30331, 5951, 4316, 26692, 50864, 50650, 5632, 53435, 38150, 55943, 39052 +, 30716, 38343, 6378, 13091, 47102, 13793, 54495, 5869, 20644, 34131, 48634, 4538, 53077, 20358, 10384 +, 38955, 8290, 20680, 5068, 18464, 51011, 11020, 22780, 54055, 38236, 49782, 36039, 31672, 27933, 31983 +, 47076, 58649, 46678, 29806, 11740, 33780, 19951, 6235, 39649, 16947, 16718, 28283, 21485, 9795, 24993 +, 31869, 48750, 33283, 28901, 53818, 51747, 56265, 41190, 50880, 50320, 55779, 40662, 26360, 27451, 44947 +, 34695, 50879, 43596, 57725, 20685, 31688, 31505, 40636, 14275, 47506, 57583, 7345, 52141, 55421, 17140 +, 17134, 3642, 42242, 26769, 8896, 12413, 54868, 5161, 29955, 45748, 31833, 25734, 2763, 34545, 53185 +, 47710, 45592, 44064, 7659, 43317, 41101, 39347, 14822, 58089, 53623, 38680, 32025, 968, 30821, 3798 +, 54461, 24307, 43792, 13055, 51076, 52688, 25468, 45945, 57849, 55424, 31693, 6035, 21158, 10808, 40580 +, 50696, 58519, 26173, 11112, 6178, 9490, 28566, 21877, 665, 26655, 51852, 15697, 35032, 29173, 46519 +, 38830, 23634, 10826, 22623, 13041, 1903, 51663, 38510, 24200, 25865, 10286, 32245, 31900, 7796, 43054 +, 48832, 58492, 17925, 15005, 45957, 455, 848, 14523, 22332, 37865, 17530, 14185, 53562, 28915, 19710 +, 16433, 7745, 43344, 27260, 6720, 56385, 5515, 34736, 11247, 6067, 601, 21533, 38312, 32501, 5682 +, 21366, 21333, 40526, 15643, 12691, 26483, 16098, 49891, 17358, 14783, 27756, 11241, 5320, 57670, 40156 +, 25030, 14104, 24253, 44726, 17716, 30974, 17463, 59583, 42062, 28711, 5650, 42663, 26596, 43962, 51516 +, 32278, 41681, 49201, 12805, 57324, 1892, 15640, 49775, 28135, 32999, 4558, 55891, 44240, 9878, 53562 +, 748, 11260, 44018, 25001, 55986, 1734, 32327, 13449, 1317, 14389, 42160, 6967, 57052, 45109, 27281 +, 48568, 53739, 45314, 37770, 42896, 18991, 16014, 58537, 8766, 44150, 7888, 49676, 16393, 52128, 35906 +, 46307, 29228, 47166, 30325, 54229, 43152, 32059, 26557, 56601, 9728, 40946, 15114, 53047, 14351, 36575 +, 20329, 2919, 30314, 5643, 17041, 13211, 24634, 9408, 11748, 9752, 53558, 19636, 59428, 9951, 48116 +, 35334, 56259, 17344, 58852, 2936, 11573, 42004, 11348, 14482, 14958, 21076, 55429, 6424, 14124, 46132 +, 42999, 10805, 49051, 13313, 52800, 42445, 26524, 53787, 51853, 14624, 3539, 21763, 34260, 39320, 31714 +, 58728, 14654, 4325, 52424, 49859, 7262, 40350, 31863, 18610, 54832, 23173, 16038, 26613, 29597, 30162 +, 12745, 12596, 17319, 38149, 2262, 10120, 56946, 28786, 3907, 48799, 19763, 43798, 10562, 30375, 23118 +, 18628, 29104, 14125, 59306, 57880, 3984, 42920, 38230, 12199, 37882, 9415, 35373, 53920, 12380, 41322 +, 435, 1478, 30271, 17754, 15979, 32533, 4226, 12925, 37671, 8133, 38076, 57434, 28284, 24990, 27810 +, 51402, 43618, 33266, 5527, 42924, 31146, 45863, 2196, 45729, 58063, 40078, 31496, 9788, 33999, 43876 +, 51110, 34434, 21706, 21381, 28540, 37685, 30266, 32767, 50610, 7938, 17252, 28686, 41724, 45536, 30028 +, 9534, 13291, 13647, 19152, 55170, 32923, 26651, 41034, 35120, 12380, 39097, 51550, 20228, 48885, 25549 +, 40456, 16347, 36335, 2163, 37729, 4876, 39848, 44347, 13995, 6811, 52285, 7599, 11849, 34010, 53136 +, 41878, 19896, 42779, 55525, 39049, 37949, 4800, 42052, 18983, 16272, 54432, 58080, 7823, 51012, 23317 +, 9724, 31468, 39665, 46060, 33631, 53746, 27288, 13480, 38093, 41283, 20291, 6731, 48882, 8492, 17093 +, 18370, 50370, 36989, 1149, 22247, 52390, 39099, 3400, 34442, 34434, 19672, 5226, 8867, 3847, 56238 +, 32184, 13572, 27707, 48201, 35984, 1338, 18299, 3272, 51170, 32745, 20907, 47813, 15828, 9789, 56306 +, 32921, 4512, 23028, 46262, 42013, 45276, 15005, 57464, 48676, 25799, 31899, 44700, 31026, 40766, 48548 +, 3616, 49302, 2120, 7675, 13856, 38104, 45366, 8507, 17728, 36536, 17604, 38635, 702, 33432, 24776 +, 33360, 42705, 29288, 56388, 28968, 11302, 41664, 43973, 8766, 6692, 46124, 17017, 51393, 17150, 57783 +, 39941, 57119, 23438, 18413, 4794, 13646, 32869, 50160, 22153, 50597, 3049, 39758, 5584, 40103, 49542 +, 30360, 13463, 32248, 59649, 46203, 1216, 47303, 4220, 21541, 32421, 10912, 7665, 49439, 38657, 1168 +, 23574, 18598, 34639, 23364, 13363, 39433, 37010, 46232, 5946, 59164, 13181, 45347, 15274, 18765, 1802 +, 4816, 49126, 51617, 37064, 25127, 37820, 14632, 48782, 18392, 36173, 21203, 29305, 20191, 46994, 7962 +, 57711, 46921, 2913, 32350, 10285, 16276, 48135, 23648, 38861, 30433, 59164, 28394, 15780, 14438, 47160 +, 53934, 55606, 12638, 45551, 32671, 37765, 59724, 23655, 26547, 18116, 36181, 24102, 23773, 56372, 47449 +, 8088, 30435, 34370, 11001, 2785, 21007, 3629, 50920, 44655, 18842, 57706, 43819, 47237, 13486, 58257 +, 34397, 43773, 30216, 23387, 29324, 39239, 1152, 29048, 2894, 4051, 47165, 39075, 4505, 10938, 11799 +, 51954, 55378, 42234, 2676, 6379, 21371, 23684, 46361, 48644, 8339, 41555, 46350, 28511, 28792, 36188 +, 3120, 39541, 19961, 33336, 2928, 49286, 12575, 40432, 54686, 15470, 44483, 18203, 30897, 25341, 5494 +, 19049, 17295, 872, 37635, 56324, 43604, 59007, 20008, 6317, 47651, 4699, 47872, 10353, 33210, 16665 +, 46541, 36331, 56206, 42855, 46019, 35487, 8493, 58595, 15919, 3179, 50417, 36755, 57735, 57666, 2096 +, 3229, 16715, 55743, 4101, 54351, 52067, 24057, 29710, 48427, 30374, 53713, 53127, 18247, 4066, 2689 +, 34912, 26959, 15372, 7470, 9814, 1392, 42957, 54659, 36339, 35229, 57839, 26756, 11984, 31926, 24422 +, 50432, 35155, 17490, 46175, 15608, 48193, 14595, 39666, 17903, 3022, 10040, 11616, 32501, 4639, 52034 +, 35191, 15903, 18993, 50563, 23374, 5160, 28307, 42683, 59819, 4646, 17912, 34010, 31402, 6248, 5936 +, 32177, 56680, 17443, 26019, 19208, 33052, 14212, 33803, 49070, 8467, 13177, 35462, 20083, 45679, 40102 +, 48469, 57222, 56005, 43814, 24137, 55731, 48974, 52445, 14767, 25146, 57091, 9031, 35508, 4846, 15280 +, 17797, 13375, 11960, 35240, 39394, 31168, 44644, 29958, 41323, 33714, 38425, 54501, 45529, 34860, 16532 +, 25631, 23329, 13754, 57988, 43495, 14243, 53720, 8822, 6688, 44839, 33968, 40132, 53870, 45828, 21330 +, 9150, 3625, 11057, 57463, 15218, 50451, 4983, 36214, 56761, 46307, 46281, 11538, 17160, 31810, 46398 +, 33692, 57441, 46079, 23798, 31781, 29574, 38041, 1853, 14748, 21082, 46692, 25068, 37566, 40563, 10897 +, 58896, 26065, 50874, 9953, 23528, 42444, 36756, 28512, 18659, 9869, 51171, 4940, 21407, 8331, 13102 +, 44157, 18375, 10543, 6588, 42173, 18676, 12514, 56566, 20530, 27263, 54000, 7222, 52331, 31566, 24137 +, 3228, 6814, 50203, 30455, 53119, 50083, 12899, 6227, 54947, 7910, 16096, 22470, 49202, 13855, 30801 +, 2304, 58012, 25528, 49199, 4600, 44053, 7876, 53467, 16972, 28406, 20730, 10972, 11980, 13061, 18891 +, 12470, 52642, 25705, 2673, 59449, 55177, 29108, 48700, 1404, 408, 56611, 53853, 22878, 22165, 7708 +, 30032, 822, 42073, 55560, 50021, 23025, 15966, 34249, 16492, 32938, 39007, 37222, 43910, 27340, 26636 +, 39153, 39810, 55630, 41211, 18835, 55079, 36388, 47943, 43779, 37792, 24703, 16742, 7997, 47582, 38908 +, 15706, 53966, 16082, 34131, 25878, 6103, 57156, 41844, 16705, 13649, 51134, 55712, 50871, 11397, 23052 +, 53859, 50550, 39214, 49489, 31761, 58049, 44568, 8149, 45993, 4700, 22294, 47048, 21442, 30291, 34630 +, 36702, 22349, 4948, 52784, 56480, 30827, 35240, 53637, 49023, 28297, 43638, 40158, 361, 10861, 51555 +, 59766, 4721, 42105, 38980, 54210, 50219, 37030, 15131, 58368, 59375, 19831, 57014, 46423, 17625, 3658 +, 21054, 30680, 2359, 2354, 59816, 58840, 9533, 11408, 28829, 58557, 39705, 12467, 15067, 40067, 59680 +, 6622, 39833, 4401, 25079, 18813, 34964, 51650, 32195, 26447, 26371, 31570, 22630, 23385, 17994, 16607 +, 3395, 15400, 47287, 5755, 17754, 23456, 40947, 27288, 34864, 46128, 25845, 50922, 34947, 17264, 30989 +, 34627, 238, 47174, 15381, 1669, 42339, 50345, 53320, 14535, 53144, 19691, 46105, 15774, 19428, 4099 +, 32381, 22824, 19499, 56021, 4931, 13606, 19477, 45878, 40894, 54341, 8358, 43091, 45263, 43305, 355 +, 52604, 17932, 593, 16130, 33313, 2262, 58470, 10, 55582, 49357, 53154, 51625, 11814, 8928, 11054 +, 52266, 17662, 10230, 48117, 13683, 15161, 1723, 33160, 37391, 42617, 3853, 45749, 25708, 49117, 29054 +, 2415, 18073, 23338, 3008, 34204, 33004, 5271, 9026, 33014, 37205, 34735, 26169, 28831, 46549, 11449 +, 16237, 38815, 29111, 26467, 3285, 19146, 41628, 5008, 52306, 55371, 47626, 56160, 41120, 49686, 21629 +, 46526, 28454, 16054, 9864, 31462, 50258, 42868, 13085, 35636, 52235, 50291, 10371, 54756, 55474, 33273 +, 6205, 11711, 48440, 11669, 14530, 51725, 7167, 56158, 33086, 59474, 27881, 57064, 31986, 45353, 46750 +, 29967, 31879, 51556, 46021, 18095, 23019, 12632, 37316, 36104, 48268, 29551, 2747, 34992, 24307, 34573 +, 44617, 6864, 22636, 9409, 54885, 37166, 1135, 2053, 9676, 34221, 1527, 37557, 7637, 9865, 22910 +, 30739, 39832, 54789, 22296, 2205, 49237, 45315, 14837, 26553, 57771, 39458, 56104, 36871, 14450, 56763 +, 11444, 35419, 3627, 10433, 44828, 58513, 47599, 22315, 566, 57276, 32888, 38445, 34833, 40525, 48310 +, 34096, 11265, 4494, 5237, 33561, 6699, 54474, 55228, 21537, 21027, 52999, 995, 53483, 6222, 51797 +, 50246, 54019, 27216, 53874, 4452, 12044, 52387, 52051, 10712, 29305, 25679, 43600, 7750, 513, 24126 +, 56060, 10961, 11743, 36906, 16198, 45304, 43605, 10673, 40532, 5142, 31700, 9883, 42489, 25184, 16106 +, 34286, 15430, 46477, 37854, 45656, 50929, 26251, 38043, 19332, 36963, 43700, 45012, 20563, 51450, 21877 +, 21041, 23862, 32838, 32784, 768, 49036, 54440, 44374, 59709, 34972, 25868, 7762, 21208, 8358, 9298 +, 13666, 18996, 1080, 143, 56851, 46737, 51072, 23102, 1132, 46756, 65, 44833, 31768, 56980, 36283 +, 53645, 18022, 146, 2835, 50806, 37266, 51872, 45247, 21640, 27933, 56571, 47509, 12047, 17779, 32219 +, 21345, 7797, 51215, 22426, 7940, 48066, 45515, 35364, 11168, 46647, 22121, 47585, 7832, 30241, 44566 +, 20468, 239, 2588, 56966, 3074, 29746, 34232, 31298, 51345, 55873, 59232, 24269, 19734, 11279, 18400 +, 28305, 32625, 26198, 19520, 31403, 34138, 43939, 16918, 9503, 31459, 39917, 7976, 19045, 47750, 38217 +, 3611, 44570, 38456, 42551, 41536, 41531, 48649, 15768, 12829, 39995, 47993, 48413, 40616, 44079, 59693 +, 59016, 12384, 8670, 25214, 8257, 16425, 35705, 52196, 9695, 21560, 23655, 49612, 29536, 19052, 13714 +, 44105, 59015, 58284, 22562, 41566, 39820, 40445, 6568, 31941, 29626, 22915, 19934, 54392, 3531, 40366 +, 54085, 2547, 52750, 39107, 4114, 37359, 31884, 16171, 29555, 41579, 14083, 29563, 7543, 43619, 48615 +, 57610, 4076, 47631, 55894, 2990, 5549, 12067, 19787, 12117, 44008, 49414, 35032, 40294, 43806, 38563 +, 57012, 14243, 17463, 26115, 29702, 57929, 3474, 37938, 50452, 33030, 19517, 4535, 38945, 3412, 24506 +, 27560, 1022, 28582, 51543, 33269, 7925, 33445, 45336, 27712, 45562, 5696, 17126, 56947, 22342, 37284 +, 11862, 19355, 27879, 5677, 45470, 33933, 3606, 25296, 11871, 30410, 34678, 7740, 34945, 13623, 11153 +, 59451, 17536, 48527, 28034, 45431, 21796, 35959, 18876, 43484, 40023, 4439, 25532, 57150, 37738, 47875 +, 10786, 49600, 43582, 15018, 55278, 5404, 48951, 35236, 30700, 823, 5647, 5379, 44915, 40592, 55354 +, 32420, 16396, 12890, 57300, 20782, 58322, 19096, 56741, 17198, 38933, 13116, 57989, 40817, 46618, 12079 +, 5044, 57405, 1680, 48626, 12423, 33310, 30382, 37726, 44898, 1083, 14901, 26897, 42814, 59817, 43842 +, 38168, 8589, 238, 27411, 5889, 21020, 25733, 1338, 54113, 19283, 40271, 7229, 53625, 57440, 53848 +, 5704, 2485, 27605, 43736, 27463, 16380, 53398, 57846, 54106, 38297, 35281, 45360, 5194, 54447, 45177 +, 49036, 32615, 53766, 49274, 26, 36008, 46646, 2111, 37346, 40759, 57747, 53969, 24341, 51372, 51409 +, 18189, 33428, 53894, 45794, 53517, 57710, 38526, 46915, 55556, 32632, 25212, 7189, 17992, 6759, 1636 +, 39521, 55795, 34251, 9640, 21422, 10630, 45648, 44420, 49093, 22994, 25180, 46840, 53315, 25873, 14564 +, 44724, 44062, 47993, 14971, 6208, 17862, 12681, 21086, 4777, 8237, 53718, 29990, 51778, 48063, 36749 +, 53414, 3936, 8896, 4017, 49928, 6670, 14647, 35576, 51091, 40093, 34922, 52623, 26933, 4589, 18496 +, 17850, 49314, 38910, 42195, 4285, 21470, 57, 53318, 42556, 4834, 37907, 12626, 34824, 29685, 37041 +, 47925, 23099, 40978, 33174, 27116, 30906, 39844, 18116, 42835, 30935, 58209, 54109, 23558, 1494, 58699 +, 42054, 19344, 24365, 20964, 1539, 5002, 42434, 1596, 58320, 1342, 6431, 36227, 13969, 17607, 42264 +, 51010, 41885, 5363, 31988, 15059, 8831, 39247, 54903, 26947, 58434, 2191, 25156, 52543, 25749, 26651 +, 27594, 44156, 22347, 51959, 41472, 23887, 33313, 259, 1835, 31633, 1601, 8266, 44212, 15570, 2226 +, 26476, 6581, 44111, 8191, 14921, 35522, 17023, 54168, 6777, 43970, 28954, 8968, 45479, 21498, 11070 +, 48482, 25444, 55226, 10829, 53756, 13050, 11068, 27069, 13309, 12904, 35055, 14911, 57522, 19267, 30481 +, 59748, 22096, 13414, 20211, 30287, 28336, 55733, 23662, 58856, 38863, 7633, 27811, 47831, 29464, 25661 +, 35253, 54298, 51105, 6831, 5127, 44861, 19882, 52548, 48283, 33191, 5452, 23338, 48102, 2974, 42605 +, 54936, 39075, 41053, 44702, 59286, 47693, 13038, 31372, 11355, 48247, 10235, 55340, 52410, 34418, 24804 +, 54423, 46024, 19102, 45528, 52855, 582, 6742, 12737, 29482, 31377, 45929, 34934, 54715, 10383, 14260 +, 13672, 41671, 53335, 54726, 26374, 52622, 42419, 15764, 346, 30126, 4011, 46933, 25467, 32773, 57703 +, 50271, 27196, 43727, 45726, 49077, 36583, 22660, 32171, 49320, 52142, 3548, 11601, 3428, 58263, 21985 +, 17688, 11935, 3656, 11024, 43013, 30030, 39998, 1784, 22147, 40344, 31911, 26158, 27277, 57378, 35284 +, 24980, 24001, 2480, 8708, 46079, 51557, 45291, 45091, 23728, 10963, 37233, 3628, 22565, 40661, 1891 +, 44550, 34702, 50179, 24558, 45726, 9544, 30941, 25724, 11329, 53088, 6068, 43240, 55598, 9697, 16970 +, 30882, 34677, 17323, 33363, 19737, 3403, 1272, 41380, 48494, 1353, 52344, 2080, 4981, 51261, 19093 +, 43225, 12163, 53795, 33404, 36721, 15873, 42948, 7662, 41597, 30629, 750, 24017, 50221, 56349, 33714 +, 7191, 3583, 44744, 867, 13298, 40833, 4270, 14571, 22214, 29116, 52276, 50910, 7548, 33609, 42171 +, 26642, 16834, 54334, 56789, 26590, 7407, 12663, 45891, 15070, 30612, 16520, 52172, 54630, 6742, 24873 +, 28344, 50285, 28457, 49440, 51152, 41755, 30274, 31774, 32678, 52488, 891, 24954, 19750, 44791, 58564 +, 1921, 11433, 51750, 32607, 44575, 18341, 40014, 57238, 40584, 31436, 27850, 57104, 59961, 58832, 40198 +, 24834, 27177, 6836, 29643, 52969, 57988, 47751, 23243, 6115, 20429, 52083, 7006, 21736, 11833, 51797 +, 56652, 50106, 39583, 48402, 22713, 510, 43095, 39080, 57748, 23679, 46868, 1950, 57136, 46829, 783 +, 37334, 11664, 4312, 44170, 17659, 33633, 18511, 5410, 56877, 24626, 25840, 25312, 7984, 47576, 37146 +, 36133, 20580, 3604, 52068, 8982, 26318, 52578, 28430, 41750, 26678, 28461, 28618, 4981, 25597, 15448 +, 42116, 39284, 3464, 22780, 59806, 21123, 56413, 18317, 26534, 29642, 19295, 28726, 54955, 27279, 52654 +, 32101, 3413, 13234, 12057, 31833, 58568, 38375, 24412, 3350, 56477, 51090, 31812, 1448, 56071, 57409 +, 16896, 14539, 36693, 56712, 37319, 36500, 54187, 33733, 31169, 57073, 3375, 50465, 25799, 58330, 54096 +, 54805, 6783, 57509, 44391, 18841, 5695, 42960, 33568, 30107, 22662, 6398, 57549, 54474, 7846, 29973 +, 28236, 1094, 44512, 4929, 57806, 21832, 17781, 28345, 31917, 25303, 25419, 35292, 15768, 27570, 9975 +, 9864, 22376, 53110, 43726, 43119, 48303, 49421, 2431, 21872, 55880, 25094, 4622, 29781, 19568, 12468 +, 59754, 47804, 13562, 20619, 29086, 47720, 42451, 23219, 16065, 14368, 48522, 17836, 26012, 40642, 45407 +, 35987, 26859, 44135, 5450, 10585, 27254, 53753, 36358, 29686, 51977, 8590, 54780, 56599, 38371, 50700 +, 45419, 14478, 38505, 35333, 35097, 43943, 23053, 17548, 7162, 15471, 8268, 55685, 33307, 34280, 12679 +, 55066, 46620, 39538, 39201, 28422, 26475, 6456, 22175, 39185, 12494, 14153, 47775, 7274, 47104, 2499 +, 34326, 32524, 16977, 12831, 44209, 52074, 33126, 43615, 45974, 40289, 59086, 54242, 12326, 8745, 4874 +, 25005, 3812, 27846, 4544, 43013, 56268, 31019, 25821, 18444, 46557, 38315, 8949, 34332, 21941, 32405 +, 13183, 56268, 41281, 30160, 45451, 25491, 22234, 18578, 9106, 8208, 35219, 44544, 38802, 47545, 53289 +, 20029, 12550, 57101, 47875, 53446, 16467, 20496, 818, 42288, 38940, 47375, 56956, 24241, 58059, 18897 +, 32998, 11243, 51517, 14280, 41403, 36969, 16123, 39990, 31899, 25229, 24550, 7118, 9773, 39705, 54663 +, 39414, 59734, 43565, 12868, 23961, 37012, 29335, 44457, 14182, 47975, 59749, 1557, 44931, 23990, 35968 +, 3829, 33341, 47211, 31698, 47621, 4967, 45019, 3744, 21309, 16918, 5325, 22211, 388, 51450, 1916 +, 31403, 30864, 38002, 14969, 43732, 1964, 28333, 13067, 46421, 42515, 1043, 46171, 20424, 22326, 46513 +, 32744, 2507, 19854, 56308, 34206, 43827, 1275, 19225, 23923, 58936, 12496, 29248, 57499, 12884, 20698 +, 59416, 44288, 27915, 13770, 35609, 11647, 15734, 3942, 1067, 38508, 22809, 38462, 1031, 19585, 788 +, 23896, 52329, 3296, 43751, 48637, 13854, 3930, 26264, 9431, 27854, 25200, 21927, 57102, 22700, 34812 +, 54153, 58468, 55452, 22068, 48590, 31061, 10067, 40677, 35003, 47486, 19185, 34164, 25948, 20216, 53749 +, 3089, 44112, 46078, 42737, 4215, 11068, 56591, 8146, 37332, 6022, 12352, 38885, 4302, 45806, 37937 +, 15466, 39959, 36405, 10918, 38379, 1347, 41979, 24799, 42024, 53334, 12285, 1209, 27498, 38234, 57777 +, 57599, 17675, 18242, 20029, 412, 58809, 31097, 33355, 6955, 8430, 15729, 55659, 47315, 20031, 41466 +, 25252, 35497, 57777, 38009, 22767, 12509, 39356, 41098, 37308, 21381, 34432, 49593, 58942, 38282, 4179 +, 56720, 35881, 58206, 51314, 55911, 34970, 50123, 3360, 8325, 33431, 11790, 407, 29090, 35457, 56790 +, 46908, 709, 8640, 44686, 15070, 31407, 33547, 30779, 48858, 10855, 52160, 23290, 36800, 27454, 37925 +, 40980, 24174, 13806, 15538, 51840, 46069, 50509, 41964, 49430, 58834, 15395, 37572, 35593, 44485, 13030 +, 8736, 7746, 50091, 17376, 28784, 5162, 25135, 2331, 12293, 13993, 49538, 4453, 13636, 26338, 8259 +, 51561, 43670, 32434, 41719, 59209, 626, 4141, 49718, 42590, 29923, 24904, 57985, 7495, 36850, 18823 +, 56877, 45586, 26569, 46969, 39314, 55353, 28483, 40801, 34036, 40776, 31147, 23574, 21581, 44783, 49912 +, 29840, 12696, 9935, 38626, 54415, 9144, 39253, 34908, 35214, 58195, 4831, 118, 56181, 48679, 36968 +, 51356, 45556, 58906, 54277, 8877, 38220, 49630, 13712, 19022, 18, 30840, 50169, 23592, 52421, 11304 +, 49856, 58614, 24000, 59791, 37240, 54767, 45287, 52845, 29676, 20501, 51041, 10859, 20620, 23574, 35890 +, 33940, 14930, 57799, 32847, 9207, 6676, 47419, 35189, 56741, 6441, 35207, 27581, 32962, 35151, 56355 +, 44266, 25007, 54969, 44618, 1151, 8561, 39386, 46438, 37759, 45414, 6940, 28800, 32625, 3912, 28726 +, 8516, 14204, 20008, 6315, 47051, 29215, 49343, 10823, 40756, 46084, 17264, 52315, 50018, 26579, 3818 +, 46373, 47197, 5177, 41342, 31816, 6328, 26255, 47554, 29119, 4014, 32968, 36059, 32814, 41945, 16323 +, 37892, 26813, 30527, 57900, 9480, 53931, 3467, 58824, 4754, 44223, 21260, 58370, 12890, 47630, 24949 +, 16708, 34003, 48499, 58238, 51697, 20315, 4566, 17953, 7869, 33685, 21967, 17189, 46096, 31134, 35486 +, 2419, 9026, 2300, 9299, 6927, 11780, 39582, 10394, 46956, 44336, 30970, 44569, 19058, 20212, 32199 +, 20360, 13273, 42555, 8859, 11511, 34252, 5526, 16077, 52205, 13395, 26115, 14173, 6936, 12211, 21659 +, 42422, 50983, 30685, 44722, 36634, 37612, 32855, 16216, 24359, 19811, 36904, 31681, 40732, 32314, 51893 +, 12932, 29026, 5166, 31839, 37885, 16677, 6091, 43411, 9107, 34649, 33158, 35222, 48822, 16446, 23785 +, 46833, 58869, 51120, 17518, 19943, 4106, 31483, 29150, 56674, 55842, 48962, 9930, 3875, 6046, 42245 +, 55768, 18978, 11271, 37287, 50817, 25509, 53964, 33261, 8920, 39423, 7910, 18431, 50997, 33084, 34877 +, 14783, 19917, 10098, 42255, 37435, 30042, 46362, 45270, 59192, 19388, 17464, 24506, 29319, 21339, 30553 +, 11564, 17108, 25883, 59187, 54395, 53053, 24696, 24711, 26314, 9969, 40487, 10576, 28400, 31484, 43660 +, 39629, 22619, 3577, 49728, 4875, 17364, 56122, 27589, 2635, 55314, 46977, 20099, 56173, 52648, 41439 +, 3078, 4212, 34899, 5313, 3400, 5646, 58366, 4448, 6709, 1032, 14417, 47196, 11608, 19169, 18681 +, 31620, 58799, 41300, 11549, 48527, 22527, 28914, 44649, 26468, 7901, 16315, 49798, 4352, 48840, 42446 +, 45791, 51918, 23011, 57042, 57232, 2763, 2688, 31950, 7211, 45750, 32983, 21629, 32946, 20943, 40798 +, 51627, 52564, 15949, 32928, 4113, 4476, 31807, 9379, 25477, 58276, 17280, 41793, 48074, 21633, 6985 +, 6872, 43776, 58904, 29883, 17171, 32488, 32646, 19859, 4438, 39858, 41961, 13773, 37839, 14908, 34717 +, 54989, 6535, 3633, 10939, 15815, 44098, 51767, 47623, 53478, 17245, 22251, 47110, 35390, 46677, 8743 +, 42375, 53549, 28872, 17631, 23433, 46043, 26471, 56079, 42254, 30910, 12289, 24216, 21035, 26480, 39124 +, 32104, 21470, 22011, 35737, 8761, 37827, 19836, 528, 1802, 49666, 54125, 405, 36776, 29515, 47082 +, 21872, 48243, 40631, 27096, 42226, 4064, 13139, 8698, 36496, 31745, 15960, 48785, 55961, 36995, 51618 +, 11437, 9100, 49440, 9801, 21189, 58201, 23980, 17377, 35081, 25782, 7043, 5559, 2539, 20172, 35074 +, 49621, 18396, 59669, 30252, 45492, 41896, 10669, 58631, 50594, 47165, 6728, 42906, 12302, 39042, 19901 +, 40272, 50479, 5353, 29712, 36632, 2895, 27913, 612, 20272, 39347, 2746, 3668, 44906, 5285, 192 +, 56332, 54906, 18588, 32354, 1511, 4080, 14250, 48532, 39063, 41196, 12049, 45791, 24102, 703, 24833 +, 20355, 40976, 51665, 25709, 10688, 28297, 28604, 14954, 28910, 25228, 30653, 31656, 28896, 15559, 13294 +, 29088, 48243, 44552, 24028, 20597, 46063, 28108, 11199, 34595, 7171, 52395, 22996, 29315, 52849, 23700 +, 54148, 13205, 4676, 22165, 15266, 51716, 50463, 43870, 6670, 55725, 45450, 37323, 3733, 50699, 29234 +, 17027, 56139, 17478, 1580, 20168, 38075, 23995, 48276, 49275, 34943, 31800, 18022, 57939, 1115, 10872 +, 21639, 31615, 429, 2667, 53781, 15695, 54384, 20596, 35917, 37406, 16321, 21367, 51082, 20054, 12066 +, 56668, 13434, 8206, 14146, 15014, 4726, 28574, 39009, 29354, 54201, 13952, 1154, 12223, 48244, 38621 +, 59447, 9883, 10237, 36228, 48903, 40370, 28275, 19639, 966, 4192, 57045, 17287, 1912, 24479, 13693 +, 50330, 21148, 27127, 34888, 11646, 18493, 39614, 16572, 57503, 45321, 10773, 47807, 46475, 59349, 36051 +, 1449, 35148, 22287, 11686, 11377, 11190, 28408, 39652, 30829, 29374, 20197, 4226, 23013, 58461, 5058 +, 36706, 25143, 2558, 40186, 32, 14204, 58679, 15998, 30777, 32534, 1319, 17902, 20342, 24147, 17251 +, 32745, 25596, 52400, 55032, 13634, 40129, 42574, 42042, 19781, 49755, 47768, 16330, 30334, 10781, 14791 +, 35392, 23839, 39935, 37950, 4025, 16319, 28506, 39057, 8669, 35635, 11591, 46341, 53538, 8285, 46840 +, 47141, 41031, 12436, 39541, 12415, 2422, 19670, 31342, 44464, 15804, 21097, 32232, 8486, 51431, 19365 +, 23278, 3175, 43204, 39565, 17477, 23582, 32236, 45984, 2639, 17257, 57971, 50582, 39950, 51509, 58868 +, 26790, 38651, 16251, 15578, 54544, 5018, 18000, 50567, 36360, 38816, 6371, 33810, 11048, 14857, 25241 +, 6765, 14487, 4769, 49970, 30404, 22246, 13552, 2640, 44582, 52543, 56250, 42554, 43125, 36200, 10415 +, 41993, 2991, 49066, 34596, 18569, 43611, 39615, 12922, 10530, 15975, 51738, 16901, 49785, 39139, 8110 +, 51379, 45904, 58950, 32500, 12226, 29354, 54746, 2130, 8347, 15681, 54673, 4597, 34587, 37799, 40797 +, 45002, 56144, 20140, 34069, 30741, 15062, 54032, 46708, 27984, 4562, 2683, 56074, 57815, 28821, 35213 +, 42277, 56552, 57470, 41227, 29052, 9696, 46934, 150, 11827, 55281, 15831, 6500, 36230, 50418, 20651 +, 53379, 35421, 16796, 49872, 45842, 23889, 4934, 16226, 10597, 32918, 20788, 49632, 5344, 54955, 54805 +, 40558, 37232, 27709, 38028, 18460, 56761, 47724, 41746, 33264, 35903, 37027, 25447, 42404, 49609, 15866 +, 39407, 42988, 27639, 56203, 32860, 49833, 56444, 14146, 6059, 43393, 23416, 3199, 9378, 28761, 34506 +, 4183, 9319, 11738, 8245, 23699, 6550, 5006, 47775, 48296, 38270, 23679, 1675, 40070, 42435, 51284 +, 55936, 21842, 10625, 59927, 18046, 19837, 26112, 50842, 33984, 8523, 34236, 57400, 11722, 19966, 26161 +, 22580, 501, 35480, 34318, 8746, 59179, 40869, 50105, 46955, 5517, 4727, 46986, 7193, 44797, 29421 +, 34829, 17085, 51263, 45454, 17012, 45661, 5292, 19476, 36504, 39276, 27999, 47092, 13028, 16073, 7058 +, 39190, 38653, 43911, 14670, 49324, 52658, 50202, 6545, 42763, 13509, 12062, 47490, 495, 55607, 32288 +, 29916, 30437, 25725, 57531, 52243, 42738, 43193, 33887, 38566, 19697, 49515, 6566, 43141, 2544, 58991 +, 26551, 41734, 37645, 10462, 32756, 26969, 3120, 59310, 33514, 22235, 49171, 21928, 9726, 26018, 17536 +, 18366, 32286, 24325, 44091, 29818, 52920, 3181, 13011, 26808, 41748, 9060, 52675, 24666, 52201, 31571 +, 23657, 55104, 13305, 37654, 5566, 22414, 40975, 8687, 58076, 14489, 7274, 47248, 12770, 17000, 13266 +, 30306, 11718, 45553, 30983, 32162, 15371, 255, 11695, 4734, 3415, 29795, 13794, 56091, 54461, 42347 +, 27662, 54471, 37451, 17320, 32125, 19369, 16086, 49453, 4408, 14162, 40294, 11683, 1410, 53064, 28683 +, 51029, 59722, 16754, 12934, 30705, 25268, 4657, 30961, 36963, 9391, 34376, 6759, 59537, 6819, 37572 +, 18236, 10834, 8395, 32039, 28154, 16873, 51408, 44240, 6326, 55817, 34754, 46620, 7500, 12517, 39685 +, 12535, 3546, 15759, 5641, 52832, 46465, 30909, 57489, 53778, 44225, 6880, 4506, 27336, 42769, 47678 +, 4908, 37357, 58512, 49656, 9396, 3018, 6529, 37156, 23610, 12855, 32973, 58364, 35827, 16825, 10881 +, 51864, 29361, 50779, 7624, 11354, 43611, 30441, 42264, 17452, 571, 26489, 24332, 5077, 53825, 43453 +, 29107, 35085, 20810, 27619, 24741, 6558, 30637, 7622, 43715, 30599, 20477, 16688, 28964, 32657, 9866 +, 16197, 24521, 39227, 43329, 32145, 26933, 26940, 2586, 9197, 44393, 3157, 12038, 45077, 44587, 42215 +, 4883, 13694, 53653, 2045, 17666, 54746, 8604, 24655, 2369, 52319, 55255, 59198, 45359, 24219, 31855 +, 55225, 16768, 56377, 10804, 97, 28522, 37738, 27038, 7461, 23287, 47783, 10618, 35326, 9212, 55205 +, 53893, 50447, 45252, 47546, 52493, 2918, 42293, 1097, 3925, 44662, 29768, 59180, 43860, 15127, 23399 +, 52068, 10353, 16520, 48445, 57509, 16617, 53319, 35247, 20007, 780, 34887, 44142, 11399, 46565, 53355 +, 42956, 40458, 20154, 4560, 4357, 12647, 43830, 46650, 50096, 47756, 7664, 19864, 46936, 27876, 34992 +, 46688, 19944, 21697, 3208, 8389, 19206, 19825, 1709, 30806, 39833, 38841, 5693, 23975, 50240, 28610 +, 53682, 9549, 9068, 13837, 14109, 13425, 26484, 57940, 36427, 52933, 45696, 44091, 12797, 8984, 48320 +, 47789, 55672, 8264, 45838, 58880, 53006, 41397, 18706, 31067, 48555, 34891, 9908, 30600, 35218, 36501 +, 59210, 28901, 22402, 8278, 42738, 36511, 58056, 45574, 10803, 34483, 38507, 32851, 54927, 27657, 41836 +, 19599, 51798, 13860, 27863, 37637, 12741, 57221, 55386, 7799, 28288, 43941, 42690, 14549, 14541, 17908 +, 27402, 13751, 23161, 49804, 58381, 42251, 2667, 32789, 4178, 13471, 7273, 19037, 22674, 38552, 46694 +, 40862, 58151, 38493, 54723, 2366, 52482, 7464, 59588, 47868, 51615, 4228, 31809, 10657, 55129, 46350 +, 28565, 22531, 36453, 28079, 12335, 34834, 10330, 51355, 7624, 14508, 4826, 51249, 33546, 3852, 6153 +, 56592, 44715, 40656, 35085, 15790, 43022, 27567, 23254, 18962, 51787, 51221, 59543, 23596, 1878, 54672 +, 46298, 6795, 53556, 22751, 34874, 42243, 33938, 45205, 33598, 17914, 36065, 14776, 45515, 45963, 18629 +, 28020, 42556, 39696, 8676, 53993, 55486, 28050, 57913, 55092, 23365, 49700, 46313, 22908, 49649, 48191 +, 53932, 35947, 54986, 23840, 35051, 6213, 6084, 45341, 51418, 16034, 3255, 3835, 30811, 25122, 26151 +, 25792, 53142, 45059, 41840, 38170, 39052, 37326, 6220, 13317, 8770, 5937, 3018, 55083, 28845, 29019 +, 19626, 59130, 4966, 50964, 22970, 40017, 57177, 5406, 25358, 24947, 21441, 4965, 28783, 28604, 6439 +, 31286, 54396, 35933, 16345, 36236, 14103, 31749, 49914, 56676, 45067, 58684, 2613, 24437, 30119, 7811 +, 53456, 49745, 43293, 58422, 40709, 42615, 14792, 14239, 48022, 16502, 39186, 45815, 57820, 44321, 14419 +, 4259, 15607, 8815, 16545, 31952, 21403, 30648, 3702, 11317, 3676, 25121, 10001, 42642, 49558, 40120 +, 26805, 43014, 6217, 10098, 17788, 23278, 52713, 8932, 37517, 17087, 25435, 53056, 39254, 59607, 37377 +, 53673, 40218, 52985, 38840, 56763, 1289, 36595, 3764, 41343, 47912, 43792, 6464, 34265, 26434, 56022 +, 50737, 53239, 15388, 56954, 3337, 9529, 56585, 32403, 18461, 10454, 25842, 20248, 3510, 5097, 19855 +, 40888, 35122, 36426, 10225, 50315, 33189, 11514, 26910, 13305, 29210, 14823, 57098, 35674, 49088, 59884 +, 8049, 16178, 53124, 59789, 13132, 32813, 9318, 46069, 41568, 4132, 56524, 7411, 24380, 36386, 48860 +, 20588, 17274, 334, 57014, 3851, 50649, 6555, 51718, 53912, 56213, 20928, 8735, 53311, 56602, 34175 +, 53195, 4651, 26705, 22671, 40793, 39838, 31837, 50111, 2259, 13405, 54243, 35135, 57168, 54976, 11522 +, 22380, 15564, 28796, 22715, 48930, 32648, 49716, 31837, 718, 43628, 28050, 21646, 28715, 57713, 18248 +, 39243, 27261, 59252, 5948, 26284, 40045, 22138, 58121, 6508, 750, 47879, 37104, 35885, 21399, 32080 +, 47407, 20132, 23996, 16204, 42847, 49278, 25204, 8915, 21115, 25922, 52544, 25518, 23920, 57611, 23231 +, 42168, 13206, 26844, 17772, 19155, 53129, 34169, 17645, 27602, 40678, 18395, 15481, 17782, 54281, 13233 +, 49862, 41688, 33365, 50210, 34244, 52564, 39488, 35800, 1479, 36955, 38074, 30375, 2473, 1994, 4339 +, 2057, 20515, 17545, 28901, 38287, 13052, 58382, 48809, 30698, 25985, 29487, 25445, 17818, 23621, 19726 +, 31051, 49835, 37767, 40768, 40045, 48363, 33332, 19533, 24164, 11164, 56488, 38590, 17891, 35314, 16937 +, 22230, 37371, 37452, 39776, 42624, 52091, 29180, 41007, 40900, 59878, 6992, 46739, 1676, 24810, 10360 +, 21402, 32214, 195, 35521, 12982, 16592, 23885, 22667, 12477, 24401, 33831, 45318, 2991, 28074, 20632 +, 19928, 50305, 34355, 33732, 6433, 16979, 25824, 35613, 57986, 6724, 11844, 4978, 53464, 13520, 6141 +, 40176, 11274, 38355, 40372, 46796, 27689, 33316, 47033, 26708, 45794, 11434, 539, 31112, 50777, 28614 +, 51744, 47058, 55271, 26099, 20790, 1704, 19430, 22966, 13669, 17417, 29691, 25513, 58747, 59507, 39033 +, 4888, 39683, 50308, 19595, 56407, 13456, 23637, 6076, 489, 50345, 51870, 48275, 27237, 22982, 39052 +, 32203, 51078, 2462, 27474, 53529, 23253, 5530, 12959, 46219, 19199, 30376, 52262, 21065, 29124, 28121 +, 98, 10364, 44157, 26758, 6312, 16916, 16566, 29949, 22992, 53407, 20294, 14862, 41682, 47531, 14196 +, 57087, 19734, 5274, 59549, 23560, 35155, 22802, 29090, 24467, 45374, 24642, 54843, 13988, 45707, 319 +, 42110, 22157, 47036, 26267, 25268, 53348, 19535, 41834, 23297, 42528, 35242, 19943, 57390, 16924, 43827 +, 47939, 14011, 3561, 29565, 13561, 3474, 4721, 12715, 32564, 29188, 34441, 57206, 383, 48430, 19265 +, 37055, 6892, 41423, 24091, 33159, 6691, 17439, 29046, 48525, 17088, 11574, 119, 37031, 45317, 17044 +, 20858, 33256, 7407, 772, 2821, 57320, 4246, 7542, 46388, 13162, 13082, 20829, 46721, 13466, 45611 +, 5986, 50521, 52503, 47409, 50964, 2014, 30452, 44755, 31061, 18978, 1843, 42635, 19097, 15226, 27952 +, 12493, 12437, 37560, 19901, 49561, 40382, 53573, 30159, 24276, 39961, 43321, 37359, 37143, 6394, 27177 +, 22754, 12381, 17698, 51610, 36142, 45014, 53624, 6595, 29769, 1037, 1925, 7964, 20025, 21022, 23190 +, 24329, 9868, 11979, 1890, 6121, 37892, 42272, 59694, 8051, 6548, 16008, 27725, 20259, 29503, 34119 +, 47436, 28609, 22852, 41486, 20219, 58995, 26500, 50196, 41942, 56269, 51233, 43867, 4233, 11258, 4889 +, 3776, 35588, 51109, 52107, 13830, 57230, 30000, 56102, 56925, 38051, 39002, 49285, 5776, 59262, 18788 +, 16248, 46698, 47397, 39100, 28185, 43969, 38095, 31037, 10517, 20037, 27307, 1750, 40256, 7892, 49361 +, 21498, 11668, 1301, 12607, 3776, 15131, 9838, 33776, 47585, 43115, 48179, 26587, 32400, 53956, 2201 +, 27540, 46556, 25252, 51289, 25656, 29789, 11610, 40104, 826, 22127, 36493, 4485, 230, 16750, 12378 +, 49591, 38248, 398, 27244, 50855, 4174, 18727, 693, 14302, 42664, 20160, 38834, 45603, 52560, 32790 +, 47805, 56452, 55698, 13057, 47742, 21354, 19198, 59352, 1458, 20024, 21480, 37952, 24510, 21710, 54702 +, 36888, 47653, 32950, 37286, 51249, 157, 17813, 46328, 851, 8467, 28992, 21011, 47301, 14595, 49924 +, 56443, 2400, 22728, 52141, 51809, 10470, 13496, 11007, 46175, 51306, 7384, 44007, 29258, 31894, 42069 +, 312, 45134, 6074, 9614, 58772, 57323, 9772, 52937, 43651, 46975, 1405, 12643, 44338, 25058, 3590 +, 34262, 57854, 42343, 33343, 49995, 34152, 20165, 39843, 21512, 6340, 7502, 5248, 26699, 36760, 37142 +, 8768, 13425, 58628, 14842, 23039, 57400, 48517, 32811, 26690, 8520, 19786, 28095, 57515, 4125, 29505 +, 1106, 14739, 27359, 43449, 48082, 53707, 53953, 8248, 9902, 15465, 50940, 17404, 57065, 17640, 30517 +, 34207, 2760, 43942, 9187, 53955, 6981, 6588, 18824, 16145, 33278, 27345, 35931, 37725, 24860, 16408 +, 43582, 25966, 7500, 47294, 45767, 55582, 41001, 39721, 40182, 27255, 31538, 7475, 44660, 28604, 1467 +, 15177, 39163, 40579, 35471, 48351, 34534, 18804, 31291, 29711, 34949, 40921, 57056, 47233, 54998, 58268 +, 39993, 38580, 587, 47493, 25874, 46354, 19428, 43227, 26075, 35962, 10483, 57614, 43437, 31495, 2570 +, 44904, 23024, 41733, 25484, 58495, 30084, 36370, 53651, 1375, 6081, 28601, 18648, 39489, 52186, 13646 +, 14110, 32179, 28579, 14697, 56025, 54453, 1051, 15453, 14033, 3479, 51415, 24516, 37445, 11205, 56011 +, 40015, 56109, 55387, 21748, 57945, 53882, 28185, 10668, 47533, 29560, 53101, 52486, 24561, 8943, 21024 +, 38207, 23053, 53204, 6786, 37750, 25581, 37592, 15153, 41034, 51625, 18632, 8801, 52493, 56077, 20006 +, 24856, 12444, 52468, 20243, 34193, 50413, 14125, 2378, 37433, 38010, 8290, 30535, 6849, 32851, 39478 +, 27873, 47411, 2531, 57429, 54197, 16633, 23010, 8141, 8138, 40396, 59766, 3123, 49198, 28611, 35552 +, 45556, 53467, 47997, 38024, 13710, 22190, 4790, 4187, 920, 42223, 18550, 9210, 12758, 1751, 18414 +, 28588, 29624, 5825, 7471, 3406, 36374, 456, 2768, 44516, 8595, 19517, 20634, 11718, 45067, 49246 +, 47270, 30623, 42713, 35267, 8648, 32776, 33809, 13438, 13315, 34729, 32013, 31865, 20292, 21124, 33616 +, 15058, 49712, 39593, 20883, 33536, 19351, 33609, 33992, 22119, 54477, 42587, 17988, 15112, 30657, 3055 +, 40710, 54280, 33679, 59775, 5899, 18679, 32551, 39709, 8469, 22219, 50790, 40482, 30436, 47434, 1606 +, 4053, 2492, 27671, 19998, 59727, 1207, 15701, 9689, 35199, 37820, 4166, 54139, 55809, 19278, 1148 +, 35216, 59988, 55428, 8895, 36116, 1328, 27574, 8667, 17389, 36043, 30886, 44531, 52878, 1323, 31966 +, 30836, 41728, 10810, 58507, 38078, 46890, 36066, 53779, 56579, 47618, 7951, 745, 41757, 40112, 56376 +, 42905, 15329, 32716, 14686, 576, 8832, 52366, 28151, 53852, 9755, 40546, 1090, 30638, 9776, 38765 +, 38956, 40613, 56845, 49767, 15472, 34923, 13009, 51539, 5054, 9588, 39157, 49358, 10333, 57266, 29470 +, 43061, 16523, 21151, 15778, 31209, 21728, 962, 23575, 26231, 54814, 9682, 43129, 55905, 40321, 52906 +, 11022, 55629, 9871, 7868, 21748, 25343, 19143, 34757, 53234, 24198, 44345, 8743, 13556, 31031, 6009 +, 19378, 14092, 22533, 40530, 6222, 30094, 38610, 7185, 53670, 4841, 38351, 39704, 47970, 10608, 56377 +, 17228, 21631, 52007, 27099, 29499, 50107, 28795, 48642, 24865, 22029, 49192, 45562, 30773, 2748, 16593 +, 13134, 58479, 7038, 12019, 15361, 49612, 42114, 53971, 33149, 12136, 35164, 11501, 51840, 59486, 58461 +, 24570, 16715, 20092, 52929, 43814, 25943, 43036, 12609, 14586, 7901, 10991, 3778, 53464, 18116, 42879 +, 46409, 7602, 41358, 29799, 19622, 33071, 19412, 1736, 27042, 52561, 50224, 2206, 40414, 18416, 1692 +, 38876, 42986, 54759, 58968, 35915, 38574, 24912, 18952, 27535, 15850, 3205, 14878, 55980, 33021, 32994 +, 38859, 55783, 40597, 56569, 25582, 36571, 29640, 44994, 14659, 33034, 13908, 4883, 35240, 30674, 23299 +, 13285, 9550, 42638, 8044, 44871, 18553, 22970, 46135, 13857, 26858, 1985, 53415, 41736, 34317, 26436 +, 51083, 13177, 58571, 8032, 46098, 24154, 20955, 15739, 45500, 35614, 25125, 59408, 40497, 366, 30083 +, 40148, 50003, 15985, 22786, 34399, 856, 17692, 57370, 23343, 7901, 580, 1680, 1316, 42316, 35998 +, 4105, 9751, 49175, 2676, 54135, 11625, 3182, 15090, 3716, 48683, 50704, 28842, 24443, 7553, 5560 +, 30878, 47702, 55563, 46864, 46840, 29962, 24072, 4532, 3684, 47416, 48786, 4264, 49096, 26454, 22933 +, 25094, 30559, 9036, 50621, 9588, 3172, 2247, 49122, 54614, 5963, 37805, 45319, 34805, 2249, 52872 +, 16717, 33127, 16926, 12280, 56343, 3767, 18595, 20416, 44651, 58631, 7832, 9789, 2896, 33280, 36244 +, 2181, 58375, 43155, 11217, 48996, 52743, 50741, 27595, 41866, 45356, 9911, 56023, 30675, 21068, 34624 +, 59899, 37786, 7752, 53178, 26418, 4095, 33297, 45013, 863, 54300, 43645, 8695, 4090, 22893, 18328 +, 40334, 1426, 16703, 23489, 48995, 42051, 52585, 39737, 45999, 10803, 25093, 55910, 6826, 32120, 16978 +, 41451, 8371, 31116, 25555, 1549, 57535, 6002, 11198, 18900, 6866, 5499, 38897, 51913, 9589, 38142 +, 10241, 26275, 39568, 3296, 49764, 28564, 45348, 42349, 44653, 31347, 53152, 9746, 3609, 36331, 18218 +, 56939, 17782, 26589, 28056, 43337, 4491, 1943, 49339, 15689, 20843, 32557, 57540, 59741, 24471, 43481 +, 14235, 34712, 9756, 53804, 38009, 59521, 58720, 59709, 18222, 43373, 7408, 47727, 53119, 11017, 24058 +, 47689, 44308, 41840, 14278, 48716, 1529, 55121, 50659, 27220, 47163, 11503, 59778, 44703, 47596, 24249 +, 4537, 1831, 35313, 14293, 31987, 49674, 50166, 30707, 25735, 8389, 50432, 33143, 56116, 19903, 20512 +, 56526, 7592, 4821, 38366, 58223, 53537, 16247, 53344, 20549, 43467, 40507, 8404, 19597, 1563, 32352 +, 43846, 6100, 10535, 55512, 56745, 42523, 45186, 46912, 49582, 47274, 55301, 40015, 20417, 27769, 59918 +, 40930, 24295, 43863, 22103, 39013, 42086, 51992, 31612, 35430, 48893, 15079, 52290, 57297, 11029, 30205 +, 29649, 54875, 36305, 40185, 26739, 33050, 59060, 48278, 56314, 48642, 35552, 27967, 5009, 55969, 55736 +, 41280, 13251, 56383, 25143, 11706, 11748, 7229, 40051, 43360, 19011, 28944, 34792, 47653, 2594, 45821 +, 17858, 32243, 17048, 30515, 48780, 20140, 39918, 47840, 8418, 36232, 12835, 20322, 4200, 54196, 52643 +, 36288, 35476, 42247, 9024, 36971, 53953, 57124, 20552, 10356, 16837, 15916, 15653, 51629, 3569, 18247 +, 13802, 57780, 50490, 7202, 28295, 39271, 3694, 44565, 3463, 12112, 57150, 52650, 8786, 37702, 46847 +, 1430, 13990, 58675, 43677, 59366, 35647, 13982, 56491, 32551, 691, 13328, 48467, 16344, 41309, 52037 +, 34591, 31463, 49817, 25081, 15017, 54464, 40704, 18712, 15382, 20520, 7176, 12532, 13170, 15963, 50234 +, 36369, 53745, 40576, 35045, 37422, 16295, 47044, 27756, 12786, 19595, 28447, 2466, 8063, 44791, 20127 +, 100, 19382, 51590, 26269, 20816, 42959, 57085, 1520, 1671, 12467, 58392, 45200, 24999, 11563, 1163 +, 51585, 24284, 54908, 32162, 59329, 8682, 48457, 22725, 36438, 37595, 42321, 41238, 40061, 50384, 26029 +, 188, 26836, 21764, 28130, 29457, 42580, 11089, 26542, 20452, 49113, 39010, 18845, 34313, 4009, 6760 +, 11828, 55595, 31044, 6736, 4109, 6726, 51770, 52566, 29451, 4560, 6513, 11772, 45798, 46574, 38508 +, 48180, 23114, 41696, 9944, 27596, 11153, 28876, 15037, 37696, 49328, 40502, 16706, 44525, 14815, 57067 +, 51285, 26643, 29014, 58682, 9731, 33123, 5408, 37853, 2041, 34859, 42414, 8554, 22984, 4564, 31480 +, 37844, 29096, 30946, 19541, 15392, 58542, 30694, 44268, 49932, 44742, 9949, 30434, 1448, 54474, 45250 +, 34868, 45760, 48245, 3882, 44442, 34329, 37006, 26202, 12182, 15399, 37413, 30948, 23954, 397, 35513 +, 55434, 14594, 40961, 26381, 34135, 56354, 1275, 41181, 40622, 51207, 25924, 50571, 21642, 27372, 21398 +, 43244, 38592, 43510, 7841, 42475, 4304, 42170, 55833, 30506, 54353, 11232, 7919, 1653, 35186, 44669 +, 13518, 6973, 35615, 54480, 9706, 9750, 50834, 47333, 50931, 7808, 38541, 53207, 34732, 36535, 56932 +, 56130, 19779, 35524, 39640, 3972, 17999, 43944, 46143, 13832, 50802, 16848, 25065, 35073, 18501, 36603 +, 56094, 32020, 19928, 31709, 26500, 29634, 41459, 53686, 16968, 8743, 1494, 31861, 1950, 12578, 8396 +, 58882, 45060, 4527, 34407, 24700, 8499, 28758, 44996, 30994, 18943, 12150, 47842, 44008, 47224, 42696 +, 56963, 43318, 51068, 16892, 15028, 53920, 22878, 32839, 47606, 16198, 41582, 25452, 48059, 19885, 38031 +, 32807, 55119, 23091, 13686, 29526, 24144, 58538, 34637, 45492, 29532, 53580, 57643, 53727, 13940, 44867 +, 36423, 10903, 4537, 3843, 4147, 19565, 57763, 27026, 52405, 45369, 43224, 10339, 47173, 7636, 6576 +, 1556, 40443, 1696, 1000, 30482, 7574, 25144, 29020, 42211, 46988, 34904, 35791, 44631, 4983, 26083 +, 5850, 17758, 36987, 10388, 21601, 17486, 6305, 19364, 20864, 35062, 4733, 4089, 45402, 28259, 48077 +, 51978, 29815, 4872, 30026, 30815, 35354, 37601, 32311, 40726, 19812, 19300, 51983, 31956, 40283, 56966 +, 58039, 46134, 14725, 11378, 32874, 36326, 28865, 39179, 55691, 49729, 14242, 36776, 30170, 35996, 5035 +, 18247, 4326, 34851, 59472, 34353, 42018, 34826, 11954, 14330, 51905, 8118, 33630, 43888, 40074, 13913 +, 40854, 14466, 36399, 55579, 25844, 9273, 8258, 54709, 24805, 3949, 20791, 39047, 17077, 50961, 51395 +, 22113, 45561, 55721, 33316, 45033, 6426, 15334, 56211, 18380, 6016, 48116, 26499, 15998, 32004, 42925 +, 29912, 49211, 57391, 42663, 21142, 59588, 28289, 29400, 30649, 53094, 9701, 51440, 32141, 3131, 18754 +, 59888, 1596, 4315, 55609, 34912, 25700, 2036, 26598, 58263, 56768, 8967, 46380, 59619, 24965, 54736 +, 18897, 31229, 20299, 52640, 13893, 41442, 52228, 42182, 47194, 22878, 35276, 56896, 50670, 43769, 27 +, 9424, 20009, 37975, 50091, 15618, 12887, 15791, 54006, 15837, 14055, 27127, 24804, 36787, 3098, 26122 +, 7875, 21995, 57351, 28175, 14636, 47596, 45969, 6864, 29778, 33163, 6094, 41406, 6411, 56765, 1527 +, 42790, 6189, 21536, 20765, 56281, 13507, 10004, 48424, 43865, 25842, 38831, 47344, 26998, 51970, 50443 +, 53120, 59846, 12438, 26824, 28021, 3426, 14420, 13990, 46643, 20551, 47153, 52737, 38309, 29917, 25854 +, 39837, 12707, 8396, 37725, 33473, 41029, 27584, 43477, 29453, 11450, 45671, 44637, 35146, 49022, 36607 +, 25589, 42142, 36453, 14380, 45318, 40826, 17806, 59739, 54816, 40801, 56642, 18322, 33539, 34951, 48239 +, 35745, 51140, 37298, 44141, 5218, 10771, 25170, 32802, 30601, 30976, 20604, 16272, 15613, 55751, 5294 +, 52220, 21340, 23789, 5026, 12072, 45459, 45852, 29879, 21550, 17021, 10680, 18192, 35343, 20571, 53144 +, 59934, 56317, 20636, 37232, 40458, 25854, 24356, 41981, 58657, 54957, 12957, 55613, 47581, 28570, 51364 +, 29228, 57142, 49057, 29369, 2168, 1129, 14828, 24373, 7360, 36379, 41394, 54393, 30923, 16737, 14964 +, 419, 53023, 47633, 21056, 30255, 4444, 23262, 30963, 46425, 58271, 25920, 59382, 53885, 49854, 4304 +, 21601, 19082, 37798, 47010, 24803, 39967, 48140, 39631, 4340, 31852, 52362, 45734, 26245, 23286, 38823 +, 41210, 57, 31846, 28843, 21113, 38453, 9639, 44376, 45769, 56064, 18999, 48041, 31798, 12884, 37895 +, 36102, 34486, 33329, 13901, 21496, 58132, 30220, 45988, 14116, 10912, 17841, 42830, 32998, 44086, 6116 +, 11821, 1648, 42526, 20019, 6844, 3639, 34824, 16483, 24367, 20593, 12548, 43367, 8635, 20698, 32603 +, 46530, 56801, 43441, 56212, 47054, 41290, 54344, 53626, 27278, 44812, 4538, 21471, 27643, 37536, 41910 +, 10111, 49357, 43558, 52637, 45728, 26754, 56277, 20552, 43238, 56996, 17498, 32138, 16715, 26133, 52836 +, 49319, 49015, 25989, 32760, 45227, 13043, 14050, 15924, 6669, 17681, 736, 47559, 15504, 28379, 25095 +, 57414, 38491, 50804, 17325, 31128, 12884, 44079, 3757, 9789, 27317, 37106, 27287, 35807, 53821, 29772 +, 28644, 19492, 18787, 54633, 28605, 40367, 44029, 19007, 56291, 27050, 36688, 33379, 14610, 28545, 38111 +, 16057, 25959, 16602, 6862, 43284, 24082, 19746, 3716, 4192, 5887, 7385, 17650, 33174, 43193, 11471 +, 2946, 11837, 7316, 21734, 42822, 35921, 38453, 26851, 54928, 11096, 53902, 7969, 44475, 44864, 36514 +, 22586, 921, 38825, 15540, 44135, 58462, 15975, 40234, 2178, 20167, 46121, 9563, 37817, 19296, 29108 +, 25640, 22242, 40945, 9308, 20328, 120, 45229, 35133, 26971, 16510, 46229, 57225, 831, 7057, 42089 +, 13697, 29643, 19363, 52522, 21536, 3498, 50984, 37511, 43732, 29514, 57678, 29854, 15430, 11847, 25502 +, 44538, 13839, 24096, 1836, 23148, 20777, 1956, 44729, 55910, 28927, 37591, 18492, 2505, 38422, 25549 +, 20946, 52119, 55192, 40309, 20994, 53080, 43808, 11978, 30591, 3892, 17845, 4621, 10098, 33275, 16468 +, 11952, 17813, 6660, 36049, 19649, 29808, 56826, 21605, 50889, 29088, 26885, 28481, 47580, 5742, 43255 +, 13129, 26688, 35375, 44674, 6998, 56369, 37754, 27158, 44699, 44698, 7402, 2544, 49319, 53853, 35819 +, 42140, 5805, 53633, 48800, 18206, 49634, 54960, 51384, 47592, 45849, 20473, 50829, 50682, 44405, 56571 +, 33938, 33887, 23259, 9313, 54913, 6609, 42034, 9019, 10119, 26733, 53717, 53874, 5630, 43037, 47727 +, 41449, 25177, 29884, 11434, 13977, 48091, 37421, 45289, 39475, 25013, 31138, 36300, 15842, 58173, 20706 +, 48765, 32111, 30945, 12024, 17776, 25858, 54986, 36162, 11229, 41457, 39247, 4947, 35331, 44877, 24336 +, 59410, 2679, 49513, 29295, 50465, 39842, 53738, 27886, 1483, 9565, 29251, 32621, 45866, 45093, 7146 +, 42924, 10210, 39257, 50221, 58587, 33385, 16079, 53573, 9547, 3660, 11382, 48795, 8607, 23066, 33672 +, 32943, 22476, 12703, 58808, 28123, 3169, 15002, 58213, 31055, 16485, 7779, 307, 25459, 29997, 21752 +, 32605, 12921, 31963, 48215, 3142, 6902, 21600, 55573, 475, 7500, 59233, 48209, 56295, 44193, 11275 +, 6319, 53488, 10104, 19023, 28649, 14579, 58544, 20003, 12793, 29599, 36489, 56924, 6258, 38300, 26921 +, 4363, 47257, 16194, 12678, 35472, 55688, 19580, 33425, 51261, 56407, 40925, 26846, 44616, 13572, 47391 +, 32244, 56243, 17232, 18700, 51618, 22233, 33279, 50162, 42236, 22424, 56114, 55077, 19348, 2372, 33377 +, 22621, 43087, 56987, 38815, 55765, 32459, 34503, 15345, 42236, 2116, 48104, 59513, 5315, 32721, 13085 +, 29058, 41317, 45681, 46290, 17, 37299, 8523, 33296, 27462, 27112, 32073, 23576, 22189, 27773, 2300 +, 31919, 50395, 45388, 28906, 29210, 41153, 37717, 40066, 32851, 19954, 18534, 20955, 19467, 201, 30028 +, 8905, 29260, 11345, 54586, 51902, 11362, 31885, 36778, 21011, 35699, 3890, 53084, 59275, 26079, 20857 +, 37928, 57998, 47604, 23316, 3256, 53167, 40821, 40974, 33233, 50024, 928, 28119, 10980, 56747, 28321 +, 17360, 42004, 33933, 5058, 36590, 25835, 52772, 44828, 2613, 13783, 56879, 6503, 43219, 56155, 8935 +, 40429, 10435, 6933, 28033, 10103, 46542, 57552, 50924, 27516, 7137, 40949, 4796, 35257, 28281, 1543 +, 39930, 21993, 19900, 13863, 27051, 32842, 39698, 19824, 17670, 18664, 9959, 14550, 25167, 53179, 47057 +, 34102, 9960, 33844, 17388, 14345, 43947, 3930, 11898, 34871, 7798, 19035, 52172, 12594, 54292, 56805 +, 50489, 10574, 55151, 10389, 24437, 22202, 43232, 4136, 18378, 37254, 22800, 28338, 28156, 24319, 57869 +, 51565, 34774, 44181, 25409, 28514, 58526, 9356, 8796, 10424, 20580, 16594, 5812, 49104, 29188, 104 +, 22262, 19677, 47031, 17413, 30067, 11468, 15967, 49651, 51956, 10698, 3257, 51108, 39036, 31414, 15428 +, 13257, 59331, 26554, 57438, 24741, 55068, 55964, 10449, 3864, 42741, 7381, 20458, 48553, 32838, 49646 +, 25009, 55100, 45675, 12040, 48865, 52094, 59861, 41184, 41745, 51817, 51882, 45003, 42926, 7270, 52769 +, 34706, 56879, 52100, 1260, 30669, 53193, 56328, 2986, 3643, 36544, 45727, 47376, 57002, 10632, 20214 +, 23000, 11993, 51666, 45027, 24034, 40531, 37122, 23895, 58068, 55219, 52064, 26302, 16574, 34990, 9925 +, 9343, 9696, 6804, 37796, 47308, 13826, 30989, 19988, 16812, 10984, 56532, 38891, 58361, 29886, 49523 +, 18575, 29238, 1516, 10242, 14266, 1902, 27125, 51388, 2149, 1545, 22959, 54214, 27848, 39534, 5556 +, 37773, 25229, 15253, 20929, 39377, 38913, 34755, 10367, 58902, 51567, 57703, 31786, 30458, 56064, 1673 +, 56333, 50992, 30911, 34202, 37586, 45177, 36104, 41063, 12917, 14606, 42609, 12229, 8820, 46809, 51763 +, 14376, 934, 53344, 5981, 21863, 9074, 44895, 32971, 55793, 20149, 890, 53496, 51935, 7701, 25913 +, 29960, 4034, 53257, 872, 14588, 30843, 22401, 50693, 48258, 11671, 5299, 30867, 23900, 50471, 17676 +, 52015, 4847, 18610, 21711, 47181, 16826, 30785, 8428, 26149, 26578, 28577, 27039, 56427, 56864, 11092 +, 22340, 26825, 51479, 15597, 4049, 6067, 22792, 2802, 33112, 11050, 50825, 38411, 18270, 51077, 5234 +, 12298, 19444, 46434, 30909, 41156, 33615, 24087, 48293, 42043, 50236, 51224, 46972, 53627, 47651, 20188 +, 4720, 46343, 47013, 56199, 38292, 27414, 38618, 1084, 6569, 11731, 48486, 57394, 26494, 6756, 48472 +, 31729, 19055, 7916, 18163, 26316, 25424, 28130, 26755, 13718, 46525, 53343, 41294, 9849, 46970, 28945 +, 30037, 28042, 51640, 53403, 593, 29932, 20817, 39212, 7368, 27386, 50943, 32206, 1133, 17437, 15315 +, 49605, 25518, 10722, 57521, 20033, 37038, 59298, 48163, 40145, 49368, 34688, 33488, 30662, 44537, 56810 +, 35959, 50927, 24853, 27599, 44330, 25446, 33883, 41499, 41010, 41251, 45238, 8305, 49809, 46371, 2095 +, 5124, 35976, 27613, 15846, 9849, 47647, 29236, 9147, 12162, 9381, 58515, 23203, 42869, 5529, 7740 +, 16032, 41488, 35019, 40885, 45439, 19349, 42683, 19322, 849, 23694, 36925, 46087, 31999, 26735, 32458 +, 34094, 31859, 44786, 38060, 47706, 54635, 2059, 16942, 40135, 14221, 26324, 15002, 37424, 45545, 20532 +, 21517, 1577, 2020, 32888, 18814, 47460, 52238, 1498, 43134, 29439, 1544, 20060, 51878, 9895, 46795 +, 24336, 20342, 55006, 45474, 34754, 42712, 16461, 36813, 36007, 32948, 27386, 38683, 47951, 41163, 580 +, 8483, 39032, 2158, 46855, 11920, 57324, 10667, 4158, 35174, 53802, 9949, 36718, 13862, 1827, 22966 +, 37009, 2515, 19660, 32015, 47989, 54414, 51080, 40803, 31227, 27087, 13751, 34965, 5770, 1702, 16128 +, 6350, 46537, 55160, 44860, 33393, 7081, 42185, 20412, 47591, 53711, 14214, 57541, 30430, 4428, 59368 +, 29748, 41437, 38236, 49408, 49805, 26225, 20174, 40885, 7028, 51401, 44324, 20780, 2718, 26446, 58834 +, 18847, 9148, 45372, 50359, 54009, 55117, 33792, 12546, 15529, 57736, 6257, 29744, 55277, 13039, 34172 +, 30997, 19139, 51962, 9233, 8547, 18119, 11811, 28721, 59004, 55191, 56474, 19680, 15971, 35545, 46126 +, 51158, 54392, 55274, 36530, 21103, 25635, 31647, 54896, 14533, 23528, 28984, 57143, 53272, 24261, 10182 +, 3797, 31610, 29322, 32111, 17196, 14221, 50230, 29007, 19295, 25586, 550, 52121, 45266, 16522, 27666 +, 31392, 44032, 58410, 3018, 20562, 19514, 28654, 28561, 50762, 43187, 52089, 19746, 40330, 21714, 20359 +, 26865, 25511, 28321, 32539, 33974, 21869, 23112, 24204, 27228, 42407, 49790, 27779, 34529, 35056, 20653 +, 38547, 42800, 4685, 36958, 45818, 25247, 32824, 14472, 30160, 59938, 34012, 22249, 56036, 50694, 43963 +, 16395, 53911, 45826, 21068, 26450, 19800, 42938, 49563, 44004, 10166, 8322, 10146, 37945, 19203, 45202 +, 58598, 57751, 28002, 39635, 11061, 50173, 4882, 43885, 40997, 35042, 43823, 15009, 33644, 39859, 42056 +, 53959, 32606, 35967, 39786, 30026, 38770, 59586, 12964, 4685, 19943, 59483, 13007, 30089, 13780, 32211 +, 51644, 12379, 6314, 55998, 52014, 17375, 46171, 33249, 37612, 27169, 44643, 57787, 18530, 54639, 13998 +, 36938, 48599, 22956, 12906, 28385, 52982, 28028, 4323, 42299, 32713, 618, 41782, 22072, 30708, 55562 +, 54283, 22352, 44293, 36949, 18350, 12660, 30676, 40874, 22261, 8288, 8043, 6904, 6075, 2925, 37896 +, 56425, 39864, 26495, 19381, 29122, 31232, 12364, 57150, 35555, 54663, 29863, 12526, 36445, 28287, 43234 +, 8359, 22571, 41938, 52653, 35872, 36640, 41665, 6549, 17514, 3926, 51189, 1909, 47182, 33617, 4835 +, 25078, 30042, 44699, 51573, 49424, 13821, 59157, 1788, 47323, 11065, 32803, 53538, 23591, 45600, 21825 +, 6825, 53959, 20748, 48763, 22964, 56621, 1755, 4629, 39522, 19270, 8555, 30711, 21179, 55738, 4328 +, 26014, 20816, 34371, 47065, 48742, 23795, 37238, 47899, 1935, 24561, 58964, 34738, 54451, 22555, 20338 +, 16277, 5732, 50649, 37025, 54495, 13614, 9998, 56251, 18243, 49520, 51873, 3151, 56584, 13052, 58889 +, 912, 15419, 56057, 35283, 38836, 44799, 35430, 16075, 9051, 37365, 16988, 8015, 48455, 11440, 6923 +, 45145, 4069, 12655, 35795, 17446, 43503, 25761, 27445, 16106, 20356, 53317, 7979, 23507, 49901, 57383 +, 58748, 27166, 49154, 54806, 2449, 27991, 15957, 14232, 20418, 1360, 27949, 13758, 45728, 16405, 25198 +, 52651, 37902, 5619, 5306, 13697, 23066, 25161, 15810, 26863, 41267, 36167, 56532, 25598, 59674, 22786 +, 22982, 58423, 49952, 48488, 29581, 28753, 16479, 21890, 42985, 13249, 23251, 10935, 27008, 8979, 3692 +, 28558, 37982, 41594, 34178, 19640, 31644, 33596, 44802, 47454, 36811, 26069, 23621, 33343, 51668, 23296 +, 56129, 51002, 58071, 22433, 39490, 27652, 51187, 32322, 25894, 34172, 45571, 49145, 21459, 48931, 34476 +, 25151, 17490, 12458, 6746, 28020, 32099, 38390, 37968, 53253, 2196, 14779, 19322, 25818, 48122, 47342 +, 25466, 20604, 14696, 23537, 19389, 30539, 27541, 10576, 2861, 53435, 21101, 24784, 42581, 42560, 13716 +, 53409, 7712, 7558, 5868, 50810, 35578, 14319, 5552, 13546, 7572, 7748, 28325, 3246, 9918, 52799 +, 26941, 35384, 49755, 41637, 58921, 9145, 12176, 26462, 56073, 51389, 19898, 17174, 16174, 38831, 36087 +, 6242, 32240, 43799, 13800, 14460, 10961, 25730, 5131, 16513, 39276, 12703, 613, 43953, 52302, 10532 +, 13104, 19243, 45916, 39212, 37232, 21190, 24709, 25761, 24004, 20782, 17150, 43902, 14309, 9676, 59085 +, 50396, 15918, 31326, 10547, 29718, 22138, 21508, 31800, 27270, 14373, 11076, 16325, 51338, 31381, 44979 +, 38222, 20838, 40574, 491, 50, 17807, 21681, 24759, 19920, 45685, 21893, 13422, 5940, 12554, 59451 +, 5025, 2950, 15369, 12703, 13497, 21440, 11194, 11357, 53240, 38464, 25730, 40669, 31141, 53421, 48402 +, 16121, 31643, 9240, 56695, 32134, 9290, 50854, 53815, 10401, 47126, 15853, 8647, 549, 21793, 21201 +, 0, 3170, 504, 51721, 52226, 50353, 49513, 3420, 1711, 19106, 18236, 3793, 36127, 49377, 57214 +, 24529, 41850, 5210, 33770, 38546, 37344, 19412, 5752, 7512, 6166, 52879, 59717, 14813, 29780, 57862 +, 12366, 6132, 1032, 12870, 34205, 53258, 39576, 23719, 33030, 41287, 19177, 51266, 21432, 55304, 40644 +, 18647, 19833, 58846, 209, 29955, 37392, 37553, 49368, 43145, 21417, 55534, 12376, 21134, 46699, 42156 +, 18996, 35417, 48288, 20029, 24640, 22493, 49639, 4216, 22564, 22670, 21855, 41741, 50288, 43287, 37045 +, 7284, 38286, 33231, 6131, 38495, 3186, 43523, 16049, 28906, 3020, 13818, 792, 51748, 34953, 47491 +, 33904, 53949, 59261, 58544, 50330, 23901, 57390, 16322, 28117, 19954, 15344, 49972, 38048, 5632, 9611 +, 51445, 12917, 47898, 24676, 19048, 26393, 4215, 38923, 18794, 33121, 18296, 32613, 33914, 10044, 7566 +, 57757, 20301, 37867, 57018, 55197, 28198, 20919, 52587, 44520, 25388, 12542, 59864, 51712, 50590, 41848 +, 1324, 42035, 54765, 49222, 43064, 50165, 51967, 47279, 5441, 47114, 56752, 89, 19727, 30666, 46485 +, 3645, 4776, 6786, 41512, 1794, 38336, 46062, 59066, 30923, 6934, 806, 43465, 6798, 52519, 10407 +, 48647, 30195, 28795, 19764, 55769, 11859, 46282, 47736, 35490, 51723, 34850, 32242, 28164, 30929, 39261 +, 14649, 34574, 44037, 57788, 52439, 22183, 36124, 38501, 21249, 7047, 45436, 22056, 26865, 28586, 50927 +, 13624, 53585, 21122, 42419, 13350, 16891, 30630, 35984, 40979, 6120, 4059, 15830, 38363, 32223, 23111 +, 17624, 46872, 57686, 38013, 44660, 26477, 196, 20784, 4978, 21446, 4184, 26766, 19854, 7401, 55353 +, 10781, 21025, 25290, 31903, 3445, 14992, 25146, 34075, 50976, 6125, 16548, 55035, 58307, 54911, 27258 +, 21419, 48887, 14131, 55457, 26900, 35143, 21934, 3448, 32280, 3264, 1246, 12816, 30031, 21100, 20217 +, 1736, 8233, 41242, 27026, 40136, 21039, 18371, 41634, 31467, 9347, 47760, 48015, 40735, 22419, 19278 +, 7993, 43838, 44517, 58476, 15647, 47769, 33620, 13933, 51217, 42252, 17198, 52464, 55068, 23581, 13564 +, 15285, 1669, 21798, 32879, 5047, 38286, 30271, 23418, 56273, 1738, 32766, 44033, 26105, 13501, 42804 +, 45383, 57846, 2995, 29900, 56323, 18642, 17669, 6295, 32576, 45238, 24899, 49774, 37702, 19967, 49707 +, 27619, 11604, 51376, 25769, 20835, 56423, 4055, 51106, 19842, 36680, 29196, 28960, 20713, 55301, 18813 +, 39870, 17036, 53011, 42865, 23288, 25686, 1507, 17309, 8333, 34083, 2548, 33232, 209, 40250, 29551 +, 26268, 7869, 17507, 17644, 33638, 38343, 50420, 14046, 29449, 46614, 50726, 58646, 51926, 47792, 30299 +, 10739, 4014, 47336, 40102, 46879, 10624, 5789, 48386, 27934, 14122, 58822, 30482, 23707, 35383, 47084 +, 53258, 1652, 31306, 47118, 55648, 41296, 25461, 46068, 31694, 31262, 32682, 58773, 6260, 24608, 22917 +, 36560, 11699, 26931, 23896, 51802, 13810, 10872, 33943, 38548, 15158, 48065, 13722, 45640, 48124, 49106 +, 9077, 17735, 27110, 16735, 4853, 59110, 58031, 30314, 45179, 29726, 37928, 54213, 4851, 44189, 55174 +, 27768, 57101, 43225, 54699, 57349, 11379, 8509, 8221, 45322, 23409, 23380, 9740, 37132, 45372, 57864 +, 2590, 30801, 15599, 29700, 47536, 20452, 5162, 45568, 27118, 50341, 51646, 5047, 20907, 56497, 25588 +, 52433, 24265, 22689, 35658, 55316, 56390, 47038, 3825, 4611, 8712, 3586, 4343, 18452, 40718, 26068 +, 52669, 43308, 56869, 44620, 49360, 44406, 41425, 54523, 6326, 8543, 21216, 57972, 49942, 18475, 30821 +, 51882, 10908, 31438, 50923, 22919, 26754, 47313, 46309, 6931, 28277, 55021, 10517, 32620, 49826, 51236 +, 58688, 42495, 10896, 31910, 27115, 36609, 16316, 8540, 31132, 58994, 53436, 28700, 33318, 19730, 47176 +, 4139, 47965, 34436, 11929, 38888, 57355, 38683, 26202, 43664, 21966, 54479, 15038, 32483, 3451, 4864 +, 71, 38492, 23711, 47320, 10402, 50826, 23929, 3070, 35719, 55061, 2064, 5507, 113, 35382, 1589 +, 47289, 15873, 25906, 58078, 27802, 4795, 55433, 42837, 7349, 15450, 4803, 38180, 6840, 13638, 17983 +, 11704, 50062, 56475, 11767, 37382, 6877, 2593, 1311, 46299, 14664, 32724, 48363, 56523, 32837, 97 +, 34465, 56479, 15970, 371, 54557, 20124, 5166, 26342, 2961, 48867, 18144, 44116, 3399, 24984, 57755 +, 21383, 13040, 47817, 17858, 24807, 25199, 1088, 3753, 2862, 47387, 54769, 35586, 12103, 51293, 44775 +, 12200, 25758, 41254, 4523, 2481, 12163, 24647, 44000, 14858, 3961, 32867, 33002, 48077, 12619, 34339 +, 22184, 34002, 47379, 10001, 28212, 48539, 11552, 5652, 52292, 50766, 29392, 47061, 26352, 41495, 14706 +, 47480, 30047, 16816, 5086, 10922, 19298, 53602, 11922, 39650, 8460, 52235, 48869, 41462, 40312, 1488 +, 15801, 2497, 35490, 39533, 48850, 40055, 28072, 36755, 45707, 56716, 27521, 51451, 20129, 30226, 9298 +, 34836, 17706, 39346, 28004, 59144, 26620, 23654, 52746, 14894, 3304, 1206, 7129, 52174, 42669, 47442 +, 30014, 34822, 26291, 5505, 14355, 51493, 21912, 18779, 28248, 43971, 15495, 55770, 35423, 11977, 25996 +, 44721, 23165, 43702, 419, 51169, 19198, 27040, 51176, 11945, 41934, 54480, 13151, 25416, 23006, 32172 +, 49210, 53021, 43347, 15501, 34878, 34054, 43346, 56790, 52834, 11595, 17113, 44681, 7365, 52536, 56658 +, 33361, 13610, 19823, 53415, 14029, 47345, 12613, 17421, 38521, 910, 35708, 9353, 50414, 1124, 32360 +, 22586, 50334, 1733, 42285, 42187, 36611, 16340, 25533, 9753, 45526, 37128, 26866, 30207, 20845, 55755 +, 3218, 30558, 9365, 59393, 23973, 59746, 46738, 12939, 17168, 1611, 50201, 52876, 10965, 40615, 54000 +, 19677, 3202, 20686, 21410, 45487, 2873, 34373, 38179, 28406, 20478, 23705, 41887, 23696, 30265, 2732 +, 19451, 33483, 33291, 5168, 9228, 33616, 4915, 32319, 22907, 22083, 33930, 13109, 51311, 21247, 53724 +, 45311, 17276, 33278, 42349, 15038, 55118, 45222, 49411, 33297, 13628, 9889, 33355, 55515, 33586, 3620 +, 34600, 29389, 13455, 7891, 10910, 22683, 17859, 15825, 55002, 40767, 14260, 5285, 53876, 5571, 26532 +, 23952, 27234, 20161, 33583, 9583, 35199, 28701, 54805, 24611, 38350, 44785, 10852, 11705, 16653, 20790 +, 51677, 51253, 26532, 5132, 35496, 37442, 27816, 53355, 53267, 59170, 34122, 7527, 4455, 4350, 49450 +, 7340, 4655, 16684, 27501, 38238, 2619, 2700, 43291, 57424, 3663, 57993, 18561, 14516, 46051, 11566 +, 11658, 37728, 39171, 38190, 42861, 14667, 15632, 47029, 44375, 45251, 46199, 54849, 29130, 27007, 59200 +, 18580, 34347, 40207, 11616, 1848, 18445, 14235, 40900, 38088, 48011, 44564, 36081, 6573, 35432, 22132 +, 18139, 47090, 59861, 57311, 25281, 19074, 48330, 17265, 6103, 32705, 2517, 28654, 27555, 31647, 55661 +, 3107, 50228, 30008, 43314, 38196, 8208, 38111, 52432, 25461, 16199, 40443, 10025, 52280, 23368, 45457 +, 50765, 17860, 8899, 26978, 51523, 10532, 46052, 16205, 27798, 28507, 48911, 30315, 57161, 52818, 38314 +, 52823, 55925, 4894, 59183, 15591, 43091, 43744, 30054, 35523, 9205, 46253, 52318, 19230, 14885, 15687 +, 41039, 5650, 9899, 26290, 32628, 1422, 36823, 55032, 17627, 4621, 23539, 42890, 11288, 20701, 12060 +, 49602, 49876, 44337, 30849, 49059, 59928, 13940, 32803, 29982, 25815, 18360, 52587, 18133, 13942, 7473 +, 10172, 31333, 49475, 56423, 57624, 58456, 34197, 34447, 29840, 51825, 15420, 53380, 11067, 3060, 14081 +, 23128, 29014, 40309, 7465, 59863, 29368, 43746, 50155, 38524, 50080, 15970, 33236, 42668, 10456, 47179 +, 26493, 20628, 18512, 52320, 17052, 52488, 27128, 51249, 3287, 56969, 19426, 18707, 50349, 6846, 21767 +, 40782, 6326, 27134, 21091, 13791, 26997, 26811, 33889, 17153, 41687, 23970, 33123, 51276, 6638, 43579 +, 38455, 9483, 40560, 33319, 1803, 33964, 25808, 5284, 1565, 29095, 2253, 57344, 24155, 28954, 4190 +, 22274, 46088, 10516, 49408, 43531, 659, 52758, 46694, 34549, 46263, 28382, 34871, 55738, 19658, 17861 +, 39318, 34465, 27344, 56230, 7784, 5499, 6546, 9944, 10783, 8111, 15392, 49388, 5455, 15899, 18342 +, 45997, 38173, 4430, 56513, 3934, 47961, 33525, 56692, 34656, 44426, 42955, 39390, 19297, 38693, 35400 +, 37158, 54363, 46217, 40854, 26945, 30353, 46353, 33491, 40298, 33489, 17955, 32042, 22877, 23410, 47941 +, 41220, 45760, 2466, 22002, 42273, 6400, 46316, 52150, 39444, 57324, 36576, 58751, 36714, 32225, 13797 +, 48466, 45735, 8160, 34683, 26589, 11458, 5036, 12943, 21301, 21686, 22784, 39256, 53728, 45661, 39019 +, 18021, 3233, 24779, 20488, 25236, 43404, 26888, 11552, 35555, 6333, 8876, 48483, 41436, 21942, 20709 +, 55233, 46760, 6444, 3394, 21443, 9386, 51204, 2831, 22329, 12505, 24518, 21465, 51762, 54598, 7126 +, 30781, 12620, 10360, 31912, 33108, 35596, 15316, 36348, 23500, 50871, 19033, 8728, 15707, 470, 7022 +, 12768, 55703, 53782, 19212, 35449, 15225, 28598, 26653, 18056, 27279, 15511, 18926, 48744, 7273, 13525 +, 32223, 14406, 2497, 42583, 22670, 35605, 54531, 37986, 11953, 54383, 5210, 7339, 3111, 20917, 7809 +, 10133, 33685, 3512, 3915, 29249, 38962, 55492, 34200, 41967, 49900, 37831, 57478, 45179, 26576, 41103 +, 58704, 35151, 31861, 1201, 17734, 54531, 13158, 48617, 32518, 1463, 43000, 14080, 8802, 46111, 34997 +, 52963, 32596, 45034, 56476, 12863, 14283, 11790, 8355, 48483, 30109, 34607, 26315, 27588, 19786, 29243 +, 45043, 54842, 40746, 53257, 32395, 58480, 47788, 45553, 47097, 56658, 23369, 6449, 10738, 8523, 52560 +, 22087, 1487, 1508, 7121, 57963, 14371, 57757, 46105, 22726, 46240, 16214, 33685, 48907, 20154, 53472 +, 54502, 41550, 48314, 35248, 34807, 57062, 10080, 22595, 42615, 33529, 55606, 42336, 39978, 6344, 50860 +, 8890, 4784, 52347, 10398, 11905, 26662, 1121, 9662, 12767, 199, 32255, 5333, 33885, 57514, 1840 +, 3709, 28369, 43390, 52023, 39969, 18197, 49085, 50050, 17144, 8053, 59931, 12750, 26741, 16262, 55447 +, 17601, 1504, 231, 46300, 11903, 48488, 49314, 13024, 34503, 38433, 49576, 6758, 43767, 23461, 40624 +, 45607, 27170, 8993, 5349, 55545, 25315, 23546, 20983, 51717, 40690, 5388, 51648, 29793, 32129, 44262 +, 1592, 26083, 45767, 1823, 48735, 57670, 26663, 38050, 47046, 1166, 16483, 36622, 44276, 36602, 36435 +, 24901, 58561, 3605, 10246, 3910, 35503, 35561, 3808, 56486, 27278, 20851, 1874, 55279, 50644, 10355 +, 39541, 28588, 36438, 1660, 30411, 1526, 35682, 33426, 39576, 22729, 34593, 32411, 35703, 55221, 9014 +, 48491, 20122, 43927, 28448, 6721, 24190, 3951, 18634, 27998, 437, 22265, 25201, 38663, 53896, 52197 +, 49019, 9789, 20785, 1809, 11450, 27548, 3335, 47132, 975, 19263, 46213, 11920, 51675, 21917, 7141 +, 37041, 46760, 3616, 57320, 15208, 10337, 21510, 19160, 5323, 25861, 55949, 27588, 51062, 34613, 21484 +, 43260, 59984, 7626, 4045, 1793, 19076, 31594, 41481, 6208, 8921, 744, 52422, 20841, 28771, 50691 +, 27982, 42164, 37451, 7950, 39485, 52659, 54639, 37347, 48171, 59963, 3208, 44121, 3903, 54271, 18734 +, 1740, 13883, 18718, 9366, 54280, 56863, 28442, 2226, 38344, 34650, 11147, 15441, 27072, 31988, 44212 +, 17763, 36323, 2729, 55214, 20625, 42214, 24226, 15265, 19561, 12397, 15228, 59122, 56518, 19131, 29745 +, 51604, 20871, 43628, 10322, 6589, 37908, 7186, 35031, 40135, 21882, 9682, 51282, 37323, 13106, 59623 +, 57888, 7222, 12298, 617, 38788, 32923, 19183, 3014, 48188, 15096, 51764, 39768, 14218, 48282, 58900 +, 43963, 39887, 56123, 27591, 26561, 39065, 5500, 10099, 14096, 21987, 31982, 130, 49621, 9305, 13237 +, 49244, 7193, 20459, 37894, 44162, 35599, 47170, 3345, 38614, 35358, 18442, 30378, 51479, 32660, 55012 +, 26731, 16624, 11251, 59206, 20567, 14165, 38271, 2419, 24264, 52368, 24406, 56246, 52498, 14028, 41904 +, 42087, 39624, 25449, 38898, 17519, 9612, 14498, 4689, 12957, 29464, 16399, 7751, 36194, 44230, 40412 +, 31206, 10961, 33388, 18810, 10168, 30307, 32975, 48439, 32727, 33591, 40807, 33485, 29838, 9658, 47513 +, 48094, 28097, 3490, 13543, 6996, 21009, 59507, 57846, 2050, 48817, 27310, 54801, 56568, 3504, 39032 +, 13332, 11062, 26345, 46720, 29872, 36513, 53380, 39199, 24953, 26107, 12791, 42112, 59592, 18981, 28122 +, 23458, 7075, 56220, 26948, 56970, 39568, 24309, 32830, 37414, 2711, 21647, 4724, 33864, 54567, 8228 +, 49248, 7900, 55642, 15594, 30972, 1867, 52107, 24352, 41066, 53412, 50459, 30209, 11877, 26404, 49190 +, 39999, 49862, 32617, 12571, 16810, 5940, 52139, 41119, 38770, 29553, 43830, 417, 10629, 54046, 54984 +, 55209, 43295, 39236, 50852, 58889, 10209, 52719, 50996, 34561, 10137, 20761, 1373, 40347, 32638, 27777 +, 5889, 48989, 17639, 38507, 37913, 10801, 20799, 30052, 51920, 59569, 35958, 12102, 36338, 46587, 6148 +, 7674, 41797, 49443, 46911, 9001, 24684, 57120, 38072, 52033, 8033, 48209, 12794, 9406, 4908, 21784 +, 13535, 10798, 47125, 31174, 25657, 25038, 18327, 46456, 55091, 46599, 22377, 31049, 35053, 58715, 53988 +, 17554, 6389, 12137, 43349, 29652, 21138, 8034, 26772, 59210, 67, 11158, 23772, 12861, 56916, 28680 +, 10997, 10452, 15830, 58122, 17978, 41487, 23161, 36306, 4295, 54604, 22905, 26672, 2005, 34311, 25387 +, 55993, 51865, 8129, 44483, 35214, 37781, 5621, 43248, 40906, 41184, 43315, 28416, 41308, 32528, 25332 +, 46340, 19877, 35784, 2171, 18000, 30115, 43658, 17513, 6421, 24306, 12117, 5678, 50978, 14122, 39989 +, 52718, 46467, 31854, 37199, 30950, 43421, 14980, 12924, 26669, 32238, 30460, 46337, 654, 11768, 55217 +, 25987, 58108, 15095, 38123, 279, 9447, 8238, 20290, 26960, 51011, 44596, 15429, 33042, 11926, 29551 +, 13031, 4644, 16018, 21238, 41843, 23321, 4659, 33176, 36245, 7680, 41766, 43057, 30369, 42421, 54825 +, 25587, 44760, 29285, 17034, 59235, 5917, 26481, 43826, 2559, 29793, 34837, 23507, 45222, 7879, 35433 +, 14773, 57263, 16430, 7143, 54853, 34625, 6816, 35864, 44153, 43061, 19896, 25920, 2470, 50266, 44693 +, 33647, 15853, 29453, 2933, 9239, 5040, 45202, 35720, 48866, 47761, 5513, 56, 11268, 27087, 44287 +, 23053, 18212, 41550, 39483, 25355, 12755, 50461, 8524, 24971, 34614, 27937, 44868, 534, 30408, 35134 +, 45227, 4055, 27339, 51032, 6988, 36578, 56073, 52190, 48650, 21291, 16303, 54163, 21347, 27571, 57602 +, 5635, 26977, 15814, 23537, 42812, 17521, 36293, 33273, 26045, 1264, 7888, 53983, 22484, 8422, 24391 +, 57618, 30002, 28446, 1309, 21034, 11787, 37887, 53459, 40329, 26537, 14751, 56633, 57052, 36098, 556 +, 54654, 18085, 27533, 10468, 41623, 10346, 4342, 54268, 43619, 30387, 31884, 27859, 24370, 54369, 36282 +, 48761, 28339, 42636, 53560, 29649, 3670, 5347, 43888, 33482, 45676, 10426, 48233, 18661, 43830, 683 +, 19218, 38485, 55121, 23103, 25305, 36744, 33449, 29647, 31012, 53421, 36387, 2896, 21280, 757, 33617 +, 33914, 25871, 1957, 16550, 19431, 7958, 56573, 1130, 51846, 30055, 23158, 2272, 54640, 41820, 46103 +, 31675, 1038, 940, 26796, 24141, 2597, 3540, 33943, 8597, 10904, 3716, 44984, 50153, 24996, 45741 +, 122, 58911, 47964, 2079, 15461, 43747, 46389, 12034, 44877, 38236, 18441, 44388, 16860, 13081, 26208 +, 39315, 44757, 3598, 16607, 47905, 4091, 19205, 27798, 14386, 27802, 38702, 18102, 12786, 5207, 43099 +, 34879, 5330, 18362, 59196, 43761, 33823, 42943, 30151, 22210, 4173, 44739, 40651, 48561, 1599, 30085 +, 51121, 17267, 51194, 54719, 33874, 39099, 35162, 53079, 6897, 49549, 57233, 21952, 7651, 46371, 27159 +, 50750, 57603, 32489, 9112, 56799, 52603, 19288, 16094, 22754, 17850, 20267, 7493, 34853, 45180, 45444 +, 4938, 36301, 2711, 56132, 7372, 36586, 35232, 42535, 6017, 18481, 32084, 39603, 40433, 39735, 2326 +, 7593, 6838, 59929, 16434, 52302, 33080, 45389, 11590, 49175, 8143, 5792, 45794, 51988, 40646, 30975 +, 13785, 45584, 43628, 52848, 18069, 51001, 5786, 29653, 33536, 11804, 48134, 41972, 27759, 28568, 21707 +, 30085, 12513, 4897, 30015, 5299, 57200, 39447, 50689, 8790, 28622, 35184, 14583, 50769, 3525, 31581 +, 21744, 17310, 17165, 41724, 10158, 11586, 32725, 15945, 41239, 42613, 4101, 29374, 24585, 8212, 34294 +, 22645, 38297, 46807, 27542, 44664, 28458, 1094, 24112, 19147, 9885, 29086, 30684, 820, 19855, 34209 +, 8753, 17951, 27871, 25918, 59676, 14381, 37505, 8753, 6678, 18744, 51367, 47131, 24470, 52304, 55343 +, 58764, 51301, 33641, 45571, 55196, 54657, 14030, 56290, 55121, 9529, 42527, 24208, 40213, 19699, 44063 +, 50774, 28452, 38367, 54997, 54371, 38043, 9379, 8228, 23148, 16057, 3324, 50867, 3189, 27795, 43172 +, 34884, 26559, 10825, 8525, 48483, 6021, 39535, 38865, 2312, 34656, 24746, 44839, 35216, 41312, 4539 +, 55632, 32086, 32991, 33999, 27084, 3714, 48394, 36463, 48294, 11542, 28872, 51619, 2410, 8413, 55766 +, 21934, 43298, 58677, 32759, 28175, 23512, 38781, 7710, 2377, 17445, 18719, 3476, 2284, 53935, 44788 +, 43175, 49567, 16874, 52519, 23566, 20310, 56233, 11960, 33125, 20880, 59855, 1998, 12499, 2265, 46763 +, 44617, 24199, 30061, 43294, 33310, 58237, 6807, 12091, 42299, 45536, 5888, 1018, 49012, 44525, 54954 +, 33800, 27700, 44521, 27027, 56571, 44440, 47337, 29157, 32752, 20463, 50037, 32607, 58813, 2536, 11224 +, 45576, 47153, 35423, 51990, 6799, 45086, 26579, 13606, 33529, 8878, 35495, 39418, 9897, 24507, 23943 +, 41203, 34660, 27995, 2076, 38039, 24567, 22868, 25376, 53724, 55621, 22191, 43761, 28228, 57356, 22649 +, 39453, 19285, 46154, 51228, 11275, 52953, 36314, 37854, 6560, 9844, 46732, 42055, 25614, 32981, 42914 +, 49557, 50536, 53926, 53904, 28965, 31965, 18471, 51833, 33694, 48547, 47454, 55885, 32308, 52035, 29594 +, 54957, 7840, 48879, 41111, 59068, 154, 10417, 11735, 14360, 16977, 57931, 37444, 35384, 59897, 10426 +, 18298, 49454, 37314, 48577, 43358, 6279, 20542, 38182, 58113, 54236, 26729, 45567, 26474, 35390, 13954 +, 56068, 6699, 21794, 44947, 24163, 57215, 21453, 34580, 45302, 35813, 51557, 19585, 49609, 3293, 19482 +, 35, 57943, 8936, 13702, 46520, 28646, 19981, 7063, 43180, 18094, 1299, 9910, 40014, 4125, 21652 +, 53968, 193, 28351, 52115, 21492, 52514, 49330, 19297, 27094, 34632, 31462, 55003, 54217, 21072, 58296 +, 13699, 57459, 32592, 58987, 11161, 19112, 3985, 31143, 26175, 23518, 25589, 3827, 33428, 5603, 44304 +, 31432, 35924, 44498, 59783, 28039, 42342, 28650, 53721, 1640, 55744, 4705, 33102, 27100, 35274, 54174 +, 25396, 25325, 51634, 34340, 24312, 2795, 53453, 4649, 10290, 55980, 28167, 35880, 36159, 37947, 17835 +, 20464, 9379, 30111, 4962, 45515, 58150, 47304, 14165, 28223, 25296, 46261, 32928, 58399, 13361, 8202 +, 28925, 15110, 33527, 56911, 49450, 34191, 36059, 42903, 38841, 46349, 15236, 43360, 58581, 51395, 21308 +, 16417, 11859, 7039, 46528, 53173, 52554, 21031, 16830, 43071, 49254, 42126, 29333, 58535, 16877, 42694 +, 6737, 45803, 57804, 16617, 42714, 23607, 50808, 18773, 6510, 6001, 41475, 58098, 49362, 40056, 49494 +, 47022, 32825, 1353, 30413, 55706, 30879, 59320, 53089, 47709, 42391, 42343, 6187, 11724, 17230, 23065 +, 30771, 320, 45220, 4927, 16937, 27934, 28534, 7745, 23060, 11397, 50099, 4535, 9495, 39461, 20943 +, 35341, 2835, 53769, 13047, 33248, 49475, 43926, 8920, 18916, 7987, 51312, 37611, 14174, 39388, 54842 +, 13591, 46511, 55162, 58811, 27791, 12099, 3098, 32677, 56196, 26158, 20426, 46295, 7045, 6274, 2108 +, 27988, 41615, 41295, 21757, 54662, 50896, 47584, 14940, 59816, 6500, 59279, 27480, 44112, 13454, 43221 +, 15306, 3397, 29732, 10468, 2209, 33875, 58919, 5307, 6553, 55115, 7817, 26979, 17763, 14862, 33253 +, 19871, 42850, 51221, 37519, 40960, 45883, 28415, 28544, 37176, 28231, 11397, 36455, 32064, 31861, 26261 +, 15285, 47167, 29659, 21369, 57635, 8220, 55245, 56554, 49879, 1798, 28021, 57696, 5129, 45784, 48910 +, 38383, 42008, 31760, 29604, 19527, 12720, 51839, 47942, 17617, 29015, 52525, 5366, 41823, 24589, 37227 +, 8084, 16226, 746, 14095, 37596, 34733, 22315, 9193, 7639, 48546, 10991, 35660, 22594, 16120, 57797 +, 11504, 30855, 39805, 43265, 36811, 59332, 32337, 28651, 23626, 26306, 34018, 16151, 8024, 15841, 17093 +, 21603, 278, 33319, 22349, 14373, 47267, 57082, 13041, 56460, 4721, 37939, 43803, 16734, 534, 36276 +, 14531, 12038, 7131, 54336, 31655, 20295, 30020, 40345, 48946, 53646, 6651, 59316, 46149, 14676, 15158 +, 39594, 36279, 51788, 49266, 34981, 6161, 12885, 8415, 55554, 9346, 49489, 33494, 29501, 6223, 34028 +, 5777, 57106, 22418, 49261, 27794, 30426, 9556, 57814, 10771, 34854, 27812, 53774, 34170, 50313, 8450 +, 25680, 6260, 21082, 17468, 55526, 32415, 23630, 8411, 40830, 55536, 54109, 30319, 29030, 23611, 36542 +, 39410, 5740, 10000, 38181, 31353, 37794, 8607, 40909, 35608, 19378, 15763, 39772, 13152, 26286, 6438 +, 57955, 51966, 12698, 55389, 9435, 8224, 27804, 9417, 52987, 8634, 4953, 47097, 38954, 33984, 47060 +, 51848, 49746, 29152, 1849, 27927, 506, 39643, 12886, 17767, 51604, 32264, 9883, 7728, 21769, 36169 +, 14166, 56076, 28135, 26864, 27817, 13922, 11440, 55621, 23339, 4428, 40607, 28293, 27877, 55913, 38629 +, 14937, 24114, 4727, 20441, 25963, 9007, 20947, 41958, 21893, 38715, 9914, 30510, 48598, 53995, 52279 +, 1119, 8161, 24707, 29254, 11378, 52524, 19529, 22818, 24497, 42868, 3598, 5104, 47513, 31475, 37370 +, 26142, 22764, 1484, 7222, 43206, 3799, 16229, 40505, 22109, 38122, 19220, 8376, 8632, 44170, 2371 +, 37263, 45289, 10532, 38322, 50896, 58262, 30846, 10425, 21081, 31695, 53293, 1031, 36800, 40807, 32507 +, 50522, 43301, 31623, 52006, 26875, 14829, 32157, 43104, 31687, 54266, 21227, 50907, 2642, 6211, 11430 +, 5013, 43475, 56719, 51898, 21797, 47615, 50160, 28996, 34392, 47593, 691, 27686, 48625, 13843, 44845 +, 57484, 40717, 4498, 29107, 32723, 31374, 20289, 41232, 14478, 51976, 35499, 12057, 19235, 14493, 54621 +, 30665, 55859, 14448, 3737, 47757, 12597, 27704, 14269, 41593, 2097, 1863, 18637, 29783, 26840, 8832 +, 50980, 24324, 49550, 55478, 29783, 58625, 3204, 50072, 39858, 17683, 42048, 15357, 6092, 37636, 6202 +, 713, 8301, 2061, 15161, 48390, 49818, 27759, 16095, 40440, 45704, 18192, 42303, 4341, 24327, 45495 +, 49526, 15307, 9819, 39076, 47137, 39602, 37701, 50342, 6027, 17559, 44377, 24427, 9268, 50469, 2063 +, 51823, 27535, 46717, 53884, 42696, 35107, 20055, 46807, 51202, 495, 32512, 45746, 42798, 13205, 10073 +, 4645, 2731, 25380, 14464, 18159, 48870, 30418, 55861, 39212, 36445, 49772, 23589, 873, 35393, 50410 +, 39288, 27216, 17945, 26005, 21100, 36994, 1113, 41155, 153, 28667, 41650, 32665, 50766, 800, 22223 +, 839, 5445, 1306, 2572, 56261, 19466, 51442, 26680, 15327, 30654, 39477, 41451, 30595, 16702, 16844 +, 57357, 55991, 44060, 15303, 21996, 41513, 28649, 59461, 22668, 28802, 4481, 40671, 37820, 55247, 17823 +, 36395, 56086, 59621, 37701, 35010, 32234, 57167, 26452, 35266, 48846, 33458, 14744, 30298, 4053, 31446 +, 23494, 37763, 27437, 43907, 53066, 49434, 25420, 58067, 25247, 24440, 26869, 29728, 5111, 41041, 24975 +, 59287, 17436, 57414, 35260, 55138, 32424, 7494, 28657, 35229, 42761, 53856, 8687, 57505, 506, 49093 +, 5303, 24000, 26856, 32741, 7907, 56274, 58527, 9679, 30693, 126, 34120, 57562, 29855, 15583, 14956 +, 31182, 14870, 32392, 4948, 50130, 3882, 13725, 33977, 32540, 48954, 16738, 26396, 57641, 14243, 3254 +, 23086, 55898, 27254, 49942, 28639, 11514, 22568, 3518, 21193, 53261, 3645, 55313, 27176, 9852, 10897 +, 42132, 17386, 2119, 50876, 22335, 28602, 54759, 12412, 2579, 3651, 1366, 19317, 6399, 35359, 9912 +, 9653, 58446, 5810, 13259, 24740, 10802, 24773, 23661, 50672, 22319, 16922, 30669, 17632, 20450, 40521 +, 4881, 38934, 57908, 7001, 29811, 56595, 11955, 922, 9007, 14534, 40925, 46725, 10203, 23676, 22084 +, 20115, 9681, 20530, 2277, 22940, 21623, 13079, 24066, 45284, 40104, 46385, 38558, 10773, 40369, 59009 +, 51295, 45251, 37943, 25555, 28604, 44106, 58502, 40559, 45028, 43861, 31445, 2305, 30586, 41648, 25981 +, 52670, 38115, 35662, 49553, 40392, 34955, 47528, 29824, 59021, 32812, 46280, 45406, 47722, 57053, 2127 +, 46731, 24700, 47378, 1027, 26607, 52334, 45133, 25109, 9245, 6514, 45322, 40690, 8819, 15908, 58690 +, 11153, 44931, 13157, 46815, 10836, 29902, 21770, 58364, 36078, 57143, 7528, 22358, 42549, 31602, 19411 +, 44677, 18334, 44112, 8407, 55713, 10719, 742, 40846, 12181, 46339, 47360, 57503, 27030, 32532, 49764 +, 2072, 43685, 34695, 15230, 6852, 21883, 45132, 4975, 56599, 21210, 2118, 40479, 19920, 21020, 12081 +, 39331, 5697, 6767, 59795, 50456, 2480, 10515, 27550, 43327, 59048, 13890, 7039, 56551, 17272, 15923 +, 22667, 19344, 35960, 33714, 10926, 42813, 55597, 32410, 47788, 52196, 29972, 49906, 9027, 49892, 10926 +, 21109, 5576, 52975, 27876, 5371, 19784, 30357, 52238, 47334, 50036, 51286, 37576, 33427, 24190, 54848 +, 25703, 46857, 50545, 1663, 20572, 37823, 44476, 52521, 10234, 8616, 21070, 16558, 34875, 30097, 42803 +, 22153, 27558, 48379, 51481, 55435, 53750, 11265, 2144, 45989, 34951, 28532, 13627, 12528, 1959, 37817 +, 7376, 4014, 1027, 34273, 5678, 57951, 12097, 26506, 26824, 58683, 35123, 47894, 51593, 46350, 54344 +, 34396, 8503, 21902, 22775, 59984, 17337, 52878, 47601, 55833, 38867, 22553, 24365, 28846, 35081, 2677 +, 43016, 18809, 6691, 20395, 53083, 48721, 18346, 41532, 15228, 45170, 16567, 26703, 9417, 8160, 13053 +, 3761, 42557, 57908, 25663, 41684, 34245, 19353, 34562, 21846, 15186, 49781, 44399, 15904, 18628, 55832 +, 54933, 1644, 14642, 1624, 22039, 44077, 26698, 16737, 1961, 41926, 38259, 18528, 8629, 24028, 26688 +, 58034, 27789, 45597, 32294, 29805, 27282, 6539, 49158, 1844, 4738, 40696, 51626, 25489, 56600, 46606 +, 21322, 27885, 24602, 12316, 29510, 22993, 32745, 32560, 16082, 34706, 14486, 54341, 53234, 59467, 18370 +, 19922, 33853, 22511, 41872, 6147, 52316, 9154, 12687, 17826, 47350, 53777, 34875, 15328, 19266, 31475 +, 1934, 16940, 59361, 26536, 29256, 5223, 25881, 2001, 37783, 41963, 36707, 28621, 12657, 6293, 28088 +, 31027, 2568, 1941, 29890, 44440, 44440, 58559, 53594, 33479, 52737, 40944, 27256, 27612, 56273, 46523 +, 35440, 34559, 3463, 34801, 37448, 9072, 16376, 3329, 47425, 30511, 45293, 485, 35484, 57950, 6778 +, 3572, 5329, 9346, 41865, 11571, 53786, 26305, 10130, 23732, 59785, 39220, 41029, 3393, 6832, 13654 +, 26268, 42272, 48213, 29732, 53425, 2013, 15156, 46153, 5343, 2581, 16664, 26988, 3066, 28500, 1290 +, 9845, 32072, 42971, 55543, 50289, 30894, 25682, 52947, 17377, 25766, 29084, 56597, 6795, 32477, 3429 +, 20449, 58746, 22054, 45015, 4830, 15479, 23380, 19986, 1633, 5075, 58919, 54649, 8415, 1986, 23150 +, 46057, 48183, 31574, 29028, 43726, 58216, 36275, 45760, 27515, 53652, 11527, 56599, 26601, 18322, 5428 +, 30030, 15124, 40526, 28436, 36491, 21708, 43916, 59871, 18046, 21901, 41299, 16966, 52902, 49714, 55304 +, 16052, 35772, 43487, 23979, 41152, 3565, 58547, 17427, 49326, 26062, 47431, 853, 59013, 14032, 55527 +, 4441, 20415, 47003, 21320, 48851, 59846, 43028, 9119, 36070, 1075, 31020, 17369, 54393, 275, 7083 +, 49697, 52679, 42855, 33184, 16658, 24008, 36749, 51557, 17787, 2427, 17619, 5219, 39632, 16632, 55603 +, 35160, 57426, 52370, 58515, 18746, 41222, 58362, 1774, 26693, 34432, 39201, 34066, 51801, 33594, 34341 +, 58884, 23291, 27020, 18092, 32827, 20031, 42100, 45929, 11588, 36239, 48356, 29208, 17810, 27989, 22192 +, 49766, 39501, 19618, 42136, 38016, 38364, 59710, 36378, 16491, 26404, 10810, 55692, 36822, 2611, 5639 +, 11163, 37848, 28930, 38183, 55940, 1758, 34566, 14392, 24039, 46155, 50631, 12395, 51715, 44794, 16736 +, 13907, 34560, 56237, 33526, 16696, 34254, 48242, 52759, 10632, 41085, 19163, 57795, 36778, 55985, 406 +, 42417, 43500, 38254, 47699, 58035, 34194, 25809, 32602, 48586, 49848, 18757, 15570, 38596, 10472, 364 +, 55332, 731, 11276, 51570, 10609, 4324, 2176, 35204, 57083, 49160, 16289, 52598, 46955, 53067, 24935 +, 47362, 11836, 8435, 1968, 35888, 6471, 12515, 38049, 39073, 37453, 4250, 34182, 53023, 42846, 21006 +, 29739, 14530, 21737, 17367, 6100, 8699, 21692, 44628, 43903, 18775, 33789, 192, 47726, 20744, 29612 +, 12661, 44458, 17800, 57449, 46427, 30040, 3920, 35294, 8090, 19345, 12747, 12340, 29879, 42123, 31538 +, 50885, 48214, 46068, 48974, 5582, 28521, 57673, 27274, 13149, 17928, 22401, 46938, 54473, 10127, 44035 +, 24085, 59141, 28493, 18237, 56590, 51272, 48278, 510, 26566, 32720, 56207, 39314, 45060, 26086, 21437 +, 52950, 53323, 9651, 39018, 42297, 51585, 7539, 16323, 18859, 57041, 10603, 17613, 20331, 5076, 4092 +, 4366, 29161, 3233, 9212, 23751, 59823, 484, 12029, 36685, 27051, 44749, 9244, 42717, 6161, 35330 +, 40506, 59111, 28653, 26509, 14481, 47303, 18095, 58373, 39978, 13306, 55414, 50581, 30919, 52097, 55658 +, 35012, 56464, 1171, 38245, 42028, 24922, 14421, 42512, 13303, 27458, 45915, 34404, 36703, 28632, 40565 +, 12033, 45490, 16028, 17039, 12000, 30510, 40694, 30095, 5235, 20672, 19753, 649, 47605, 50673, 29098 +, 19615, 25685, 1914, 20787, 40282, 43942, 22061, 31055, 26455, 35365, 58514, 48722, 9769, 35217, 53707 +, 26687, 23602, 39197, 42715, 40641, 27549, 49577, 57687, 33996, 54812, 54711, 53750, 31813, 42317, 44423 +, 37264, 1932, 46460, 39178, 59071, 3094, 23121, 21133, 34150, 25928, 32850, 9016, 14650, 42619, 44233 +, 44709, 45658, 44187, 259, 4726, 24829, 27808, 54303, 58868, 1805, 25468, 53580, 31907, 33633, 35897 +, 16330, 10897, 14181, 39142, 50076, 13253, 18588, 49549, 34386, 29090, 15477, 7236, 38106, 6479, 26207 +, 58691, 51189, 11866, 42879, 51448, 16592, 44060, 55608, 47247, 42928, 57413, 49067, 36508, 5672, 22701 +, 12405, 22002, 33598, 26587, 37496, 26, 16192, 56085, 49575, 50578, 25175, 5052, 34166, 3282, 47884 +, 373, 1973, 39073, 48591, 21204, 6873, 41535, 5264, 2481, 28783, 48193, 36247, 17850, 24701, 41919 +, 16903, 13459, 40274, 26854, 16398, 54122, 26880, 32590, 50207, 52808, 59520, 51735, 34212, 33686, 55017 +, 22096, 10411, 33342, 37521, 59003, 30899, 20746, 40538, 36163, 23228, 45673, 24356, 35827, 39876, 25410 +, 54098, 33131, 38869, 10724, 59985, 31619, 4847, 3218, 4209, 55054, 56026, 40081, 23141, 6590, 13767 +, 18158, 5039, 24178, 27853, 42560, 59533, 58752, 3307, 16424, 11267, 2887, 2097, 35624, 15066, 18325 +, 1034, 45516, 51457, 16255, 56241, 27794, 24226, 1088, 31012, 4787, 32494, 3390, 44868, 55636, 9981 +, 58635, 50146, 15020, 59165, 54351, 33932, 58699, 29455, 13591, 15123, 40723, 16478, 53572, 52699, 7896 +, 48250, 30085, 53413, 39707, 22692, 49654, 43853, 46918, 27094, 14866, 51705, 35940, 54608, 36573, 7928 +, 4589, 11560, 34427, 55961, 47077, 28778, 6246, 45776, 34586, 19837, 37251, 51661, 12668, 7176, 44360 +, 20564, 31778, 14445, 13977, 47837, 13489, 39983, 31690, 407, 43429, 46556, 52112, 55722, 41165, 5037 +, 3650, 22106, 52949, 38077, 54420, 40026, 43208, 666, 2155, 54146, 20503, 15758, 45807, 33171, 59286 +, 6519, 53736, 31064, 57316, 44065, 18901, 10805, 401, 50592, 11212, 20182, 37148, 39676, 15904, 54665 +, 44713, 55907, 53124, 37662, 33984, 47544, 54040, 53544, 48210, 56195, 47690, 8713, 11954, 9849, 18237 +, 11240, 16368, 48325, 42305, 13684, 32390, 37558, 24489, 9143, 28150, 12053, 5678, 41651, 51729, 21582 +, 12668, 12794, 17489, 5792, 26808, 27826, 53336, 20849, 21370, 41546, 17044, 45413, 26612, 5350, 31614 +, 44849, 52943, 47983, 33174, 11600, 38019, 41916, 49158, 38861, 27412, 17309, 50914, 33090, 35312, 18996 +, 54672, 47980, 31790, 48514, 53773, 58599, 16340, 23461, 55800, 14062, 5008, 49196, 35827, 7972, 54547 +, 7442, 52821, 47490, 31777, 2347, 35442, 46148, 44263, 24600, 25009, 48027, 18261, 52276, 21117, 53573 +, 47624, 52142, 17906, 19414, 40656, 11679, 54365, 33348, 35140, 26517, 47410, 16500, 15714, 23238, 824 +, 10261, 7032, 53645, 34103, 38809, 32344, 9545, 24957, 52960, 10497, 26319, 40987, 28759, 54947, 2105 +, 58684, 42571, 30599, 16590, 38337, 11255, 4621, 9055, 44603, 39762, 35572, 8365, 32614, 51286, 31603 +, 33439, 37899, 14987, 3436, 12002, 53796, 35781, 57899, 55106, 5093, 8397, 57777, 46080, 13508, 52724 +, 24537, 12192, 35295, 55136, 28783, 49984, 42743, 33404, 59039, 27346, 49518, 34612, 35712, 58485, 25898 +, 43667, 8276, 3798, 58655, 11712, 52152, 28803, 23845, 26404, 261, 28938, 11153, 58038, 51371, 24661 +, 50762, 52260, 13205, 2409, 23749, 18340, 52394, 6492, 28097, 51433, 10191, 17615, 26045, 22255, 52452 +, 28296, 42274, 728, 8446, 40929, 12441, 36950, 46085, 12638, 3354, 46346, 17929, 50859, 44385, 45652 +, 15520, 11499, 37912, 5078, 13909, 38013, 23418, 42655, 44506, 51515, 10440, 31049, 45483, 12838, 53304 +, 37935, 41134, 35578, 15016, 25932, 52860, 3809, 2882, 38945, 16447, 42589, 25291, 10728, 33448, 46028 +, 56380, 25321, 57528, 10645, 30399, 47789, 48658, 53817, 30444, 9516, 21685, 17236, 16917, 43520, 30074 +, 10221, 57807, 11208, 22152, 12823, 37140, 15012, 16632, 16375, 30309, 9432, 58964, 31952, 20160, 32412 +, 17981, 52893, 57733, 51861, 39890, 28132, 39650, 4900, 58302, 46446, 14417, 56339, 3682, 31334, 39859 +, 33757, 17908, 37666, 21317, 16412, 50490, 34810, 31424, 43474, 51185, 38085, 52906, 50149, 10037, 49419 +, 58913, 28018, 42312, 56647, 19879, 58554, 1131, 35881, 3454, 35785, 22327, 17871, 32124, 2362, 25558 +, 11983, 36119, 19818, 26002, 33788, 36230, 16492, 8598, 44006, 36318, 59783, 22091, 29225, 26284, 8480 +, 54996, 25198, 36499, 37308, 21845, 32730, 35862, 59328, 44964, 39316, 35114, 43643, 33540, 7238, 46005 +, 35450, 55574, 58476, 31620, 21576, 32265, 7850, 14420, 40863, 51856, 50738, 40647, 50299, 56315, 6931 +, 58779, 51311, 8481, 11630, 28619, 30326, 20713, 40833, 29655, 5677, 56502, 41121, 25672, 6394, 48359 +, 11678, 18196, 43933, 46506, 49816, 5509, 18771, 34018, 56281, 35987, 25874, 47020, 52986, 52525, 43335 +, 36269, 51304, 34647, 44751, 39287, 39618, 51429, 0, 56804, 21084, 42029, 29658, 38557, 7701, 12404 +, 26917, 19379, 30600, 47202, 42238, 56768, 29064, 1009, 30786, 25345, 36996, 56660, 48717, 6334, 25537 +, 32053, 42604, 53193, 43052, 27355, 32480, 59022, 18784, 32480, 55826, 16221, 14509, 1836, 54778, 58563 +, 14240, 58047, 54294, 44840, 45250, 36532, 41608, 50666, 37542, 48746, 16011, 50890, 21758, 4729, 33577 +, 47295, 13134, 16181, 40489, 32538, 43536, 12969, 31560, 38672, 21802, 3739, 54893, 12663, 5575, 49672 +, 11226, 19816, 24071, 5521, 41008, 9321, 42053, 58969, 36339, 55947, 47715, 52351, 23190, 9474, 33432 +, 56767, 33121, 22918, 12948, 13610, 55456, 32836, 2932, 27016, 11508, 24734, 30755, 6402, 37397, 12683 +, 32426, 48624, 32499, 56497, 54145, 49859, 42171, 36198, 25180, 18510, 8498, 49248, 47213, 31688, 35074 +, 56997, 28455, 8195, 19915, 41403, 21806, 15371, 14239, 1090, 42388, 2099, 25824, 49495, 8501, 3221 +, 2178, 17279, 51845, 11029, 13777, 22342, 37241, 32300, 34893, 2421, 50810, 43391, 28021, 14376, 15079 +, 3095, 11373, 43534, 11291, 31289, 1289, 9449, 46660, 51880, 10539, 5400, 53979, 36363, 31248, 38833 +, 15936, 33426, 56112, 44134, 20808, 46241, 6476, 58049, 18541, 41369, 470, 45704, 24760, 28492, 36432 +, 16191, 7939, 47805, 59725, 55582, 55446, 37366, 5031, 42107, 5598, 51922, 23859, 35930, 4637, 55107 +, 14763, 20574, 4886, 10875, 4708, 25694, 33469, 47536, 23743, 28362, 28906, 565, 14066, 30018, 5409 +, 50498, 46210, 49701, 14656, 22287, 45283, 10102, 36006, 50315, 28561, 41604, 18589, 52421, 17534, 23227 +, 23880, 32297, 20153, 5118, 19525, 1213, 30812, 29346, 48749, 30907, 57708, 54007, 7825, 11775, 378 +, 49586, 38625, 22940, 39287, 53281, 45227, 24571, 3384, 21233, 14886, 8297, 2838, 9827, 718, 56724 +, 33054, 951, 5374, 29559, 6069, 24899, 7124, 13234, 54245, 55874, 20493, 51953, 26233, 28318, 40080 +, 2963, 17905, 55058, 25903, 57192, 48339, 11131, 58115, 28075, 8716, 49353, 36373, 47906, 59181, 13443 +, 44631, 8587, 50746, 50005, 38147, 56816, 51256, 45271, 46402, 21853, 17497, 6895, 50158, 20083, 11566 +, 6591, 23046, 29471, 1649, 25302, 3015, 26340, 36433, 1131, 30768, 21501, 50484, 7141, 9408, 49665 +, 56936, 30391, 34605, 47683, 56748, 12752, 20851, 24356, 34375, 43605, 46209, 28225, 50500, 12719, 48308 +, 2066, 19310, 47706, 7889, 57311, 13008, 47257, 23652, 25793, 48388, 54420, 23647, 15224, 37913, 33055 +, 41242, 11201, 39798, 15847, 58884, 12898, 4951, 56087, 37254, 15678, 39692, 59815, 43903, 6545, 48886 +, 8563, 8611, 8197, 32622, 52853, 41860, 45630, 40110, 41864, 47776, 4850, 36284, 11423, 20074, 50549 +, 20830, 37668, 1751, 36980, 53515, 36987, 49878, 58466, 33075, 27132, 50497, 49119, 3299, 34400, 55664 +, 52185, 42964, 40628, 36734, 51938, 33481, 18595, 37568, 49943, 459, 1696, 54793, 13096, 49471, 51219 +, 39997, 10301, 28888, 41748, 23633, 58755, 55088, 13511, 33574, 4515, 16995, 24071, 53634, 20294, 58471 +, 25651, 48832, 17787, 6279, 25566, 9725, 16112, 20513, 23646, 42407, 57325, 1694, 13552, 46773, 51166 +, 4771, 26770, 37819, 10011, 44871, 1453, 8767, 39959, 14964, 42341, 20826, 8312, 42764, 14460, 4958 +, 41235, 40111, 53790, 35375, 22742, 55709, 45100, 15206, 16222, 45098, 57613, 49899, 46793, 11165, 36672 +, 37959, 52289, 39795, 52130, 2300, 1018, 53583, 47419, 17329, 44900, 29760, 38155, 29564, 12524, 52615 +, 34522, 30112, 9079, 28313, 41839, 8173, 374, 26939, 23380, 52948, 48390, 57345, 42848, 35183, 8511 +, 55872, 49494, 37152, 12019, 17976, 39452, 13037, 47912, 26872, 30366, 32812, 32984, 8521, 38728, 21861 +, 37489, 13250, 28325, 22920, 17915, 10164, 31093, 18289, 13455, 30825, 11238, 1845, 28171, 30438, 13380 +, 13034, 26310, 39226, 50186, 38330, 33555, 29638, 27719, 21467, 32862, 58086, 30631, 42199, 42959, 9359 +, 40412, 56800, 22609, 45089, 19720, 40525, 55253, 27166, 35166, 45060, 57991, 46404, 23258, 2514, 16842 +, 12990, 15548, 19505, 28569, 5734, 57835, 2124, 11725, 1906, 23591, 20939, 59992, 54222, 39490, 19304 +, 39933, 56254, 52456, 2542, 41343, 48529, 19419, 36596, 15695, 54586, 58009, 50038, 17342, 21267, 52553 +, 34185, 34257, 44453, 30042, 2826, 26540, 27877, 41302, 14617, 6135, 4893, 11908, 42480, 35467, 51399 +, 1784, 15400, 47653, 54240, 54295, 28997, 42769, 50066, 41945, 34816, 44652, 39954, 1207, 38347, 37573 +, 30112, 48884, 11831, 14565, 18926, 51009, 17457, 23155, 32312, 32074, 29290, 13557, 43983, 11770, 25377 +, 11734, 13554, 40777, 59387, 44147, 11424, 4736, 3268, 1491, 23034, 14437, 22495, 2988, 15644, 842 +, 16914, 45756, 26078, 28745, 321, 45004, 56106, 17779, 8159, 4770, 26205, 37450, 18328, 10188, 49220 +, 43705, 21922, 39127, 834, 57662, 59626, 48611, 2398, 2894, 26454, 25432, 17331, 48949, 4773, 32975 +, 26144, 21687, 18731, 52222, 26784, 55405, 37227, 22890, 49536, 21738, 4013, 15741, 59188, 22341, 25930 +, 24761, 42398, 24204, 3888, 19584, 21866, 3514, 44547, 617, 42760, 11001, 2401, 36444, 36303, 7174 +, 9419, 2447, 5213, 4503, 31021, 31997, 36260, 44600, 31240, 25796, 6339, 35253, 41537, 5527, 33946 +, 43819, 30288, 52696, 8024, 10528, 48632, 6242, 50394, 33180, 6859, 33155, 44181, 9261, 9599, 20484 +, 52787, 55370, 59283, 58001, 59873, 30305, 6350, 12485, 14905, 37590, 38281, 57596, 49195, 56171, 3124 +, 23141, 39990, 9764, 15837, 24366, 56645, 4470, 6961, 47039, 37650, 13820, 56546, 58183, 59433, 6145 +, 18668, 28573, 37868, 54303, 2926, 14093, 24608, 9276, 26579, 15866, 46867, 4860, 13462, 36062, 37383 +, 52938, 35556, 17374, 39055, 51393, 18092, 35700, 32215, 25053, 59091, 46217, 15226, 55638, 20753, 51011 +, 38135, 39421, 19584, 16003, 33724, 22510, 30097, 34685, 31787, 33028, 50551, 55006, 37888, 40365, 7420 +, 51624, 33304, 42976, 8998, 12359, 10722, 3442, 24411, 42937, 28496, 59854, 5507, 20074, 55492, 26260 +, 11085, 9980, 42033, 7022, 2335, 52109, 29532, 32432, 26794, 37671, 41812, 53697, 32677, 19701, 34063 +, 16450, 11325, 7367, 59426, 56675, 56078, 10148, 117, 56841, 29438, 4965, 56695, 34945, 25039, 28540 +, 1205, 12477, 38520, 19590, 19499, 40855, 11699, 49031, 49640, 14846, 3055, 31452, 8543, 12084, 27505 +, 18958, 28534, 15182, 2677, 27961, 48209, 58755, 38109, 24679, 55596, 7547, 29644, 28644, 18844, 31036 +, 57184, 56401, 43513, 35704, 15991, 3012, 52911, 4043, 28395, 42551, 18889, 31450, 14004, 3784, 19887 +, 17861, 22743, 48421, 33044, 25420, 52734, 21253, 528, 30844, 45932, 32476, 14743, 51929, 1120, 9940 +, 22965, 34656, 6341, 42830, 10360, 58685, 45842, 3272, 2728, 14237, 22175, 57969, 22040, 12531, 1753 +, 41927, 30393, 848, 6700, 3437, 2621, 59435, 1042, 39501, 6631, 23327, 48329, 21374, 15256, 49450 +, 7666, 14573, 458, 14008, 57403, 10819, 12693, 19597, 50443, 51773, 10186, 12618, 49742, 32226, 25150 +, 27847, 50505, 31895, 5048, 57206, 11684, 7669, 32993, 12726, 23522, 39624, 12405, 11851, 37350, 4013 +, 37653, 45017, 54938, 38112, 59025, 28693, 25283, 48070, 48290, 15726, 16195, 58477, 4696, 42289, 7055 +, 6198, 10136, 33913, 38093, 51536, 7471, 49777, 35557, 40464, 38856, 59079, 20088, 27613, 47283, 57438 +, 31627, 24936, 18807, 26565, 39400, 54184, 55259, 4683, 42254, 19901, 56761, 34801, 18378, 1458, 17090 +, 1786, 44008, 3579, 12051, 22102, 55115, 19522, 48231, 7025, 59986, 3439, 42456, 56426, 31053, 29739 +, 30216, 39032, 54676, 49024, 5597, 10428, 43208, 37208, 15112, 1815, 57110, 11873, 36616, 51840, 49683 +, 30059, 29978, 33692, 33638, 42029, 32146, 5105, 1551, 20377, 12130, 37889, 169, 54587, 34315, 31222 +, 678, 4532, 10254, 55354, 53556, 52203, 42135, 13116, 29412, 57247, 14931, 2874, 45472, 27900, 54714 +, 35156, 57959, 1045, 45200, 7949, 43074, 17346, 13054, 20978, 14075, 1537, 58867, 14244, 32476, 9535 +, 21818, 33154, 50419, 8424, 4861, 20327, 628, 46996, 33443, 6392, 20595, 24727, 45618, 6067, 52627 +, 40332, 17575, 50586, 17729, 39127, 58535, 804, 32825, 47941, 21782, 46901, 25830, 57001, 37497, 34658 +, 42888, 35668, 7813, 33307, 44092, 49026, 29986, 21072, 12374, 3430, 27464, 32969, 4509, 13082, 15388 +, 57136, 29767, 9316, 24074, 47496, 48443, 58961, 24652, 21269, 23254, 22786, 44522, 49085, 56140, 22019 +, 23743, 39028, 34039, 7908, 48688, 18132, 56934, 18674, 39204, 45660, 58456, 43021, 18629, 39317, 32455 +, 34018, 36453, 38574, 19686, 36879, 2423, 8129, 35840, 27075, 29398, 35447, 49862, 50272, 884, 22354 +, 48644, 24627, 1382, 22683, 8888, 26422, 40815, 42174, 21449, 56372, 27835, 19905, 39393, 22816, 59223 +, 48200, 33186, 12028, 26775, 52872, 25260, 29198, 1002, 37452, 32625, 6752, 12899, 58839, 57025, 13783 +, 21193, 45669, 14763, 58928, 8352, 23651, 25350, 25520, 42177, 46799, 21892, 10012, 43057, 1285, 32829 +, 18632, 25837, 6015, 7012, 52612, 58888, 32272, 58162, 36242, 9725, 7140, 42994, 22624, 5979, 40019 +, 12760, 3525, 2040, 27523, 2453, 10393, 27526, 27803, 35913, 9703, 50955, 34157, 56068, 34012, 11794 +, 28897, 28996, 37631, 11264, 36008, 6596, 46504, 8281, 41110, 22746, 54358, 48250, 5741, 16982, 30582 +, 22112, 29742, 34107, 24153, 33617, 36560, 10898, 37495, 40715, 23163, 47199, 8022, 57320, 43267, 18386 +, 9114, 48516, 47382, 23097, 59780, 23391, 29693, 46285, 8024, 10804, 9031, 2382, 35406, 51124, 55716 +, 5988, 13237, 1811, 40095, 13742, 35428, 53007, 24640, 12924, 10075, 47803, 36475, 18097, 21475, 56094 +, 36484, 30589, 44610, 23866, 53686, 20742, 23609, 59732, 43379, 31633, 10536, 52411, 10367, 22294, 19887 +, 6084, 28283, 33124, 7895, 44730, 46866, 19675, 37738, 47858, 8951, 47813, 35661, 45426, 5910, 57136 +, 41520, 18746, 4077, 2482, 42613, 34116, 23225, 42574, 33848, 6604, 50560, 20736, 35367, 927, 43030 +, 55255, 43363, 47665, 4731, 51258, 32396, 27950, 47286, 10134, 15808, 56237, 34299, 27822, 18016, 16561 +, 1310, 59536, 35308, 5388, 38371, 54273, 15856, 1596, 36847, 49704, 8200, 3759, 46792, 43568, 4687 +, 6174, 15175, 48050, 53840, 19906, 15661, 26236, 24208, 39299, 36370, 40017, 35536, 47021, 7839, 29904 +, 3582, 9149, 29441, 38890, 50889, 44164, 33163, 6745, 45760, 46363, 32801, 30312, 50122, 55945, 50232 +, 31161, 2120, 5407, 55564, 55960, 1666, 11225, 22196, 25874, 50524, 34918, 42243, 2412, 21939, 50082 +, 32317, 1873, 35584, 38110, 40764, 2825, 22274, 50279, 9571, 8034, 12994, 18724, 38346, 3117, 14670 +, 4931, 34278, 16790, 10338, 6194, 12750, 48356, 17419, 11298, 14231, 44295, 22568, 56474, 23060, 20859 +, 22909, 55377, 22732, 34845, 9839, 39848, 37670, 32113, 6480, 23593, 16499, 19474, 42318, 31197, 58943 +, 56988, 36128, 33222, 50130, 22819, 39416, 2880, 11175, 33188, 50530, 1758, 53835, 49450, 34585, 16895 +, 10309, 57494, 48624, 9393, 8691, 58463, 49242, 46361, 6928, 55722, 9955, 59779, 51548, 52273, 7329 +, 50492, 25613, 43457, 66, 15743, 42628, 15834, 54975, 53804, 49022, 45505, 31914, 19210, 11307, 6499 +, 36105, 21616, 40345, 24730, 31009, 49036, 59545, 56603, 35398, 6474, 28677, 21705, 6253, 20226, 50330 +, 13582, 10718, 15943, 33392, 10784, 31686, 52372, 26618, 3013, 46176, 51993, 24870, 54443, 11203, 36177 +, 942, 23660, 57793, 41288, 48390, 5154, 6676, 47936, 38110, 18426, 30762, 6787, 40131, 13367, 3365 +, 30461, 3302, 50435, 22756, 13046, 1219, 30794, 5418, 4190, 33807, 27947, 56183, 58677, 22390, 43738 +, 34854, 23332, 7398, 8999, 40972, 32141, 50506, 47649, 56429, 28616, 42427, 27191, 11755, 22559, 16910 +, 51473, 29372, 20212, 41908, 52129, 33258, 19480, 22923, 38677, 23670, 56731, 6624, 56205, 55408, 5366 +, 16295, 6615, 28698, 23693, 51966, 46023, 55834, 42472, 10024, 52263, 47440, 52451, 55806, 35548, 51362 +, 12717, 27021, 20735, 9281, 45281, 12864, 42540, 4761, 35787, 57569, 4783, 32518, 4193, 988, 4279 +, 9559, 17283, 47246, 14609, 17329, 39212, 36984, 49515, 58037, 23360, 41779, 21829, 15812, 13937, 57377 +, 7174, 3006, 750, 4261, 12288, 46032, 17125, 54828, 50793, 52913, 28749, 55577, 1783, 32942, 32917 +, 42414, 18853, 26553, 6012, 9814, 43882, 21577, 23151, 33397, 19614, 46511, 51528, 41443, 38675, 41818 +, 15173, 22202, 44824, 15923, 26463, 57112, 38307, 43589, 28292, 29101, 12854, 57041, 1030, 50989, 6335 +, 10299, 9756, 1540, 36852, 15768, 11355, 20734, 37345, 34506, 30484, 33311, 21017, 22012, 51107, 36045 +, 3830, 6280, 58247, 48655, 58555, 24710, 22119, 36863, 8299, 26764, 42316, 57505, 157, 19698, 48495 +, 42845, 29997, 58251, 44385, 6850, 50371, 32092, 3936, 4069, 42950, 34420, 13732, 40320, 32785, 4839 +, 16365, 36615, 47471, 14612, 1622, 22379, 39322, 94, 59242, 23974, 3210, 17910, 21479, 3367, 37608 +, 46326, 22564, 43957, 20929, 6950, 27159, 11301, 39042, 31096, 51722, 21993, 41868, 5454, 2313, 14653 +, 10294, 18678, 27621, 34117, 9642, 5595, 56496, 48964, 5689, 32090, 12938, 45251, 50000, 10770, 24971 +, 3960, 57096, 47535, 47918, 18026, 54485, 51429, 5679, 9880, 22525, 57401, 8225, 40746, 2855, 46890 +, 31751, 49501, 41920, 59372, 23619, 51562, 41320, 20115, 16878, 23361, 28558, 29817, 8613, 18558, 16939 +, 33584, 58871, 14035, 57471, 23141, 8413, 51957, 14570, 50444, 38189, 13448, 24197, 46414, 54194, 27053 +, 9656, 2297, 52906, 51576, 38022, 16525, 19490, 19342, 12993, 36368, 42703, 41551, 42537, 27668, 36461 +, 59476, 37604, 11684, 49864, 35076, 34825, 34629, 3385, 49396, 25074, 41574, 2844, 49271, 4340, 33390 +, 52676, 50348, 35687, 21935, 41924, 50061, 38460, 37766, 9403, 27805, 14134, 28459, 45708, 56672, 32479 +, 58522, 32500, 10084, 10206, 22364, 21512, 45032, 56994, 24897, 10780, 58420, 42823, 13624, 24043, 23515 +, 23366, 53072, 13863, 35405, 15007, 32139, 25467, 29819, 9905, 11222, 33977, 24039, 39681, 56037, 57063 +, 48513, 54559, 29564, 58597, 4766, 28280, 56461, 26150, 1626, 21358, 36930, 36398, 40533, 26906, 442 +, 4048, 50272, 29866, 17911, 2029, 21225, 26402, 27496, 27396, 36307, 38719, 1373, 36698, 54752, 57411 +, 33762, 43265, 28322, 39678, 18214, 33088, 7958, 14675, 59238, 45937, 12385, 12520, 22335, 52918, 39426 +, 59129, 33318, 29698, 28995, 27581, 31728, 26572, 53983, 35576, 53969, 30290, 50647, 31694, 6989, 21752 +, 5457, 17103, 5017, 33780, 33133, 59584, 6868, 17443, 50611, 42459, 3380, 39349, 31331, 25716, 8619 +, 10758, 1197, 41938, 16808, 6545, 9519, 24888, 33117, 3503, 465, 3438, 10145, 27464, 35133, 53486 +, 49216, 40590, 46941, 30586, 14370, 20074, 30170, 57591, 37518, 57133, 16402, 17250, 36482, 47733, 19318 +, 45102, 34843, 20516, 27040, 51652, 27061, 12911, 16540, 36530, 52766, 53357, 39969, 2912, 20822, 51454 +, 56398, 10038, 8396, 43340, 40624, 59119, 39766, 47146, 33062, 17284, 44280, 49464, 10887, 20762, 13549 +, 30205, 42216, 48393, 27073, 45608, 16397, 30486, 58520, 32937, 7017, 51286, 26295, 23338, 30550, 47117 +, 51144, 26949, 33507, 59540, 46641, 14132, 58659, 26407, 1278, 31721, 20044, 21910, 57537, 30931, 19025 +, 47439, 1136, 1241, 35832, 28210, 46850, 52229, 58696, 21722, 1518, 42065, 49360, 4165, 41755, 19911 +, 51282, 32899, 46860, 1142, 32440, 9853, 15274, 7451, 36260, 52904, 39173, 32656, 14815, 13062, 3587 +, 33840, 501, 41076, 11433, 12685, 45638, 58283, 41266, 20686, 56357, 19137, 2752, 45718, 23302, 44507 +, 5629, 14585, 17407, 28841, 52079, 26199, 38694, 7353, 33650, 51306, 36609, 49175, 23963, 27776, 38590 +, 3902, 37968, 39091, 44978, 49402, 28129, 30616, 24037, 9395, 51303, 20395, 28532, 30407, 42465, 51835 +, 51266, 48094, 42772, 8673, 53287, 34851, 11224, 8333, 18556, 21227, 59639, 31517, 10402, 59954, 59294 +, 48992, 3857, 37262, 4436, 25187, 3016, 32565, 32156, 3406, 18312, 23459, 23801, 23197, 30218, 42618 +, 51384, 21484, 30712, 34156, 6510, 23999, 45359, 17734, 32332, 40267, 38961, 8323, 11784, 25716, 44630 +, 47430, 51060, 24839, 1045, 55496, 50026, 4061, 4413, 22182, 7467, 22726, 21993, 7620, 45923, 28563 +, 50238, 37307, 50048, 57302, 47815, 56558, 57653, 9526, 50644, 6337, 49793, 5958, 51013, 37929, 31674 +, 35643, 25360, 59086, 482, 26405, 54583, 26860, 6818, 58996, 25395, 14286, 21722, 47388, 58258, 43997 +, 15952, 48497, 21304, 42352, 22151, 45471, 15262, 19805, 54997, 5906, 2494, 21142, 48216, 53507, 59072 +, 19890, 29150, 784, 18977, 5984, 27189, 49912, 32845, 10359, 25260, 58240, 24645, 46983, 21980, 59256 +, 7332, 14284, 24105, 4989, 32988, 46256, 50460, 48250, 42413, 21810, 54157, 44908, 42952, 42373, 38415 +, 42024, 38616, 7566, 19160, 33945, 49902, 46349, 209, 22747, 56709, 25469, 57339, 57706, 48804, 55672 +, 56962, 56137, 46308, 57419, 37478, 19297, 43676, 27938, 7547, 26089, 26100, 38056, 10997, 9053, 56782 +, 49413, 27429, 35398, 33331, 46590, 45695, 59585, 9291, 45904, 22333, 42352, 11373, 56024, 16411, 36530 +, 28048, 49725, 32667, 50709, 47145, 10145, 10006, 30821, 14435, 53905, 33262, 40536, 31962, 44260, 25941 +, 5096, 10025, 53370, 16846, 19708, 16312, 2541, 19293, 25604, 24797, 17978, 44308, 12522, 50355, 719 +, 49052, 54755, 50445, 58071, 45464, 37590, 44568, 55470, 44763, 59004, 25728, 18025, 15892, 34042, 38637 +, 41833, 39138, 25014, 11555, 55984, 44722, 4220, 58525, 40368, 29824, 59674, 34698, 50484, 12196, 25053 +, 51204, 37601, 56161, 41649, 35672, 41625, 55591, 20241, 13448, 40354, 55597, 39176, 58379, 47841, 13218 +, 13369, 6026, 52356, 38383, 17581, 48340, 59458, 21801, 23217, 39826, 27977, 22891, 50876, 18462, 11439 +, 15930, 46018, 49040, 12091, 27667, 1065, 30068, 59610, 57658, 43516, 39964, 29607, 22692, 14695, 17448 +, 12262, 4416, 23474, 4618, 42800, 17407, 29310, 42258, 15561, 52527, 58436, 43538, 51770, 49312, 38352 +, 39562, 41594, 24370, 4954, 30037, 28389, 6019, 36458, 27999, 40029, 19974, 44315, 9636, 19019, 35363 +, 27084, 31281, 39779, 26910, 12252, 58931, 44318, 17914, 17541, 59879, 46794, 15977, 19769, 38564, 41642 +, 58122, 54478, 59588, 58844, 59433, 5978, 27234, 5452, 42436, 31585, 21834, 2410, 52253, 31470, 57781 +, 3968, 34907, 29063, 43747, 1817, 17667, 19031, 46135, 35581, 36572, 22366, 58727, 28902, 42136, 13644 +, 46896, 16610, 8122, 46484, 15454, 7555, 52462, 42688, 49360, 34898, 50626, 11194, 13661, 42879, 19016 +, 11442, 46847, 53923, 16857, 6946, 55741, 10876, 25977, 18228, 22810, 38902, 16947, 21537, 7804, 59083 +, 35181, 54700, 52045, 19656, 41184, 7499, 3563, 9999, 26540, 52923, 21249, 17166, 40469, 34910, 45 +, 59486, 22705, 46892, 29761, 39562, 30190, 25502, 26791, 56168, 20083, 49601, 35070, 37030, 47490, 19226 +, 12465, 22672, 13926, 4510, 18680, 31462, 12009, 22243, 17813, 38549, 15167, 39063, 32067, 31988, 50325 +, 32112, 7826, 13030, 55356, 37588, 28945, 25547, 39442, 55736, 21715, 59525, 21689, 33137, 12907, 9179 +, 52363, 1724, 8203, 42641, 42586, 26883, 50455, 54596, 49127, 8269, 9497, 40646, 23684, 41565, 12634 +, 14009, 50029, 20461, 3392, 45386, 34401, 8689, 47285, 13843, 40777, 9000, 49721, 38818, 18489, 38980 +, 47997, 47204, 40705, 56201, 29845, 23291, 59436, 56652, 54239, 48563, 41273, 40089, 5561, 4957, 58006 +, 54548, 55319, 24387, 51361, 35063, 46125, 25762, 20104, 33410, 15957, 881, 18762, 5678, 39699, 37251 +, 21011, 4048, 24455, 1716, 36601, 30652, 1359, 36038, 3657, 31951, 953, 44930, 48392, 6515, 49888 +, 22750, 1063, 21559, 47137, 52424, 56622, 33263, 54538, 16726, 6673, 10495, 53959, 25436, 16174, 10010 +, 39039, 37185, 14058, 39847, 15253, 27012, 46851, 52964, 3050, 50508, 1267, 40355, 35439, 49659, 46870 +, 1679, 48761, 24285, 23238, 12251, 53061, 56212, 45514, 47599, 49290, 28539, 58095, 19601, 30327, 50621 +, 29611, 9367, 4158, 20021, 25566, 55763, 47033, 12417, 48727, 50083, 2926, 49995, 30439, 14717, 16006 +, 53661, 16396, 41120, 54299, 15986, 53371, 47360, 48550, 38885, 11312, 14192, 43776, 9407, 33793, 50456 +, 36380, 3404, 59823, 40538, 23425, 1741, 36301, 10459, 14158, 1380, 36894, 53436, 27727, 43685, 8153 +, 20086, 13699, 901, 1206, 7998, 53239, 54577, 31710, 41789, 9814, 43022, 55981, 53590, 28781, 6126 +, 44046, 41513, 9530, 20221, 22051, 9308, 21962, 34704, 19767, 12473, 36085, 33013, 5909, 3812, 16699 +, 50415, 23898, 30398, 27668, 25104, 14748, 20908, 56033, 46458, 39049, 5847, 5833, 11383, 35790, 34614 +, 17509, 56188, 16128, 3392, 16410, 14531, 12700, 14724, 49236, 8819, 3549, 1673, 41832, 45811, 41837 +, 34883, 36226, 5736, 5281, 40246, 7192, 20029, 1154, 3226, 42840, 16556, 45425, 48673, 27939, 21215 +, 59639, 21800, 17404, 52119, 25192, 10166, 6651, 14244, 1242, 32239, 23063, 4792, 33912, 41248, 50603 +, 15749, 16131, 3181, 57837, 57765, 43427, 41382, 54146, 20934, 20960, 36986, 37490, 6385, 2011, 41781 +, 3953, 1651, 39933, 57709, 53770, 41478, 7875, 36773, 55722, 9117, 45364, 55138, 13909, 55628, 36386 +, 40864, 47730, 28869, 44045, 45567, 26634, 3825, 3301, 57133, 24759, 24261, 10471, 38601, 6999, 12483 +, 56734, 10952, 50486, 36667, 8661, 44256, 18145, 52888, 57382, 50220, 2005, 42746, 45358, 52267, 38375 +, 21744, 33131, 26105, 26965, 53529, 48024, 53600, 57354, 51326, 27085, 58465, 51939, 37556, 13418, 58938 +, 50039, 10152, 46242, 40525, 46819, 31255, 1134, 41317, 24143, 58516, 31537, 2501, 17614, 16895, 54768 +, 55989, 14991, 4251, 22094, 41956, 34132, 46471, 11908, 7838, 37797, 38993, 42655, 29736, 16550, 56073 +, 5027, 6589, 6225, 51269, 23467, 29397, 58877, 24601, 10714, 23020, 59469, 18603, 1873, 17083, 35498 +, 32993, 13073, 26841, 37245, 11519, 45149, 47729, 57990, 57058, 55568, 12139, 36051, 38223, 18228, 28953 +, 34297, 23255, 11895, 16874, 50876, 35362, 46271, 49753, 36315, 33337, 49126, 35784, 51940, 50999, 52867 +, 3790, 23993, 42292, 30631, 37590, 53812, 15781, 25319, 28154, 49191, 57239, 40294, 1594, 11815, 58522 +, 30548, 22464, 58129, 42443, 39338, 49005, 54157, 1962, 15111, 30472, 35299, 40589, 42608, 3592, 31588 +, 35475, 7382, 31933, 17768, 14366, 9523, 47932, 6499, 11195, 16086, 55690, 44786, 32732, 57284, 56601 +, 7606, 4184, 19065, 5735, 22979, 34756, 31093, 17136, 36718, 46204, 23960, 48369, 3145, 6568, 51961 +, 34733, 42044, 59344, 43019, 36164, 50062, 28894, 24096, 56561, 40089, 16534, 28603, 1228, 49267, 25887 +, 57829, 56873, 6424, 53247, 38961, 29403, 28003, 10054, 46540, 41073, 32610, 10500, 29442, 35755, 53421 +, 21404, 46840, 35465, 57100, 29859, 47981, 47162, 58754, 48429, 20075, 15195, 4963, 48678, 16423, 54230 +, 50917, 50605, 27456, 57341, 43852, 6417, 26745, 11855, 16471, 13285, 29280, 25433, 137, 58722, 1188 +, 53558, 56478, 48028, 5375, 53578, 17888, 29708, 17092, 52994, 18137, 37167, 8189, 23101, 2197, 24613 +, 53683, 53115, 15218, 57491, 50456, 35422, 3908, 53553, 23629, 56731, 43190, 52909, 58516, 43328, 51631 +, 59704, 13238, 48110, 24085, 54966, 18040, 41973, 24674, 35133, 11319, 42812, 48652, 19508, 42265, 50850 +, 20473, 35948, 20317, 12043, 33440, 47125, 47465, 13700, 40679, 11094, 46784, 23869, 40355, 45300, 43549 +, 8339, 45005, 33140, 56449, 9090, 28106, 50841, 27415, 29132, 2326, 38734, 11944, 50979, 34594, 54209 +, 18181, 55068, 6510, 14850, 43463, 16302, 1975, 7281, 30002, 19006, 54727, 53138, 42876, 35083, 38439 +, 26425, 43422, 59796, 59565, 16223, 45238, 4023, 7064, 12653, 33156, 9391, 27739, 21452, 36722, 2333 +, 15662, 31255, 33753, 58524, 46105, 53569, 14826, 24432, 850, 21180, 43439, 55577, 14319, 2667, 7012 +, 52758, 29092, 50434, 28906, 5010, 43009, 14144, 9033, 26426, 26797, 18541, 12169, 30888, 39994, 48891 +, 9573, 32008, 56498, 19679, 30532, 18955, 13248, 21710, 43387, 50450, 42890, 3178, 46027, 57209, 5845 +, 29392, 26319, 11290, 56178, 55225, 52652, 39188, 9369, 1685, 41966, 12518, 56579, 54135, 19758, 36573 +, 19378, 29332, 8581, 15876, 49011, 15465, 11183, 38611, 37175, 30922, 29061, 20065, 34101, 51440, 53627 +, 16298, 20832, 19946, 27588, 17011, 51524, 20240, 32551, 893, 58278, 14517, 49764, 54857, 8652, 9522 +, 7782, 28030, 38854, 16363, 20258, 4217, 8180, 31441, 42828, 45355, 2363, 11889, 5420, 12816, 3330 +, 59047, 29115, 24162, 55346, 56703, 17525, 46870, 53296, 26428, 24115, 51574, 40945, 13879, 22783, 25949 +, 23402, 30565, 30331, 38608, 23280, 50589, 42826, 31460, 58382, 25654, 53167, 746, 13896, 34939, 13562 +, 17226, 33987, 19029, 17740, 5685, 15733, 11618, 52555, 45381, 38046, 53022, 13307, 55344, 6902, 12442 +, 21293, 6656, 19359, 51625, 45264, 42639, 18566, 4442, 50451, 16949, 6449, 19970, 54047, 20345, 54909 +, 43961, 13923, 5248, 2991, 8015, 10933, 55076, 55985, 39840, 40457, 10384, 32863, 30116, 5728, 16117 +, 42558, 3373, 59125, 1917, 31350, 20741, 20908, 49917, 25184, 47711, 43218, 7985, 7681, 37265, 28330 +, 2590, 21226, 18605, 7839, 24217, 2972, 18772, 55645, 58958, 34965, 36102, 9342, 44180, 6218, 51422 +, 297, 48776, 54795, 59422, 27045, 2498, 20163, 47953, 28767, 21699, 35664, 11985, 29684, 43345, 25602 +, 34366, 45936, 23180, 52971, 30127, 23750, 32296, 25251, 19395, 7606, 216, 31850, 53300, 44396, 14420 +, 44722, 21045, 3197, 15869, 56819, 30242, 18367, 53335, 54548, 23486, 15034, 30212, 11823, 44719, 13558 +, 13777, 55437, 35846, 36958, 24761, 5973, 37060, 57057, 31224, 32807, 4663, 7793, 4657, 57963, 28541 +, 19078, 19037, 25939, 58627, 34906, 22758, 5221, 29626, 16093, 59769, 29464, 7480, 29982, 41288, 28551 +, 19892, 55065, 23988, 55738, 8375, 48749, 38063, 45435, 45806, 45639, 18243, 26821, 53432, 59252, 1136 +, 58326, 18330, 20173, 24265, 16957, 31432, 23375, 58531, 1058, 39469, 58300, 30522, 23301, 28282, 48162 +, 51852, 48174, 43228, 15840, 20264, 51603, 40942, 58327, 13391, 3100, 43967, 7986, 29922, 13751, 7238 +, 31058, 48429, 1921, 27584, 12694, 18878, 59016, 36070, 53761, 74, 51891, 52062, 6948, 15192, 20344 +, 55111, 43396, 44871, 14691, 35588, 5135, 6294, 16530, 3463, 56037, 19631, 23782, 4023, 25905, 13885 +, 11262, 33315, 2315, 13183, 899, 51361, 8413, 59915, 27431, 2175, 36341, 55674, 54237, 43290, 47218 +, 50933, 14753, 30614, 12156, 29444, 42555, 17292, 12090, 59085, 57107, 8128, 55068, 20889, 12151, 20973 +, 11126, 59765, 54289, 13441, 49300, 31540, 4803, 57714, 31456, 8586, 36241, 7797, 4261, 6830, 27439 +, 27831, 34115, 42192, 34798, 46272, 47988, 17353, 3564, 79, 52790, 37023, 8207, 47859, 34264, 56710 +, 8832, 45390, 56476, 39473, 35184, 22128, 11014, 39987, 56194, 18822, 48573, 32435, 26619, 29186, 15617 +, 30411, 33370, 26085, 48955, 8168, 12357, 36944, 1873, 52273, 13375, 54663, 29296, 21582, 42522, 3560 +, 54644, 27707, 25302, 27472, 7180, 486, 49601, 54546, 40473, 45795, 13368, 5399, 54583, 16340, 10937 +, 46552, 23103, 20659, 12637, 12058, 5179, 24994, 25354, 7052, 53619, 38729, 38068, 22915, 36663, 56942 +, 2827, 31308, 24649, 28130, 58780, 8182, 28616, 24733, 39080, 45442, 10529, 52449, 27193, 41464, 45141 +, 14482, 28016, 8244, 35142, 40654, 56654, 40321, 42000, 22009, 23726, 35620, 738, 1794, 34887, 37402 +, 58736, 37715, 8710, 59738, 5845, 43842, 7920, 10813, 8576, 47000, 32607, 55457, 15801, 59800, 36921 +, 37294, 14283, 41289, 45538, 49425, 21943, 42193, 6098, 40296, 4202, 29824, 15916, 41292, 7970, 50803 +, 18694, 43059, 4870, 3756, 42797, 47067, 23951, 27069, 57881, 8879, 50421, 30488, 4336, 42575, 6641 +, 17609, 19869, 20924, 58898, 5408, 46701, 57194, 23953, 52799, 37490, 4507, 58976, 29758, 45799, 43298 +, 56913, 40846, 26357, 38136, 20954, 45506, 25203, 44905, 12575, 23084, 30136, 39349, 29925, 34472, 21924 +, 36566, 28433, 41793, 33842, 27332, 23553, 20543, 878, 47506, 49694, 14720, 28365, 25022, 44478, 14165 +, 8321, 17743, 55011, 34678, 55879, 52317, 20185, 57435, 37223, 9112, 56871, 7359, 48461, 26796, 18184 +, 46737, 39714, 46617, 28531, 49908, 50301, 28436, 10451, 51179, 52295, 36498, 5899, 20660, 1520, 26729 +, 34825, 9841, 44473, 6188, 20872, 16704, 58506, 17409, 50491, 12081, 26521, 47363, 55792, 51335, 50511 +, 50328, 38072, 6578, 36946, 42955, 56486, 3599, 11392, 43290, 54779, 3687, 19788, 678, 24347, 21308 +, 3760, 35525, 7502, 24585, 41713, 28374, 41289, 16571, 45783, 8133, 28652, 48656, 55496, 797, 39991 +, 46007, 51125, 18064, 52585, 4423, 1019, 49072, 8023, 48763, 32362, 39154, 52450, 28502, 16184, 53150 +, 26162, 19944, 28675, 33664, 44529, 10388, 38390, 2171, 26960, 525, 10304, 31964, 25534, 5800, 9113 +, 5525, 28159, 239, 59941, 57097, 41014, 37313, 22521, 25389, 2428, 31235, 4543, 54879, 59737, 20728 +, 48029, 25899, 40672, 16704, 35916, 1554, 3444, 50658, 3725, 6756, 27536, 14029, 15073, 53070, 56181 +, 24186, 34947, 692, 777, 11241, 57789, 41792, 24906, 20310, 7181, 27334, 51545, 48077, 22213, 27634 +, 45157, 46594, 29886, 2181, 39650, 42154, 3735, 19447, 32812, 7460, 26203, 36700, 57841, 41276, 29770 +, 30374, 41815, 41070, 31067, 42592, 52311, 28856, 24384, 53569, 25519, 7918, 20903, 17064, 55995, 19469 +, 21051, 41152, 6063, 50937, 43333, 45714, 33091, 23421, 41513, 42255, 30881, 7716, 18956, 5075, 25345 +, 25078, 35449, 7160, 6148, 6516, 49752, 34811, 35373, 50489, 28380, 37244, 58407, 49284, 54308, 30754 +, 8753, 51711, 48258, 51168, 42648, 7943, 13234, 15739, 31364, 54747, 57995, 38598, 38816, 53303, 43673 +, 4161, 18381, 19122, 11321, 882, 1991, 37425, 35693, 13716, 27914, 40426, 50960, 2673, 6062, 21620 +, 33427, 51167, 13332, 21685, 18687, 55980, 29629, 31922, 48072, 37345, 3021, 22419, 15943, 41837, 15722 +, 59616, 45998, 10455, 55091, 33671, 11337, 57082, 11097, 23383, 10798, 15363, 40161, 1758, 18037, 46223 +, 23378, 51464, 13742, 36710, 49502, 32429, 9043, 55483, 40703, 57115, 32828, 43725, 55886, 48772, 25562 +, 47960, 48388, 11561, 58415, 19831, 21584, 46105, 16913, 32681, 9488, 27711, 48045, 26001, 5821, 42434 +, 12224, 29200, 10250, 2318, 42262, 59752, 34747, 51305, 31587, 15451, 24772, 4416, 35528, 57010, 29540 +, 1090, 44970, 17928, 49003, 43386, 14112, 10588, 29491, 31025, 43269, 15331, 35089, 7666, 41332, 40910 +, 50100, 29908, 46462, 36703, 8578, 28725, 36455, 19677, 56382, 8043, 11480, 57507, 48811, 47008, 54517 +, 18351, 48099, 39488, 12631, 37102, 59226, 26743, 47690, 5069, 57769, 7312, 56752, 32858, 51330, 14436 +, 50120, 17783, 20696, 36583, 54486, 29274, 5308, 30941, 48951, 38042, 15336, 432, 35549, 4147, 47440 +, 6419, 58850, 11891, 22259, 11482, 48994, 57837, 38225, 13036, 2906, 12346, 20348, 36010, 21556, 11679 +, 50446, 11677, 29462, 11142, 48260, 23948, 16768, 29920, 31241, 5719, 7962, 22930, 42503, 19864, 27077 +, 29944, 26283, 25928, 41835, 48542, 13762, 7181, 46379, 51987, 20218, 25637, 40686, 16918, 1647, 2242 +, 28597, 28445, 13919, 34411, 15939, 38531, 34711, 32707, 8451, 5953, 14778, 16414, 28883, 57282, 36278 +, 32312, 3578, 38913, 34592, 21765, 27455, 48354, 28947, 50186, 16694, 25517, 15823, 33732, 42435, 53822 +, 35974, 47385, 22267, 26246, 21796, 38206, 4777, 32860, 47265, 13229, 15165, 2043, 5995, 20400, 59325 +, 42273, 29064, 39255, 21186, 3657, 1021, 24993, 28363, 29968, 51531, 21409, 31837, 7354, 55141, 14272 +, 37528, 31116, 1657, 36147, 33714, 59806, 50705, 38491, 32666, 37970, 28072, 24183, 16365, 34067, 44583 +, 52043, 52692, 13647, 31298, 50230, 53656, 32319, 15223, 22020, 38639, 6754, 19781, 10476, 50460, 14923 +, 1101, 4340, 22391, 2758, 40487, 56105, 38916, 31192, 10948, 11582, 45514, 39021, 35765, 1880, 13088 +, 56700, 53923, 42133, 10348, 25221, 32363, 4004, 33893, 23939, 2376, 48884, 30693, 22158, 35713, 57506 +, 37081, 36814, 1846, 35824, 15924, 18686, 31929, 54841, 49878, 42877, 42775, 35393, 21898, 54893, 13625 +, 11339, 51593, 7548, 53472, 1941, 9121, 25835, 42298, 19366, 49774, 44674, 8251, 56820, 43184, 20316 +, 30678, 56617, 57130, 8876, 32441, 49406, 27562, 4370, 44247, 53793, 23600, 27023, 5538, 45498, 58268 +, 19163, 33189, 49861, 3063, 26661, 28155, 12184, 28849, 10453, 7903, 54975, 31479, 52506, 28147, 14664 +, 12822, 58825, 11281, 46304, 44054, 20075, 35710, 11616, 24445, 56310, 5409, 48045, 23333, 10947, 9896 +, 57953, 6462, 43085, 47814, 9525, 46099, 15969, 58062, 51300, 2774, 5965, 22627, 10606, 58471, 50775 +, 25270, 47645, 25952, 12903, 33949, 10006, 32978, 46011, 57975, 33776, 42321, 39736, 58173, 42006, 27036 +, 8069, 39959, 33498, 27507, 27774, 43024, 49958, 20095, 17438, 41258, 22870, 59755, 3885, 33476, 34578 +, 31012, 35098, 22223, 33317, 24353, 32524, 43323, 33684, 18535, 17650, 43812, 857, 57387, 41985, 42863 +, 24423, 26407, 22823, 57921, 30266, 26949, 17297, 20224, 47044, 11087, 37834, 46266, 10842, 18071, 56094 +, 45420, 49084, 7544, 7643, 22401, 31898, 40167, 42076, 41934, 35055, 36079, 25746, 35912, 33466, 44083 +, 55127, 34241, 10490, 54302, 8514, 40756, 21251, 25812, 37332, 44648, 36899, 15166, 30914, 24094, 33238 +, 3361, 9514, 58674, 10905, 53510, 57427, 19155, 10029, 15855, 1089, 45084, 51934, 3187, 57348, 1752 +, 47271, 52476, 35993, 34113, 23130, 44508, 51222, 20734, 46672, 4906, 5382, 59923, 20073, 12648, 24017 +, 29663, 16009, 33532, 4689, 3267, 27042, 2116, 22422, 37071, 54323, 23512, 58508, 46258, 3051, 55856 +, 24362, 26674, 24684, 36708, 37140, 47815, 21216, 28362, 44901, 44240, 33268, 50283, 44163, 29693, 39283 +, 8181, 59356, 55293, 18065, 4045, 34912, 45107, 42513, 57334, 58530, 36837, 57198, 33390, 59447, 250 +, 29247, 161, 26924, 30283, 36869, 4064, 54450, 58085, 8778, 39351, 18677, 18399, 5986, 2841, 48092 +, 45270, 11022, 23801, 16915, 5439, 4198, 51827, 26898, 23064, 49161, 25428, 59901, 46360, 35171, 35700 +, 22962, 4418, 35861, 49886, 11053, 49083, 30303, 5504, 23520, 15433, 21207, 42198, 33832, 27194, 45039 +, 58277, 12464, 32413, 58430, 5731, 37852, 2628, 57558, 4750, 25692, 46719, 6530, 1945, 9431, 41701 +, 13997, 32393, 22471, 26211, 58632, 33525, 15294, 5287, 15381, 38814, 20720, 36588, 21012, 30905, 40134 +, 42403, 5534, 28950, 14816, 3964, 34681, 52668, 42944, 32239, 33770, 44989, 55311, 40301, 23286, 41094 +, 58354, 37284, 13488, 20826, 39847, 48472, 54351, 55141, 30111, 46084, 10307, 27183, 59024, 7672, 58088 +, 39159, 50075, 39974, 8109, 4892, 20290, 42791, 33912, 3235, 51382, 44035, 24576, 46693, 24336, 47862 +, 27788, 22690, 1498, 17628, 43516, 41345, 42452, 14219, 12838, 12563, 36655, 23146, 39746, 35680, 30818 +, 14187, 51191, 57245, 30513, 59300, 38489, 50804, 18443, 12402, 54039, 9826, 56437, 54967, 32871, 57125 +, 42829, 37011, 56167, 44328, 30991, 16036, 2025, 13443, 6607, 14864, 2358, 43263, 14362, 18457, 18943 +, 21532, 32644, 46486, 18777, 39509, 45786, 57267, 30313, 4230, 46021, 704, 50408, 18810, 55671, 23279 +, 52287, 38501, 36643, 48454, 59181, 7634, 4490, 1206, 57430, 11098, 52422, 59788, 54361, 6784, 18245 +, 49656, 28316, 27241, 36142, 23446, 6751, 58280, 20713, 13416, 38862, 43086, 14121, 29270, 38248, 9792 +, 28902, 30535, 24645, 5545, 18989, 178, 49531, 23480, 37737, 46961, 10930, 30159, 23102, 41643, 13296 +, 17699, 31299, 41612, 21293, 43793, 41410, 28044, 42073, 38475, 17812, 57288, 21561, 31933, 2910, 59809 +, 18078, 31812, 6696, 19075, 13709, 25686, 19254, 39593, 25518, 56991, 26554, 36448, 3502, 26008, 18091 +, 16798, 43708, 25742, 34763, 5001, 45887, 16173, 9397, 4312, 54649, 27209, 1600, 52562, 35495, 4511 +, 28724, 53573, 12675, 35420, 49000, 26385, 1106, 8254, 42330, 2976, 41597, 45236, 39424, 21452, 11245 +, 33867, 38250, 54953, 35961, 13013, 36306, 21848, 5539, 45703, 2513, 188, 49264, 4113, 29102, 24759 +, 44976, 57826, 54684, 57652, 33247, 43685, 389, 34353, 28291, 42719, 37330, 46241, 27955, 53106, 7693 +, 15552, 3326, 45943, 10505, 39287, 35309, 23163, 37488, 40848, 45218, 40001, 17388, 34483, 20466, 46490 +, 35594, 41795, 44317, 6631, 39447, 17564, 50316, 16188, 28269, 54959, 35259, 41951, 41200, 39566, 35058 +, 48893, 55119, 14736, 11189, 41976, 30375, 46498, 5140, 7863, 3698, 50358, 24216, 57438, 1193, 21035 +, 43928, 13140, 2830, 4597, 19771, 18629, 58513, 10087, 34817, 3135, 41398, 46428, 45086, 22599, 25994 +, 56496, 47844, 21113, 11232, 59033, 3090, 41608, 45531, 8230, 25823, 25581, 34940, 26392, 23019, 12486 +, 47427, 43300, 25626, 26609, 47897, 45397, 45238, 22763, 31836, 56407, 25898, 13234, 42835, 47336, 35833 +, 8829, 43833, 30, 29943, 31417, 59063, 9385, 49377, 44595, 53967, 51553, 46528, 28907, 17945, 9548 +, 41393, 41724, 52848, 43371, 8333, 17097, 28768, 53571, 39860, 604, 26330, 42110, 13839, 9165, 29447 +, 26024, 54346, 49632, 26054, 641, 21049, 25118, 10026, 46779, 46065, 3993, 38332, 8945, 9253, 56277 +, 18493, 26998, 14353, 47693, 10370, 22686, 4791, 39138, 52609, 21003, 16095, 18939, 3114, 6286, 4456 +, 32561, 32310, 58802, 22193, 34717, 59444, 19594, 36187, 9470, 6373, 58604, 49816, 21057, 7549, 35421 +, 53686, 2395, 2419, 8039, 50088, 49141, 30725, 54879, 4632, 59686, 15883, 20727, 18625, 18997, 27013 +, 59433, 27910, 35675, 58236, 50103, 46744, 34032, 46049, 59283, 19854, 28775, 57887, 9670, 49832, 41789 +, 21443, 43519, 44184, 23863, 51558, 34272, 49356, 58636, 5504, 53988, 58322, 21387, 14715, 53300, 16736 +, 18080, 52733, 44646, 53756, 27321, 11101, 40500, 1353, 33502, 16136, 57560, 2277, 14023, 43582, 52110 +, 32164, 5026, 11981, 16348, 5241, 3539, 26973, 54597, 2175, 32477, 48586, 36850, 30216, 3301, 30150 +, 23304, 21382, 59235, 7950, 51490, 26557, 55403, 8342, 4262, 28905, 24478, 1822, 7535, 14854, 21757 +, 59645, 47018, 26783, 11626, 39719, 32024, 51517, 6692, 26621, 30045, 15521, 15207, 6895, 45737, 54861 +, 37045, 9041, 52595, 12632, 53343, 44085, 39189, 25098, 28779, 19804, 30355, 53258, 57978, 37890, 44464 +, 19735, 13887, 31482, 46518, 1865, 11201, 54894, 29735, 54245, 21516, 59780, 9766, 13075, 6675, 31855 +, 44288, 20072, 17248, 13235, 32704, 46943, 33672, 48246, 12041, 2452, 8050, 18749, 32062, 6028, 32991 +, 16526, 2116, 46879, 24360, 48634, 25096, 11914, 19881, 54831, 6159, 17749, 30963, 52278, 7176, 13990 +, 485, 51465, 10414, 17734, 4700, 43119, 41029, 38373, 7717, 29423, 17177, 52119, 48172, 49239, 34499 +, 21163, 42117, 36615, 44394, 6477, 1602, 45843, 54743, 21483, 17026, 903, 39232, 47990, 29533, 46408 +, 1980, 30018, 14225, 12395, 24104, 18926, 31866, 41486, 33651, 39583, 10909, 50828, 8054, 35433, 16419 +, 42553, 56596, 34888, 19169, 17343, 41365, 57123, 3186, 12461, 18606, 20212, 49716, 57838, 44554, 19249 +, 20598, 46535, 25619, 34824, 35282, 26076, 30102, 43500, 7562, 40105, 59435, 54823, 30933, 7489, 30256 +, 23704, 50042, 3204, 58592, 45563, 20547, 16309, 42686, 85, 28770, 37644, 20298, 18486, 35482, 41204 +, 14087, 32433, 27739, 16059, 43609, 39373, 42135, 13711, 22873, 26049, 53816, 22308, 20872, 1101, 29797 +, 27480, 1157, 56192, 30684, 59749, 41755, 51232, 52410, 794, 51317, 57533, 38438, 47967, 52371, 50273 +, 29172, 6459, 59058, 33263, 58870, 42667, 12637, 17357, 56378, 11862, 43406, 26546, 34171, 40630, 27647 +, 40320, 8110, 5156, 12864, 38794, 4905, 30972, 6378, 33667, 31766, 57696, 31200, 46556, 22015, 59924 +, 36829, 27539, 42735, 35887, 803, 41605, 18554, 49792, 58962, 51284, 1654, 18720, 17830, 12177, 35702 +, 21829, 28850, 20164, 3337, 41714, 35310, 44594, 12686, 41689, 18262, 44452, 15737, 25814, 31009, 37752 +, 25738, 44190, 41644, 8473, 56430, 42447, 26430, 51336, 8591, 25392, 42621, 10245, 20464, 36803, 58775 +, 32518, 34985, 27625, 52682, 38322, 45691, 27993, 22917, 58378, 46034, 41179, 19182, 1771, 43345, 26543 +, 15875, 9084, 10734, 57519, 53909, 43516, 16318, 20340, 34852, 24909, 22084, 17473, 11507, 42549, 30629 +, 10282, 51419, 5614, 14259, 44102, 43936, 36302, 48447, 43205, 34680, 34481, 736, 30215, 36252, 44082 +, 56758, 28479, 29518, 43844, 2351, 23427, 27360, 18669, 20119, 2213, 43579, 42204, 56038, 31438, 1105 +, 26667, 18072, 52524, 8633, 32331, 12978, 28922, 44985, 1425, 12127, 19666, 35906, 49216, 49881, 48510 +, 33298, 22991, 16990, 39168, 6836, 19341, 38947, 10548, 14362, 59067, 12761, 57941, 17623, 45152, 29379 +, 18728, 48171, 23803, 47604, 56805, 56134, 583, 25727, 17472, 2008, 14206, 37138, 14267, 3422, 3371 +, 2777, 36720, 26362, 56119, 52240, 9550, 51812, 31188, 20099, 6175, 30255, 9212, 40468, 24230, 30716 +, 46200, 19310, 18888, 10003, 6914, 15693, 42490, 43849, 17772, 59962, 22210, 31978, 37100, 36477, 35401 +, 16823, 15606, 48473, 19537, 11726, 40714, 5440, 3538, 11902, 25539, 46065, 18509, 11103, 26534, 42739 +, 41820, 12734, 2049, 37060, 22737, 45315, 52753, 5227, 29165, 10525, 5189, 27727, 18855, 18641, 4204 +, 54256, 11816, 19810, 19082, 31354, 7888, 59796, 36794, 47779, 48050, 38685, 33844, 6559, 26140, 378 +, 25650, 44312, 13112, 4051, 21372, 12202, 49366, 50477, 17429, 54883, 37354, 58971, 22610, 56210, 53964 +, 3166, 26818, 5781, 59329, 45900, 13487, 7217, 45696, 26633, 54996, 10098, 5318, 5193, 16657, 7810 +, 5571, 18659, 52123, 55036, 22710, 49847, 7238, 48429, 40325, 1019, 19664, 54031, 59990, 18627, 50241 +, 30307, 21793, 53412, 36088, 21122, 39312, 49575, 4692, 1361, 16208, 36040, 11459, 57878, 17585, 4469 +, 5688, 23157, 59480, 34163, 54545, 58543, 24011, 1783, 46972, 40688, 39154, 42988, 34719, 15497, 1615 +, 24961, 45804, 23409, 54725, 58244, 20883, 34037, 47819, 1927, 11750, 40379, 14320, 59562, 14609, 31905 +, 4031, 20297, 31414, 3511, 30813, 25959, 38406, 54824, 4094, 25378, 35512, 43249, 44719, 46583, 58746 +, 46334, 11544, 20902, 46095, 42621, 19146, 6979, 16659, 43317, 45258, 28409, 23696, 59578, 27971, 38305 +, 7836, 8354, 34954, 39250, 48218, 42119, 5210, 26624, 36943, 9304, 28355, 48807, 28905, 13074, 35391 +, 4003, 59408, 23287, 24905, 21856, 5909, 20403, 5187, 58920, 3720, 50445, 3681, 3768, 26376, 8005 +, 18425, 34212, 52711, 29732, 49814, 40929, 11851, 55024, 43906, 25147, 40681, 48613, 50306, 9586, 1687 +, 25697, 49942, 37447, 25337, 14847, 35655, 7598, 11603, 40842, 42870, 15323, 31288, 46551, 55444, 34016 +, 30908, 13869, 44580, 23620, 19953, 34394, 4549, 31805, 29419, 24807, 56952, 46452, 13420, 47258, 32390 +, 51459, 49308, 22332, 5259, 50997, 37180, 40914, 34947, 25135, 21757, 17817, 40458, 29397, 40720, 12254 +, 3413, 11629, 2476, 47993, 35249, 22429, 58739, 16150, 30586, 28158, 40958, 3890, 50962, 30730, 51149 +, 23353, 58542, 16809, 45685, 40153, 44158, 59217, 21067, 19105, 24352, 19176, 13274, 41163, 24925, 53994 +, 53417, 28338, 5623, 32245, 52683, 40872, 54675, 51423, 57023, 1613, 55933, 14333, 5504, 23248, 21415 +, 33005, 46601, 19957, 49814, 32286, 110, 10324, 7856, 57530, 5781, 32208, 53058, 19055, 49723, 17984 +, 13049, 43141, 22674, 55025, 51738, 51710, 35897, 46413, 19485, 9272, 48027, 15418, 59957, 29883, 15018 +, 21373, 2888, 1619, 17682, 29054, 10258, 17793, 39378, 54466, 51675, 45159, 26674, 44733, 40566, 16398 +, 2717, 53615, 35891, 25392, 48640, 27629, 17102, 890, 50395, 36587, 46514, 14774, 28357, 46472, 44657 +, 43376, 7845, 47545, 21347, 25527, 52951, 7957, 19672, 32329, 2423, 11347, 53840, 5450, 56081, 34406 +, 21848, 35150, 4373, 34091, 542, 29366, 38072, 53996, 6608, 4819, 30583, 53122, 19593, 35293, 39594 +, 40602, 18669, 23791, 4499, 16368, 25671, 57450, 24326, 45343, 6131, 26749, 33043, 59971, 32199, 5476 +, 10729, 30399, 40626, 51455, 40842, 41169, 20821, 18915, 11517, 27429, 23734, 42101, 56903, 19680, 17394 +, 36498, 282, 12415, 36641, 4782, 28783, 2312, 38584, 53109, 24008, 44716, 56211, 57051, 21039, 4762 +, 2527, 31769, 11514, 19505, 23224, 52356, 37026, 20397, 47623, 48544, 24178, 11358, 6997, 21081, 31038 +, 24391, 57579, 7672, 36806, 10573, 48806, 41941, 12885, 27391, 11403, 36893, 48459, 7614, 10296, 9498 +, 48728, 49175, 41267, 242, 8681, 40843, 52599, 45707, 1240, 40222, 10603, 25418, 27932, 17600, 22852 +, 35322, 41991, 56783, 42995, 55149, 7356, 8153, 13443, 20242, 11896, 24846, 33487, 355, 8812, 43784 +, 9854, 57540, 32959, 51121, 57783, 41640, 8317, 26734, 3700, 9557, 43308, 14303, 11328, 47593, 31904 +, 10532, 22915, 50247, 7315, 42262, 21749, 14672, 50416, 35192, 11266, 38664, 38, 44753, 39020, 8850 +, 28537, 48874, 42742, 1497, 16347, 16877, 19489, 24664, 19963, 23189, 10574, 3272, 13845, 58254, 27217 +, 22101, 8786, 50132, 12348, 16101, 8747, 34097, 7125, 35515, 9289, 18391, 14179, 45679, 3145, 53199 +, 30881, 8034, 42073, 13624, 45883, 34773, 30501, 5373, 59437, 26817, 4914, 10011, 6441, 55111, 44617 +, 33658, 17212, 53403, 23790, 29561, 45857, 32537, 40010, 52982, 8052, 49300, 11374, 58584, 34979, 50871 +, 51783, 5861, 58905, 10209, 55837, 44789, 44982, 2690, 26514, 20771, 29507, 7780, 7135, 35948, 2892 +, 51752, 9606, 20104, 45156, 9749, 26017, 7365, 42286, 6028, 347, 26691, 31680, 48073, 25275, 6659 +, 38944, 53410, 48872, 14202, 3619, 44709, 35343, 24953, 47400, 38209, 45725, 53259, 45989, 52860, 29208 +, 25233, 44612, 15166, 21690, 6120, 24915, 47707, 13485, 43554, 53735, 13833, 46597, 1767, 38258, 11872 +, 8427, 53555, 41634, 33651, 7757, 45254, 54713, 19452, 10207, 18465, 57661, 55932, 11724, 20002, 25144 +, 40932, 45236, 9757, 32451, 6926, 15877, 57366, 30985, 5715, 40920, 1073, 55900, 27517, 2840, 34158 +, 15741, 47619, 27713, 57376, 21271, 11822, 18982, 15984, 31274, 5541, 34449, 5287, 37826, 22525, 1642 +, 2970, 39810, 23230, 49079, 12261, 30156, 41309, 9627, 37493, 47024, 26900, 38566, 42924, 30769, 41407 +, 17082, 46511, 29026, 44796, 20239, 26649, 32970, 15573, 42633, 4245, 21114, 53434, 45884, 58940, 15960 +, 47526, 38263, 55770, 10756, 27342, 8031, 17264, 8651, 54010, 54758, 55675, 57262, 9676, 14951, 28032 +, 51083, 32034, 50895, 56462, 53182, 11134, 23111, 26152, 26707, 42097, 6749, 24173, 11883, 52634, 59466 +, 27843, 16512, 37729, 59965, 27269, 5071, 44348, 20885, 13723, 14711, 51995, 45750, 11973, 1672, 702 +, 40005, 52755, 9088, 30900, 25569, 2270, 18386, 48681, 4774, 21445, 7130, 11524, 45619, 19013, 40510 +, 21437, 23209, 33374, 59166, 23174, 36995, 40589, 7523, 57881, 30664, 58586, 49876, 16415, 10559, 51548 +, 53469, 26917, 20656, 2557, 57817, 46225, 41179, 52556, 11258, 45953, 50353, 18388, 33829, 12324, 13754 +, 50691, 33761, 36963, 24066, 32927, 137, 1061, 13517, 44012, 35294, 44181, 42598, 25171, 36948, 29510 +, 53071, 30417, 56427, 13727, 9326, 30596, 36305, 50505, 23152, 47563, 12811, 49858, 42304, 46640, 2182 +, 56058, 13684, 35944, 9373, 37750, 45223, 9510, 15163, 58740, 29875, 50458, 19274, 48825, 15629, 32574 +, 18335, 45052, 39344, 51114, 58780, 48670, 21711, 35085, 39176, 21215, 59000, 51987, 11073, 17656, 14979 +, 13256, 50066, 5015, 25552, 59439, 42765, 10775, 45302, 34281, 45868, 51529, 24739, 41494, 40354, 16720 +, 14068, 35042, 1772, 53412, 26156, 36904, 42083, 24219, 48341, 57611, 45435, 23694, 25950, 32860, 41350 +, 17281, 46116, 31417, 22297, 11668, 7208, 41414, 58796, 52510, 15695, 44664, 44039, 16786, 26158, 746 +, 9858, 40226, 12140, 11631, 9991, 38296, 24887, 28426, 38868, 13229, 2389, 24303, 13275, 28339, 57163 +, 54625, 21972, 19632, 2394, 44269, 7652, 45955, 2036, 6448, 38465, 17731, 51112, 58857, 10870, 17270 +, 35955, 20728, 33849, 48095, 8711, 20192, 2743, 33599, 48618, 41611, 23180, 51007, 5914, 36455, 55698 +, 39430, 7432, 17670, 35414, 46179, 38292, 43066, 32134, 40328, 49515, 46951, 34411, 16979, 22160, 45281 +, 34250, 58115, 42362, 44451, 46210, 51073, 40995, 48954, 1024, 29613, 30565, 556, 56972, 12832, 13363 +, 52670, 28614, 57148, 46692, 4028, 43327, 24984, 47094, 51813, 41664, 12961, 38764, 16076, 29941, 925 +, 37709, 40543, 35392, 56423, 1346, 21603, 23849, 42341, 10557, 24873, 11954, 17474, 1782, 45278, 6658 +, 15145, 37948, 35272, 12293, 992, 39300, 31972, 25977, 2747, 23785, 7641, 52060, 38902, 69, 22001 +, 16179, 14131, 2544, 51571, 10554, 3890, 13174, 10755, 22583, 83, 11981, 34537, 53910, 13763, 19815 +, 568, 5260, 34115, 35841, 53906, 35108, 51493, 25878, 37437, 30592, 26016, 21430, 22653, 4918, 57852 +, 44654, 57449, 11983, 23551, 49020, 58889, 3793, 2195, 9645, 26377, 38630, 21626, 37266, 32540, 11741 +, 33434, 33109, 17001, 43901, 45302, 10907, 19009, 36795, 13138, 32798, 43740, 15506, 54229, 6393, 56776 +, 28433, 27399, 54225, 40416, 27302, 43245, 15657, 31096, 21792, 1654, 33825, 36775, 59632, 47443, 9315 +, 11373, 20877, 18776, 4727, 4779, 4078, 51986, 140, 17226, 5124, 32939, 37318, 56982, 3520, 43711 +, 53758, 31953, 47462, 24335, 48721, 14765, 7581, 4378, 22213, 5725, 42385, 56038, 42500, 42017, 43481 +, 28168, 53391, 40711, 46944, 34470, 45490, 27375, 26456, 45630, 20953, 7933, 54921, 58271, 4915, 34793 +, 18334, 35026, 6746, 5796, 59361, 55467, 20561, 43294, 36198, 19126, 49020, 18583, 15164, 7872, 36952 +, 34998, 36040, 6695, 15709, 59337, 41165, 37551, 3064, 7622, 59533, 369, 15555, 54455, 58640, 56822 +, 5600, 53326, 31848, 12347, 35474, 7562, 44166, 56036, 50856, 56716, 15162, 16228, 51651, 6679, 24101 +, 28604, 18029, 36493, 35299, 33738, 35830, 16465, 47641, 15246, 439, 47174, 15615, 52346, 17981, 50607 +, 49168, 23582, 43933, 57369, 12281, 19408, 4931, 56447, 51796, 55787, 53164, 43310, 12016, 44815, 26341 +, 12469, 49771, 44370, 48962, 25071, 54460, 1145, 17888, 42101, 16391, 54679, 5628, 32007, 47025, 23609 +, 58966, 12545, 23543, 42900, 9914, 35824, 38660, 14845, 8624, 6808, 46985, 38140, 50118, 35353, 22955 +, 52812, 47822, 49079, 37182, 36784, 14150, 31643, 37929, 8390, 50096, 54321, 3069, 55724, 2680, 26446 +, 55686, 1646, 38991, 55581, 20898, 48906, 7758, 35910, 40103, 16382, 42718, 3440, 54522, 9189, 38793 +, 53829, 2001, 26615, 42908, 15535, 39752, 33410, 23530, 17681, 18152, 13627, 48354, 57573, 45703, 27386 +, 24019, 17741, 29033, 39363, 13323, 26283, 4621, 21081, 2194, 44724, 13815, 44912, 24517, 8337, 54101 +, 3310, 38518, 32454, 6278, 21427, 47990, 46030, 31189, 11520, 40063, 49342, 1499, 4770, 46915, 47203 +, 32156, 47287, 41296, 1189, 26650, 54619, 27473, 31271, 52052, 6019, 52347, 5867, 50931, 53216, 14204 +, 21385, 56527, 52723, 30191, 39157, 50502, 18181, 1539, 21691, 6054, 41602, 47385, 7553, 22724, 10653 +, 31108, 54881, 57940, 12405, 32422, 24590, 43376, 36247, 32213, 35429, 42266, 912, 41296, 9550, 54129 +, 55501, 30935, 27008, 24576, 1126, 6165, 51430, 55660, 44056, 13121, 1714, 2010, 36859, 45619, 24735 +, 47512, 53080, 19616, 45452, 5485, 52038, 46394, 48861, 4638, 54959, 24290, 46904, 55871, 41939, 56454 +, 26352, 37440, 3741, 53360, 38368, 4868, 35877, 29798, 36880, 19933, 19271, 14946, 58296, 56130, 36917 +, 23031, 43642, 29997, 18999, 5446, 35482, 47389, 51840, 696, 52027, 46799, 1338, 38932, 19023, 43277 +, 11738, 45375, 57069, 15480, 15088, 11789, 56700, 27317, 17939, 33580, 23603, 37211, 24878, 21899, 9693 +, 1795, 21282, 53336, 31793, 40281, 35134, 43627, 27670, 26975, 20675, 56050, 50126, 22014, 11334, 45501 +, 41643, 23072, 7229, 15065, 14904, 22317, 26854, 11604, 49634, 44794, 21536, 13237, 58357, 46414, 11488 +, 8050, 24562, 32770, 37738, 56355, 13051, 12873, 16334, 17074, 16200, 37010, 49476, 42678, 35376, 810 +, 28180, 17019, 234, 11761, 8436, 15139, 34078, 35291, 26743, 64, 56437, 24632, 49654, 54794, 47398 +, 37494, 39196, 11960, 10265, 16935, 8315, 59668, 6160, 1002, 53094, 22360, 38012, 42570, 5038, 13388 +, 19732, 9570, 6759, 19967, 21331, 15196, 11458, 31761, 26839, 14553, 31826, 59628, 39185, 57832, 30774 +, 26584, 35326, 9970, 38544, 21943, 26905, 23212, 21612, 9417, 24214, 51058, 31777, 38578, 9981, 13168 +, 51966, 29713, 22738, 35077, 26032, 44070, 26625, 13842, 52183, 29816, 28396, 361, 29444, 7581, 58193 +, 218, 10517, 9872, 46541, 49062, 31815, 49798, 48626, 29779, 59216, 49192, 20838, 30993, 27770, 7171 +, 44161, 19736, 36884, 43252, 31165, 39269, 3674, 57791, 53111, 55857, 27607, 21507, 56219, 33404, 5441 +, 54412, 33622, 15958, 40636, 20163, 41372, 48804, 46314, 6350, 18583, 45530, 55542, 15773, 16523, 23312 +, 22944, 37037, 19400, 36181, 20289, 50566, 15450, 23963, 48357, 44913, 19820, 52316, 42773, 16039, 25720 +, 48214, 46804, 35695, 40524, 27440, 32210, 58249, 52596, 18524, 4599, 11180, 4054, 142, 3305, 56930 +, 59806, 2602, 33967, 19207, 38783, 30608, 46125, 30585, 54571, 34482, 15498, 50743, 3150, 34623, 43135 +, 28871, 59189, 29939, 40918, 39714, 33731, 13128, 14315, 26328, 31653, 18914, 13860, 35707, 55408, 53517 +, 32637, 55215, 56119, 42956, 50774, 34902, 13564, 36899, 41839, 44487, 47733, 57338, 35231, 50883, 8313 +, 54718, 56106, 7503, 24657, 37024, 47217, 34740, 26505, 1532, 37420, 58158, 56798, 27632, 10217, 52207 +, 21150, 19207, 23774, 17269, 2163, 50900, 28524, 52080, 27799, 10363, 36567, 51884, 44053, 48150, 19119 +, 52367, 42868, 15226, 59870, 43877, 28602, 23439, 54970, 55107, 24971, 32390, 29617, 58121, 23, 39835 +, 26680, 21173, 59042, 26806, 14794, 1205, 17706, 43318, 29637, 45505, 53682, 6205, 13741, 37735, 30707 +, 32861, 6454, 13576, 24439, 6324, 33805, 53041, 29763, 28775, 24501, 31086, 1166, 54118, 29208, 37541 +, 33953, 55888, 35066, 32995, 59047, 49860, 10553, 16753, 33179, 40190, 38611, 3213, 22747, 52352, 17300 +, 53455, 25213, 23755, 43383, 49652, 30079, 17188, 19046, 36195, 22316, 43547, 7281, 59834, 37665, 12841 +, 37375, 47971, 45082, 48793, 57318, 44129, 38653, 7871, 882, 48184, 24414, 39493, 51397, 23513, 31846 +, 45050, 53320, 33411, 8805, 36703, 59416, 38884, 30244, 18462, 15079, 28912, 38361, 58713, 28746, 16026 +, 11554, 42473, 40349, 56636, 31266, 37668, 40765, 9919, 21891, 41648, 34456, 22657, 57493, 2205, 46171 +, 5691, 47255, 15843, 15455, 56060, 28899, 14871, 11297, 59143, 33333, 2728, 4407, 11694, 1441, 33153 +, 4072, 12996, 15626, 20774, 45984, 23244, 58442, 26750, 33163, 56685, 44750, 43971, 19343, 42243, 46177 +, 41866, 24287, 33432, 57709, 39742, 29493, 2960, 54613, 40790, 2103, 4298, 43518, 42862, 52344, 21312 +, 16015, 32768, 34308, 7993, 53542, 20292, 31237, 28336, 23394, 40753, 1374, 8144, 24724, 20717, 26740 +, 10901, 38935, 27379, 20686, 12996, 7121, 50179, 15957, 38086, 7321, 54412, 18736, 27191, 37275, 11080 +, 48503, 29642, 20200, 22811, 13988, 13743, 19456, 21577, 18431, 42850, 2330, 19805, 27347, 3407, 16874 +, 30439, 50660, 32161, 57818, 11346, 21510, 41291, 37877, 37467, 55729, 45198, 8231, 14465, 12390, 21858 +, 1897, 893, 27853, 22097, 57, 41841, 12192, 55865, 39770, 30624, 15067, 18453, 26781, 42414, 21860 +, 43656, 49205, 48872, 15817, 23375, 219, 37327, 4666, 38096, 51146, 395, 59647, 35730, 51212, 12037 +, 33940, 53109, 49282, 1793, 51559, 25691, 19986, 3751, 21556, 59757, 10727, 36624, 18210, 37509, 55390 +, 16422, 57517, 44596, 5294, 13334, 7971, 41865, 27014, 48990, 56314, 54512, 25737, 55961, 30242, 16950 +, 44350, 4183, 46411, 33632, 42328, 37970, 59324, 2315, 41722, 57232, 38424, 52449, 33856, 32986, 6310 +, 29247, 49408, 3827, 50195, 31054, 53514, 34518, 12920, 20528, 59860, 9234, 51392, 25598, 41547, 57987 +, 18900, 2249, 38522, 5311, 12233, 20850, 43282, 11557, 59517, 1356, 45142, 14293, 53805, 18998, 47279 +, 36468, 24597, 36687, 40295, 51144, 7742, 33809, 25663, 57014, 30689, 25523, 42600, 58434, 27473, 24147 +, 56421, 46373, 26396, 34943, 51685, 38629, 55793, 11319, 26539, 31663, 12675, 11681, 45956, 42832, 7031 +, 33236, 19300, 7981, 46275, 35948, 59125, 54017, 9757, 1140, 51031, 16799, 3016, 9983, 15233, 6841 +, 34130, 11654, 53215, 36878, 22949, 21252, 51860, 18742, 32571, 18399, 26757, 21598, 6432, 12714, 4430 +, 49815, 22302, 23731, 34148, 8577, 36031, 9626, 2595, 22140, 10766, 29978, 38939, 50134, 39962, 30524 +, 56976, 50444, 18530, 26543, 3675, 41479, 24147, 55535, 36574, 33070, 50286, 3331, 54668, 33070, 52397 +, 35450, 22885, 14699, 59181, 33386, 23277, 35212, 43012, 2224, 33705, 30130, 8554, 12644, 20265, 24868 +, 19521, 53593, 51665, 38051, 56488, 55340, 55883, 20635, 50875, 32457, 30057, 17513, 12140, 24725, 50583 +, 40890, 175, 49820, 55589, 35709, 23206, 55218, 47273, 6218, 33794, 20978, 36349, 42349, 9975, 32966 +, 43569, 29496, 26559, 35234, 43899, 59399, 30574, 39782, 20034, 57801, 48591, 50091, 51666, 37084, 51168 +, 42249, 17974, 27695, 8422, 49915, 3404, 31628, 45134, 27030, 14199, 18928, 48008, 50548, 37629, 34335 +, 59866, 21199, 3831, 2777, 32785, 24083, 2176, 39712, 3865, 58562, 37513, 28809, 25005, 5532, 5893 +, 16173, 47781, 219, 43868, 56203, 50134, 23625, 4184, 35268, 27007, 18383, 30549, 15015, 45283, 8178 +, 25703, 45149, 5729, 29534, 47926, 38515, 53617, 50102, 18227, 33835, 25016, 32092, 38996, 50021, 37624 +, 44889, 42546, 1758, 21460, 2766, 34313, 11594, 26391, 38497, 23215, 53398, 56880, 53764, 44766, 42163 +, 38294, 10469, 3664, 20376, 16355, 51590, 58891, 46325, 18044, 53470, 56512, 43060, 1914, 35508, 9433 +, 15891, 56749, 51979, 17649, 18209, 54746, 51962, 6155, 57489, 30460, 29370, 27240, 3692, 23134, 12006 +, 22208, 37781, 58827, 25872, 58157, 51534, 53815, 33400, 37859, 11859, 3222, 10723, 31272, 5136, 46231 +, 40705, 21027, 19332, 9037, 15028, 13893, 3783, 43343, 20049, 1272, 13803, 49419, 28512, 53847, 48906 +, 16870, 16055, 26687, 52049, 41928, 1196, 43584, 35743, 10948, 57795, 23954, 14170, 8519, 55226, 55658 +, 31102, 12284, 53038, 26787, 21321, 8066, 40680, 1456, 51409, 729, 39080, 41564, 26501, 43945, 35412 +, 51759, 37167, 27819, 18446, 29217, 9747, 55994, 49153, 21842, 6942, 46948, 45797, 57464, 31819, 17375 +, 53122, 39274, 6011, 46160, 6061, 3684, 54227, 23093, 41492, 21988, 23823, 20573, 3553, 26676, 4518 +, 15317, 18435, 41685, 43136, 13233, 47254, 29236, 45579, 36407, 27430, 52521, 59708, 49579, 26337, 7879 +, 43307, 19459, 47153, 49318, 5620, 29566, 29355, 36199, 52660, 10847, 34539, 52835, 31420, 14444, 19511 +, 12290, 29761, 14298, 30328, 49250, 27531, 17582, 54838, 13110, 30342, 22268, 41983, 6402, 11848, 8320 +, 50633, 55155, 4131, 37787, 20825, 46103, 43705, 50180, 22302, 36365, 1028, 56842, 29200, 8800, 11286 +, 25063, 21091, 17400, 39361, 51419, 43002, 43244, 45353, 37840, 32706, 52047, 36460, 51041, 34801, 24660 +, 59361, 25435, 56167, 39845, 39574, 16993, 25948, 23279, 43525, 24603, 59645, 20905, 57797, 5197, 29706 +, 45435, 30261, 27149, 39187, 9622, 54920, 22189, 29219, 40273, 36381, 1925, 8673, 12842, 52967, 43474 +, 13854, 28680, 45261, 10022, 44877, 24835, 3367, 10826, 48115, 23244, 11781, 24112, 44150, 9578, 29309 +, 13856, 31365, 59570, 41005, 10553, 45545, 35925, 32742, 51116, 52550, 45476, 53041, 37575, 34670, 22360 +, 57402, 48524, 27393, 42663, 34898, 12270, 43851, 38265, 23096, 31966, 1510, 11229, 32430, 22012, 20807 +, 1739, 35868, 28525, 37662, 53225, 39078, 59559, 5502, 48172, 50675, 34404, 33648, 43716, 11980, 8318 +, 42429, 45734, 33195, 9822, 28397, 8093, 22092, 12248, 22711, 21541, 20566, 573, 32770, 52996, 58937 +, 29930, 31088, 34805, 58455, 8750, 4382, 13885, 44661, 46236, 2057, 35336, 56992, 12058, 55404, 8972 +, 56728, 37833, 54706, 6275, 47655, 59456, 50721, 46100, 48056, 13432, 43993, 44975, 50357, 53115, 14323 +, 49294, 23045, 45411, 451, 57852, 30513, 41185, 48089, 15174, 3773, 26499, 50510, 765, 38557, 45915 +, 46090, 11637, 100, 17148, 17913, 47756, 16604, 8634, 10208, 41013, 58418, 54201, 25988, 25127, 47316 +, 40311, 50773, 46714, 2075, 51224, 20918, 8940, 8761, 9008, 24115, 12534, 35507, 50977, 13299, 50416 +, 13244, 59389, 38405, 49697, 16538, 56318, 13805, 9494, 4952, 24013, 50507, 39722, 54566, 52847, 4849 +, 41882, 33159, 55622, 4948, 11586, 23198, 25867, 20526, 31959, 11227, 20993, 20845, 23086, 48323, 10497 +, 49854, 37919, 9886, 28259, 27616, 2776, 24578, 41421, 48623, 5882, 41786, 15482, 45605, 36352, 8330 +, 26806, 54587, 17841, 58781, 59535, 29427, 21979, 1754, 26305, 30291, 12981, 47299, 51136, 36067, 11974 +, 1633, 2273, 49893, 47872, 30533, 53862, 27000, 55111, 11635, 15623, 37345, 53422, 7458, 59302, 6126 +, 15788, 26109, 713, 9981, 1242, 249, 15760, 23221, 2003, 42065, 29864, 51337, 5716, 21001, 3756 +, 54042, 58986, 6030, 43936, 23210, 36563, 14150, 50211, 8026, 25785, 42186, 45371, 55559, 49644, 21026 +, 1686, 41784, 23487, 38751, 28117, 24729, 39000, 43877, 47950, 17356, 2295, 17815, 45045, 8011, 15168 +, 48801, 2054, 50506, 54831, 22342, 13717, 31394, 12844, 40280, 15772, 38629, 58818, 1144, 10541, 48463 +, 22170, 12227, 6599, 45657, 50978, 34717, 46738, 6331, 18594, 34688, 39, 57241, 28855, 45084, 5253 +, 20375, 33885, 43659, 10882, 5069, 42353, 951, 12815, 55197, 17583, 28588, 10178, 16401, 6084, 20719 +, 4864, 4606, 9298, 47816, 26615, 36629, 58885, 13353, 19312, 17479, 24393, 19351, 14721, 53249, 40787 +, 56326, 49976, 51024, 16337, 37210, 56093, 58690, 14513, 8909, 30239, 32096, 13849, 40417, 48498, 19933 +, 1137, 29714, 24539, 46787, 17530, 51154, 23416, 16415, 4507, 19080, 10247, 28900, 14783, 1320, 58501 +, 55570, 33998, 24830, 46595, 50335, 2040, 19040, 25377, 16554, 4301, 55616, 48650, 18150, 36033, 13500 +, 38083, 13522, 43215, 38974, 310, 745, 30128, 78, 53513, 10987, 55511, 40112, 16240, 10294, 41432 +, 14741, 5865, 15430, 15923, 28812, 42117, 17964, 24204, 7494, 10870, 28506, 3110, 35872, 23008, 15495 +, 49373, 37444, 29018, 8940, 16418, 5680, 46037, 22899, 42110, 39550, 33886, 37621, 19662, 50126, 47916 +, 37446, 41220, 30133, 52876, 57143, 35297, 11345, 51459, 59501, 18839, 38681, 4359, 21949, 14554, 27368 +, 37445, 40279, 4812, 42815, 49219, 57582, 48495, 35256, 20481, 6957, 51159, 54368, 44579, 10821, 20846 +, 8847, 24620, 38418, 38980, 17496, 35562, 14277, 28842, 3373, 50130, 24033, 42055, 54490, 45983, 56609 +, 58210, 59780, 13240, 39374, 42595, 2459, 36956, 7442, 14067, 57438, 50751, 5226, 28158, 35330, 52400 +, 49004, 20529, 17020, 27423, 59509, 10868, 39337, 50138, 16062, 42710, 16621, 40096, 24765, 47463, 2431 +, 57726, 45673, 38563, 10966, 25047, 57510, 49777, 2003, 41304, 40197, 35793, 32055, 21775, 3951, 7386 +, 50527, 29308, 27915, 43899, 56731, 3777, 31120, 12420, 30267, 23534, 55130, 23240, 3630, 56248, 10703 +, 42413, 30326, 56376, 57328, 17645, 21423, 54838, 43774, 59779, 36142, 23971, 35572, 8198, 22099, 15876 +, 51936, 12626, 45184, 56203, 32878, 18267, 36332, 3998, 30687, 6600, 27532, 2169, 29840, 7515, 34769 +, 16896, 26280, 5096, 13272, 23609, 22741, 11048, 18447, 42867, 10827, 30942, 6839, 22751, 39140, 5290 +, 38627, 7428, 54268, 23811, 3631, 27146, 42078, 39964, 7496, 49117, 22916, 11381, 51287, 29108, 18896 +, 2408, 46004, 45176, 7504, 35629, 45137, 6597, 46677, 39937, 49465, 33856, 10879, 32656, 56607, 50019 +, 14298, 11587, 33799, 8566, 35398, 37430, 12065, 53829, 53746, 19561, 42946, 16662, 30942, 10585, 22123 +, 26190, 12994, 44479, 47719, 56850, 20108, 32856, 39800, 6785, 12793, 29265, 40641, 23672, 38273, 13601 +, 50043, 52571, 25188, 23842, 37489, 586, 37625, 49554, 30767, 31371, 9116, 50066, 24386, 16410, 651 +, 22861, 42601, 49997, 7340, 30320, 46848, 27449, 39528, 26648, 34234, 28674, 32265, 51228, 52346, 46890 +, 4829, 18742, 39461, 30017, 18936, 53302, 6955, 32913, 42857, 14075, 4285, 28325, 4141, 5023, 44735 +, 41144, 27884, 3688, 7494, 11576, 10360, 54342, 39025, 49889, 57342, 49612, 18563, 5959, 17192, 47261 +, 52849, 22021, 42355, 8662, 28390, 37644, 38316, 11697, 10557, 21173, 2124, 51194, 49498, 6265, 32569 +, 10586, 23762, 36805, 14274, 31256, 48382, 987, 1950, 27407, 50876, 59292, 53371, 45791, 41603, 10563 +, 9404, 10804, 32584, 28112, 55818, 37326, 5756, 34134, 25376, 52665, 55308, 27500, 43860, 21158, 10118 +, 16429, 8096, 33880, 53235, 22371, 5136, 41617, 23358, 7086, 45376, 50586, 42730, 38748, 12729, 24333 +, 25663, 22133, 11489, 34600, 50245, 7307, 11926, 32353, 17793, 13654, 25019, 13101, 41155, 8879, 10612 +, 51273, 1660, 18708, 25153, 31247, 17431, 30289, 49216, 17141, 13727, 10945, 7727, 56457, 26045, 20456 +, 57142, 51708, 18942, 8631, 26308, 9187, 52290, 14587, 41541, 10083, 28241, 42912, 59537, 9396, 28143 +, 46501, 669, 29803, 5209, 2174, 37403, 58993, 8815, 2971, 16134, 22542, 13916, 214, 55351, 39961 +, 20670, 52493, 31670, 15964, 37476, 34330, 1504, 6118, 48917, 19397, 16202, 17159, 2309, 52091, 26555 +, 30452, 38592, 3577, 36607, 20153, 42103, 14010, 19146, 50919, 16982, 11633, 49813, 30898, 11847, 45165 +, 47212, 8869, 14010, 55234, 24834, 27839, 29564, 26338, 33957, 18482, 45735, 26511, 11993, 24396, 18602 +, 38548, 54848, 33546, 18477, 31455, 30052, 581, 45466, 49198, 27852, 38800, 37183, 17665, 46050, 49030 +, 2830, 33262, 57900, 53193, 4848, 59086, 21032, 34413, 25424, 54989, 29247, 47511, 21501, 41240, 11907 +, 16455, 56140, 6755, 50002, 14618, 14562, 20054, 51551, 36380, 45604, 19403, 15180, 22788, 13420, 1231 +, 48170, 52603, 10845, 46070, 45796, 15694, 45156, 6828, 26459, 46932, 38169, 55706, 10795, 36022, 13298 +, 59054, 52478, 9438, 42161, 18832, 408, 56724, 15238, 51959, 33104, 842, 47714, 24637, 59982, 1135 +, 2220, 48153, 53738, 49417, 10575, 15886, 5111, 32084, 22714, 7922, 55368, 37235, 39980, 6164, 13258 +, 53278, 5218, 5736, 39069, 47380, 24568, 39477, 20456, 16158, 7789, 29912, 17000, 55503, 54549, 53335 +, 32990, 56769, 17840, 26728, 46187, 28415, 42614, 27650, 36851, 41680, 11925, 32220, 18916, 51905, 14736 +, 32174, 21536, 56306, 14262, 605, 20038, 38830, 40082, 40494, 54988, 47871, 10407, 48340, 19727, 41308 +, 18027, 52717, 38078, 35867, 55798, 617, 40635, 38412, 4619, 53838, 56445, 52896, 2410, 15361, 44802 +, 17146, 23887, 6338, 13453, 38149, 43295, 9843, 53331, 23377, 50338, 24671, 47601, 37097, 49363, 43680 +, 18405, 7391, 36397, 32835, 19610, 32195, 9804, 36597, 46960, 50776, 30436, 43405, 43672, 9198, 35118 +, 28474, 26345, 59005, 11164, 16150, 13506, 54459, 25993, 6837, 54189, 52683, 7860, 18142, 29780, 57223 +, 1822, 24538, 4614, 38219, 57373, 577, 46767, 43530, 13526, 33727, 34306, 20314, 53484, 17978, 29513 +, 4954, 46453, 55858, 3959, 33969, 48360, 53817, 4781, 50705, 654, 58970, 43389, 8514, 17112, 49521 +, 42089, 55286, 50411, 23056, 9857, 47785, 23633, 56624, 31315, 37159, 6703, 41973, 33826, 36539, 59951 +, 3339, 41493, 22756, 35549, 21804, 56726, 23909, 15621, 1507, 50966, 52627, 36829, 10707, 37493, 30293 +, 229, 19583, 25579, 50640, 42639, 35436, 14777, 42624, 8413, 22444, 19783, 51468, 4417, 53609, 28008 +, 40721, 33300, 9501, 3477, 8849, 31306, 203, 9110, 23279, 1710, 77, 15907, 14891, 10784, 53400 +, 45184, 47365, 49335, 10763, 14358, 31974, 22552, 5487, 14598, 7317, 27932, 10734, 58785, 8701, 40695 +, 3145, 49422, 13996, 12647, 52900, 59197, 20305, 29455, 8308, 43584, 7518, 44737, 35843, 22409, 31873 +, 5596, 7594, 55591, 54931, 54709, 9949, 26906, 53613, 51788, 41504, 930, 56072, 28590, 59716, 4774 +, 9286, 2861, 30548, 59634, 51860, 59800, 58831, 48517, 29256, 43491, 8454, 13126, 28228, 44297, 35535 +, 36454, 49893, 19481, 32045, 44825, 14191, 18346, 11731, 7804, 10134, 29587, 45087, 6207, 58178, 21155 +, 47333, 43816, 24016, 54233, 43450, 52229, 54034, 18633, 40746, 59642, 2125, 49200, 49120, 6705, 9850 +, 24655, 43159, 59743, 20489, 51556, 20920, 11032, 9902, 32651, 55188, 56389, 38591, 40275, 38948, 13121 +, 1430, 26281, 56937, 1799, 56866, 16739, 30380, 50900, 35372, 11126, 26894, 37497, 36679, 16014, 20555 +, 22881, 17022, 3714, 22624, 13863, 55271, 43545, 24895, 41525, 52548, 20083, 37914, 7491, 36711, 16862 +, 20612, 14493, 19495, 53901, 16292, 16362, 10640, 23024, 43614, 46013, 10503, 46861, 59862, 47182, 39227 +, 20417, 46415, 56249, 484, 9039, 46464, 32107, 28936, 11359, 13632, 57837, 7795, 27899, 5328, 20858 +, 21113, 25941, 35351, 16961, 19842, 27996, 33323, 30483, 51020, 53289, 52848, 1523, 40150, 29062, 25057 +, 19378, 25832, 11472, 51979, 26316, 56864, 38444, 58423, 25800, 49803, 48407, 23637, 33950, 52658, 28966 +, 54808, 13772, 31259, 30160, 30733, 51101, 34508, 40408, 57936, 25528, 33697, 27136, 3404, 13848, 56199 +, 28461, 9578, 22031, 16286, 1557, 24699, 13150, 40001, 59474, 15302, 6157, 47881, 15292, 40107, 16892 +, 20610, 11268, 7016, 51869, 41428, 37749, 19322, 15936, 54509, 53611, 17816, 28206, 20747, 21220, 18406 +, 16946, 26034, 27984, 15329, 42320, 5894, 40028, 31822, 45895, 39502, 47124, 28404, 3736, 38768, 44864 +, 20628, 59378, 56132, 27644, 27599, 13912, 41745, 23274, 6200, 36254, 16885, 24016, 40812, 37632, 21589 +, 59219, 54579, 47623, 3555, 9908, 29943, 9449, 26289, 38117, 31697, 5791, 25241, 36453, 45879, 40362 +, 21317, 42859, 39740, 17449, 10503, 43692, 7713, 28600, 6966, 13913, 41206, 23851, 14282, 22019, 1483 +, 12223, 57590, 32414, 59846, 1145, 18675, 6141, 46947, 44964, 44258, 54996, 27107, 45851, 31449, 49339 +, 26213, 29119, 32198, 42306, 22920, 19054, 25998, 30634, 47654, 32964, 20899, 28861, 33167, 11533, 50880 +, 34650, 23756, 24822, 43417, 23602, 2319, 2092, 6095, 25618, 23408, 26705, 20614, 26867, 12557, 28416 +, 16206, 15122, 57535, 48405, 57428, 56807, 7459, 23426, 27441, 31465, 32742, 24693, 326, 5909, 36226 +, 27558, 16912, 36335, 28732, 329, 36289, 31052, 38773, 42385, 56670, 38533, 9090, 53637, 41752, 57999 +, 22053, 57959, 13122, 55940, 22716, 10550, 52747, 6527, 10329, 56541, 37992, 19423, 57586, 14671, 25333 +, 33812, 18581, 18597, 46499, 47314, 55278, 22789, 18366, 10403, 5174, 51388, 48936, 50616, 45025, 30688 +, 24968, 43430, 4999, 38090, 15722, 4067, 24992, 8470, 10594, 11673, 41363, 24939, 31097, 38949, 39610 +, 32782, 49113, 34543, 51379, 35613, 21857, 46657, 58402, 16575, 57060, 39928, 44316, 22348, 6896, 29341 +, 29388, 31864, 49124, 34388, 46306, 4846, 14807, 47651, 13316, 25402, 35676, 31031, 26693, 6773, 9980 +, 42655, 39555, 35446, 17198, 7286, 11059, 15408, 53943, 45813, 8335, 27355, 2093, 52651, 49703, 8989 +, 58345, 19092, 17206, 47469, 29832, 39864, 52315, 44639, 3867, 41984, 46393, 39544, 13015, 13086, 22669 +, 59348, 55741, 38577, 11146, 49292, 45863, 58557, 4700, 16159, 44370, 49387, 43514, 46463, 42039, 33218 +, 31804, 40384, 28662, 25362, 27853, 34846, 5227, 56520, 19485, 45446, 14856, 42231, 24990, 27872, 31669 +, 47660, 3572, 3763, 26237, 51070, 53055, 48452, 49627, 34107, 4611, 33997, 23494, 24478, 56812, 5533 +, 34048, 4968, 22269, 2710, 30331, 26474, 37556, 11910, 22995, 33393, 57356, 37851, 15624, 58699, 42075 +, 47294, 46359, 21999, 51057, 48948, 13069, 20464, 13752, 2696, 54571, 54716, 13045, 54417, 19194, 46209 +, 36303, 53242, 51178, 58572, 55952, 57861, 25047, 9860, 46123, 24394, 43253, 43479, 38597, 35230, 42178 +, 57025, 58876, 4889, 19024, 49933, 30189, 8446, 46749, 43942, 47494, 41320, 38658, 36892, 12089, 34204 +, 23101, 48392, 27446, 50631, 46965, 59750, 48492, 48364, 9610, 34615, 49110, 29215, 54447, 27707, 4445 +, 12977, 1084, 3321, 17867, 56461, 29606, 24408, 4907, 16355, 44702, 28753, 34027, 23360, 5645, 46117 +, 33916, 28747, 34509, 1362, 55730, 57826, 1112, 44223, 22542, 47074, 55190, 11652, 52642, 49637, 15712 +, 33439, 2615, 16796, 13113, 56834, 13257, 42719, 21242, 54516, 35427, 5945, 23270, 45806, 5657, 5267 +, 8275, 39574, 10366, 42785, 17288, 6097, 16963, 54753, 50320, 39506, 41827, 21862, 27510, 10821, 47852 +, 43222, 44261, 50467, 36371, 57374, 23653, 25980, 16445, 21247, 20497, 51872, 3544, 20119, 14031, 9202 +, 1738, 22306, 25128, 12105, 41443, 42416, 18202, 58407, 13521, 44874, 14265, 31701, 6736, 41775, 42522 +, 54588, 1350, 26783, 21407, 37721, 24157, 21412, 3701, 40603, 42660, 550, 8827, 46204, 57021, 22858 +, 31758, 58760, 45165, 33238, 10865, 26608, 52007, 5419, 25015, 5528, 50293, 15632, 37229, 33381, 57408 +, 19752, 4322, 35110, 46535, 25729, 12831, 10693, 47142, 52884, 27648, 6154, 29787, 36475, 28710, 26808 +, 59334, 469, 1920, 20851, 33707, 49137, 47459, 25714, 54556, 48827, 7595, 21201, 4459, 44824, 54583 +, 38219, 40928, 35257, 13329, 27464, 986, 26160, 14509, 24480, 55397, 18509, 6986, 25184, 54984, 35697 +, 28344, 30670, 12518, 6617, 51521, 46225, 55754, 38981, 48292, 26663, 4160, 32239, 47864, 8619, 17063 +, 18799, 23191, 57992, 54056, 36520, 1808, 31395, 39033, 52669, 32227, 34430, 11178, 39214, 35966, 42514 +, 14911, 40662, 13185, 27429, 47279, 4706, 50006, 19386, 20039, 14650, 46049, 24199, 46889, 10265, 9171 +, 40305, 29065, 32362, 38297, 23121, 8882, 16457, 54516, 24267, 9126, 26744, 58697, 56656, 42310, 11015 +, 39170, 33573, 28030, 28707, 1002, 51661, 9766, 27360, 11047, 29805, 42011, 33448, 30357, 5252, 43714 +, 15880, 45557, 12779, 48242, 206, 12252, 33476, 16663, 43121, 57744, 2141, 46217, 32793, 35149, 28527 +, 20161, 50672, 2100, 48191, 19379, 39454, 39852, 29145, 6814, 27252, 58951, 25177, 700, 5660, 30430 +, 20766, 21540, 52339, 33545, 9782, 52546, 45798, 19610, 45561, 5271, 17354, 24055, 51488, 26500, 59204 +, 20015, 46661, 49876, 22115, 11204, 9256, 37921, 51056, 14753, 44735, 54660, 13704, 46265, 31713, 55716 +, 53047, 52479, 17256, 45386, 2377, 3390, 14284, 24527, 59353, 59846, 29798, 53059, 23901, 21286, 19559 +, 59457, 41301, 42572, 49334, 39768, 53776, 34942, 17689, 21185, 49695, 38776, 15845, 39752, 1393, 23910 +, 11820, 54440, 16390, 29077, 16179, 18767, 8819, 6815, 43294, 8172, 6661, 13092, 1232, 6914, 34378 +, 57143, 42724, 52031, 39716, 32058, 8151, 33492, 43352, 25840, 54677, 9399, 40968, 10523, 25503, 18714 +, 34433, 37324, 49506, 27175, 6401, 5685, 22294, 51572, 48853, 5588, 59745, 55514, 55032, 37329, 38781 +, 5762, 34472, 21505, 57793, 14188, 29915, 42296, 47681, 49619, 8136, 42358, 59018, 25457, 29233, 24522 +, 44171, 40019, 1846, 33677, 43546, 44599, 15715, 5841, 36171, 40920, 11429, 12268, 36434, 42814, 49597 +, 51567, 48576, 422, 49424, 22722, 14610, 19339, 5018, 2291, 45310, 49507, 21002, 44329, 51316, 26587 +, 45203, 11839, 42958, 23401, 21868, 26505, 44352, 37583, 32346, 20523, 18503, 20127, 9144, 31290, 2941 +, 35093, 59209, 27870, 35515, 48634, 50592, 50126, 44325, 31962, 28769, 29636, 21469, 26123, 50317, 49137 +, 52711, 35520, 976, 35669, 35273, 22845, 38526, 19625, 36780, 10872, 16500, 31636, 31000, 25644, 39278 +, 10293, 738, 38487, 14515, 12605, 3473, 5107, 39083, 24151, 13422, 7853, 53787, 11243, 10328, 20456 +, 381, 3039, 55976, 1357, 15061, 31249, 24202, 53587, 50874, 983, 40812, 7374, 32619, 48164, 9371 +, 11897, 34809, 46461, 26736, 49325, 59066, 30210, 30784, 38150, 54361, 44206, 22355, 24500, 55450, 32683 +, 44956, 32183, 12075, 17284, 33540, 3488, 24885, 34095, 33427, 52111, 35078, 50591, 35837, 44049, 38755 +, 45208, 55946, 13565, 8021, 59034, 2890, 43440, 5596, 10026, 57942, 59957, 54233, 20297, 809, 26035 +, 29332, 22117, 58218, 17759, 15753, 8110, 57599, 40638, 42205, 31027, 9101, 17283, 21618, 44939, 37684 +, 36726, 6499, 9982, 50291, 50873, 9017, 29533, 34313, 14613, 39559, 32255, 50923, 10144, 28904, 28084 +, 36179, 34588, 50202, 10749, 28700, 42307, 18860, 26299, 22946, 1065, 33678, 8399, 54701, 31649, 29690 +, 32385, 8375, 36190, 42368, 35018, 3415, 27737, 40903, 37728, 42350, 56814, 46335, 33273, 43311, 15239 +, 37710, 55842, 26179, 27912, 6592, 54879, 46571, 1804, 57531, 45869, 2869, 31209, 54269, 33922, 39210 +, 23959, 6308, 23937, 36501, 25028, 35307, 39916, 52765, 52562, 17644, 11467, 49377, 3979, 21093, 32688 +, 55570, 58803, 4882, 21750, 3067, 11474, 52981, 49638, 13278, 50512, 35508, 52500, 58074, 29777, 2774 +, 37284, 30088, 45434, 37574, 6590, 10462, 12881, 22858, 39579, 5444, 16855, 51047, 31173, 57186, 12140 +, 40213, 52757, 10943, 45095, 50859, 50362, 56570, 20192, 40000, 46200, 10705, 15508, 15052, 8779, 21637 +, 17827, 22415, 51726, 3261, 59989, 34668, 50076, 49223, 57526, 29655, 54667, 50733, 20702, 25840, 47920 +, 9194, 42405, 40677, 56489, 27500, 7888, 46851, 422, 28080, 26852, 46623, 15137, 18712, 38027, 268 +, 16702, 55854, 22684, 44780, 35468, 59025, 19448, 25544, 48248, 53326, 55199, 19267, 44060, 52254, 21459 +, 8332, 1448, 3864, 25361, 34290, 31365, 33249, 21141, 8139, 37681, 24345, 31114, 52819, 43058, 9142 +, 53087, 59760, 41348, 52123, 44540, 16816, 51149, 40340, 42360, 15749, 10018, 13912, 35017, 30430, 42518 +, 56476, 38762, 43966, 341, 4123, 18256, 8058, 37372, 15750, 16197, 51406, 40095, 47312, 44225, 59505 +, 32806, 37312, 59265, 14154, 29436, 20157, 30971, 56937, 497, 49683, 12686, 46868, 39947, 47703, 17298 +, 22465, 20532, 56061, 42784, 57225, 184, 37392, 41635, 13909, 53142, 34184, 5315, 33238, 21496, 49540 +, 32743, 30654, 3204, 8361, 44809, 8992, 4870, 52132, 5929, 5368, 18167, 54968, 52236, 58115, 42671 +, 45886, 56932, 39555, 41947, 39716, 36780, 42132, 17109, 18415, 32393, 46603, 52600, 37708, 56193, 50448 +, 3600, 5289, 21103, 6804, 13650, 42264, 15797, 18520, 10748, 58078, 240, 28915, 53046, 28828, 3382 +, 12070, 14715, 36667, 51625, 33014, 16383, 28406, 51498, 9844, 46821, 23891, 56448, 15773, 1599, 28993 +, 6222, 5199, 34282, 3677, 48356, 24284, 45941, 40505, 19157, 56689, 38583, 19397, 1956, 31630, 24578 +, 41691, 20052, 15645, 18358, 11677, 48659, 11093, 40083, 16510, 20938, 3257, 40401, 53738, 19030, 18353 +, 22731, 1604, 59904, 33366, 5281, 48260, 57650, 27574, 28765, 16807, 615, 43701, 12557, 38924, 51683 +, 37135, 20615, 11735, 29132, 15325, 23412, 17791, 26418, 39848, 34301, 23708, 43105, 51055, 53798, 38487 +, 9408, 16530, 40092, 9312, 26248, 21725, 33925, 23898, 49300, 39042, 40706, 49915, 22743, 53263, 28839 +, 50778, 6750, 25806, 2513, 35882, 41131, 2278, 30025, 43902, 42126, 40679, 7610, 25231, 31734, 37761 +, 40070, 17494, 30643, 20162, 26806, 56891, 41888, 37083, 20789, 7540, 16126, 1495, 33807, 15221, 31110 +, 2647, 6000, 37860, 4805, 8513, 50094, 45937, 10791, 20120, 29839, 29269, 799, 13801, 54500, 8885 +, 51562, 10923, 26379, 22205, 31085, 29537, 19096, 49325, 6621, 16238, 33217, 59099, 17733, 7025, 14320 +, 25196, 46024, 20320, 39408, 50829, 5186, 5855, 36766, 52329, 25975, 42957, 21599, 3126, 33111, 52451 +, 12011, 24673, 3374, 14742, 23231, 34460, 44279, 18679, 137, 50900, 34917, 9707, 49999, 29003, 16732 +, 40672, 54199, 2756, 37344, 9959, 53585, 42530, 15814, 6704, 34860, 18141, 26013, 32811, 57619, 59124 +, 25262, 9630, 150, 28637, 724, 23381, 39449, 45004, 42060, 15938, 12256, 53330, 25645, 38608, 22333 +, 42377, 19280, 52884, 21485, 56624, 2843, 51423, 15507, 55010, 58127, 26719, 13151, 24140, 59530, 10771 +, 59617, 24792, 56753, 59767, 29781, 57478, 59500, 9230, 18834, 41560, 1521, 31090, 34890, 27166, 46050 +, 33575, 45896, 5330, 26459, 7381, 38307, 29303, 58804, 53814, 665, 33283, 20533, 13816, 33776, 56415 +, 24587, 33393, 21207, 57693, 33160, 50989, 31523, 9012, 36571, 50357, 26924, 38092, 57799, 1815, 41611 +, 43850, 11742, 27507, 25532, 38202, 11240, 3839, 43857, 46397, 34005, 44522, 19680, 30890, 58338, 53456 +, 27305, 59278, 3201, 24865, 33323, 12713, 52206, 4846, 21725, 28777, 55203, 48650, 43222, 29354, 26817 +, 1185, 13204, 38559, 28692, 38737, 53113, 16284, 18928, 36970, 2681, 29286, 57844, 22362, 176, 32535 +, 52170, 3834, 8165, 55372, 28699, 41488, 44437, 20905, 46334, 6163, 26034, 17889, 54813, 45608, 47243 +, 57982, 46793, 448, 12893, 51837, 15537, 6007, 8122, 10817, 19329, 10803, 40103, 17174, 33165, 16632 +, 49709, 1688, 20466, 57874, 57060, 25517, 39362, 41497, 22774, 2048, 24012, 48808, 19937, 55177, 34417 +, 43532, 53159, 57562, 20332, 6053, 49400, 12221, 12060, 57522, 23039, 31389, 8325, 39494, 24915, 17843 +, 32478, 14624, 19531, 29296, 12498, 52943, 54813, 28212, 10792, 17587, 6612, 34805, 42748, 2901, 29982 +, 53517, 46434, 23142, 51079, 6766, 5547, 40479, 18988, 53959, 14353, 18379, 1700, 59031, 34225, 26616 +, 16874, 6704, 17592, 12757, 12352, 6443, 5700, 7166, 34655, 16492, 1105, 41268, 27649, 20205, 20521 +, 57632, 13722, 6955, 57126, 41154, 50074, 39025, 21633, 9062, 32984, 12339, 3793, 11036, 11370, 38018 +, 37652, 4596, 21074, 31597, 17353, 33427, 38040, 59405, 16945, 49047, 52249, 18050, 6667, 19899, 14608 +, 27189, 53883, 28330, 34144, 27361, 9484, 24218, 6386, 7470, 9632, 39370, 56161, 13425, 26758, 7531 +, 27796, 40763, 48479, 48870, 12360, 42184, 58649, 50400, 41589, 15594, 39447, 10190, 9997, 46115, 30089 +, 24605, 13304, 324, 29287, 47448, 27685, 38772, 48019, 34071, 22594, 57651, 49793, 18755, 47429, 16552 +, 2638, 15225, 57315, 51117, 40447, 9675, 33301, 15449, 36427, 51242, 31043, 15874, 1432, 41040, 1989 +, 7874, 41997, 15293, 8198, 11285, 39094, 12236, 50057, 27113, 46307, 49003, 24764, 12453, 7758, 48545 +, 29005, 46748, 40122, 2672, 37865, 56922, 48699, 47518, 12371, 25126, 15112, 43414, 41000, 16544, 807 +, 19342, 770, 42804, 34635, 45321, 54089, 50081, 57557, 20498, 17194, 20216, 45853, 18311, 32669, 53611 +, 43208, 38026, 16711, 23331, 17050, 54576, 20253, 42101, 18446, 32624, 7227, 33558, 52390, 24580, 26455 +, 53197, 43922, 3577, 12354, 54909, 48898, 42795, 44991, 22807, 39646, 38537, 19376, 25499, 33200, 28397 +, 55463, 16409, 42776, 12174, 39740, 36178, 6751, 36345, 18280, 1549, 45321, 1859, 11460, 37711, 26439 +, 37915, 7261, 46713, 41492, 19615, 17975, 6743, 2410, 2966, 5902, 42056, 17855, 1630, 43908, 27408 +, 6380, 39371, 43817, 49156, 51545, 59909, 1686, 34648, 36254, 19966, 36198, 57927, 21826, 47658, 35638 +, 24617, 1925, 42899, 47683, 19769, 38866, 5658, 2864, 17629, 44976, 45119, 36037, 2831, 46749, 19945 +, 30239, 53129, 59316, 50408, 18637, 50862, 26669, 20324, 25510, 39275, 16642, 38060, 37202, 38468, 25718 +, 12841, 39438, 3995, 32092, 27121, 23765, 10959, 32779, 26629, 28588, 17755, 11748, 4625, 56938, 58498 +, 24571, 3530, 27979, 239, 30290, 46617, 51101, 56960, 43293, 52964, 36235, 59935, 31024, 13438, 14756 +, 56743, 26279, 30546, 738, 34723, 57667, 855, 45682, 6798, 27485, 50622, 905, 39233, 31600, 57843 +, 14083, 32523, 37725, 18415, 32762, 8016, 41384, 23864, 4976, 24677, 16828, 41211, 964, 47852, 54649 +, 15720, 20947, 57280, 46266, 58038, 32004, 20285, 58893, 54038, 27083, 2730, 44661, 27988, 18316, 16261 +, 2184, 32399, 48784, 16261, 27166, 21546, 24277, 8550, 21762, 29253, 33227, 14942, 46817, 34192, 2795 +, 17818, 26264, 94, 51451, 48883, 34484, 23455, 9168, 9730, 53845, 12604, 12460, 38506, 40592, 30776 +, 31119, 19128, 39528, 56255, 35390, 6694, 54154, 36019, 15245, 15916, 41625, 24824, 30859, 28442, 59016 +, 10006, 22612, 1633, 46452, 14063, 50516, 20937, 13870, 59684, 30667, 7716, 48640, 43127, 22574, 5585 +, 50256, 53694, 24713, 29784, 49949, 36455, 36478, 20455, 12475, 51723, 36372, 54100, 16548, 43583, 58894 +, 51916, 53589, 21506, 29901, 40041, 11922, 20417, 37330, 25792, 56454, 7997, 9860, 45094, 27477, 32435 +, 50679, 17733, 2481, 51745, 47517, 28782, 4552, 347, 49238, 17027, 28423, 25610, 47479, 21323, 9193 +, 22725, 13239, 39134, 44232, 19493, 55527, 32506, 16262, 32858, 58298, 49068, 17207, 44511, 10515, 21036 +, 16946, 37546, 38769, 19427, 29291, 2638, 48209, 33844, 2986, 37447, 27223, 7761, 39409, 14703, 29084 +, 24954, 37428, 18675, 40440, 58012, 38168, 35968, 6870, 54431, 45178, 41521, 43499, 38737, 26032, 30366 +, 59774, 42978, 7913, 38543, 38757, 37204, 17534, 26966, 47400, 56872, 40766, 50976, 4633, 20175, 42031 +, 33717, 21482, 55811, 52392, 1922, 53824, 30561, 14242, 37046, 1344, 59420, 18567, 21195, 38158, 44599 +, 51562, 37932, 3929, 59475, 52827, 42686, 13031, 46713, 46005, 36784, 43585, 26771, 27760, 48218, 23298 +, 9791, 21935, 21132, 5602, 50680, 23055, 35778, 57593, 37297, 12825, 58937, 13070, 31392, 56484, 27580 +, 52344, 48046, 41864, 56273, 23873, 11043, 38960, 36905, 57757, 1317, 13689, 41342, 28088, 41449, 5913 +, 27738, 27592, 27848, 48871, 33194, 54880, 48278, 8973, 52473, 1927, 21798, 27762, 14997, 29542, 24247 +, 18929, 21886, 48645, 793, 18160, 12519, 48189, 33472, 49424, 45946, 34789, 39465, 27288, 39229, 57266 +, 33201, 6967, 24858, 37402, 32190, 58052, 32282, 20468, 43377, 1108, 58748, 5175, 28870, 50097, 11070 +, 53117, 9027, 32956, 41763, 46172, 27468, 30634, 34361, 940, 56410, 20307, 12081, 35875, 23948, 51310 +, 9493, 33501, 34630, 34351, 47255, 43172, 8755, 55890, 39993, 52133, 56998, 38741, 33660, 2220, 28838 +, 21082, 55338, 14217, 54039, 13453, 390, 21507, 44087, 34751, 58800, 16849, 31411, 47233, 52724, 31711 +, 14896, 2217, 5212, 49526, 12920, 28820, 32698, 58027, 24710, 49043, 26512, 58060, 27784, 173, 280 +, 32975, 21255, 31970, 47192, 51646, 21775, 47582, 49506, 42214, 58686, 24658, 59063, 30097, 11891, 51787 +, 38160, 26787, 30356, 19724, 52665, 19628, 48544, 1716, 17656, 13254, 50759, 44168, 11314, 18544, 20693 +, 47947, 51519, 18301, 19917, 38711, 9947, 41693, 2646, 35805, 259, 37684, 463, 59323, 44133, 12355 +, 27462, 22293, 15494, 34171, 42017, 8160, 53799, 30562, 9876, 47807, 20168, 635, 31976, 7835, 55531 +, 29021, 55782, 23402, 47322, 52051, 38466, 33622, 10096, 41112, 9427, 10356, 55148, 46243, 9679, 39281 +, 34950, 13493, 1574, 50444, 47664, 43591, 34956, 41464, 14153, 44832, 5623, 10674, 21820, 13951, 18509 +, 53703, 42973, 14291, 17106, 6647, 42694, 31924, 40269, 52791, 49388, 26049, 39499, 44536, 12292, 49178 +, 23817, 47242, 39023, 25391, 14038, 26688, 8982, 48995, 8152, 59488, 10179, 13775, 10162, 31999, 27727 +, 5023, 25703, 47052, 55666, 19161, 53699, 38360, 51085, 10321, 7503, 40473, 12722, 47002, 25009, 25014 +, 12532, 48826, 48608, 51556, 50569, 2646, 18244, 35903, 27993, 2748, 35391, 38173, 52875, 21905, 10172 +, 56954, 3280, 12227, 44006, 58946, 7740, 14058, 37307, 35177, 24379, 44810, 15650, 13453, 31813, 17011 +, 14819, 44345, 42189, 3427, 35901, 9110, 42425, 30497, 45014, 10419, 33245, 56757, 48592, 26121, 18663 +, 35116, 23075, 21943, 23696, 7082, 57242, 31436, 57492, 34549, 6614, 58223, 55711, 58616, 11676, 3876 +, 51980, 26495, 24574, 10521, 6274, 475, 19632, 48699, 7325, 4646, 35470, 40570, 1403, 414, 6691 +, 56418, 35531, 6119, 54714, 35579, 49553, 51956, 43367, 47045, 2857, 49981, 45268, 58568, 24950, 56944 +, 2445, 53282, 59791, 27019, 3803, 6065, 3846, 59787, 31116, 11171, 4433, 6587, 28094, 42189, 43353 +, 34785, 38607, 18884, 17256, 9673, 30815, 6809, 1629, 14183, 53854, 40838, 40516, 39122, 39407, 5466 +, 12418, 18204, 35100, 48561, 21575, 15256, 54626, 1773, 15043, 25743, 12945, 55829, 8682, 17391, 38018 +, 52035, 52176, 52977, 47272, 45785, 2651, 18087, 52594, 40632, 32270, 46449, 21471, 49139, 1923, 37230 +, 30957, 50694, 31786, 6058, 39255, 53361, 21314, 10234, 55134, 12709, 35977, 44431, 8538, 21011, 1822 +, 46556, 49398, 30351, 15886, 36670, 16136, 54889, 31110, 45082, 35521, 39732, 31531, 33344, 28871, 9807 +, 46926, 59829, 36853, 18712, 42239, 16108, 48425, 3553, 26342, 19912, 52614, 38671, 40695, 1153, 36034 +, 18870, 24061, 25433, 25573, 39947, 2103, 18061, 34836, 9565, 3143, 46710, 49298, 34675, 56406, 54521 +, 20834, 19685, 30702, 57687, 14749, 12941, 50147, 3175, 52846, 52842, 59439, 45461, 31513, 40134, 46614 +, 7548, 35356, 10675, 9333, 929, 26975, 47788, 18990, 1811, 57354, 22134, 24873, 23004, 33161, 21280 +, 17525, 53995, 17317, 48228, 28034, 32066, 1169, 18181, 35241, 30368, 11023, 11032, 15829, 18889, 51167 +, 2443, 2789, 2875, 49470, 12122, 3805, 16445, 59910, 22795, 54609, 57264, 21281, 19482, 56620, 54442 +, 17114, 14146, 24789, 34431, 38726, 29175, 6498, 16247, 23709, 18091, 46615, 11084, 29124, 2444, 29973 +, 56643, 41239, 32762, 59518, 7062, 21236, 39675, 23507, 21147, 2471, 18116, 54763, 104, 13951, 51384 +, 54547, 7417, 41882, 55688, 41849, 20608, 1216, 24699, 36855, 24925, 19142, 59823, 36009, 48266, 38619 +, 42335, 21261, 19859, 51449, 20780, 26921, 12686, 455, 26780, 10185, 39278, 21249, 4948, 39383, 35200 +, 32684, 10282, 42617, 14566, 42322, 818, 11526, 43538, 1869, 24734, 44815, 21012, 24557, 57177, 9278 +, 3176, 39512, 6892, 59387, 30961, 27672, 2660, 19999, 4479, 29441, 30184, 20110, 27042, 11485, 35845 +, 2242, 44169, 22479, 21211, 58736, 41153, 58382, 10262, 1044, 251, 11348, 45859, 21263, 35905, 43036 +, 6894, 15434, 58900, 13786, 14821, 6214, 17810, 17482, 26213, 58641, 23275, 56398, 18751, 50317, 7883 +, 30948, 28911, 28404, 29779, 26474, 3492, 10933, 1208, 50107, 11977, 1460, 1455, 34188, 59075, 37361 +, 53577, 5969, 52795, 52477, 19755, 43968, 58691, 37565, 37802, 24905, 12559, 37429, 57655, 31310, 4098 +, 41890, 38611, 9361, 10294, 8390, 35836, 13787, 19323, 13396, 3894, 7652, 14856, 5349, 41841, 13932 +, 19062, 35418, 56253, 48209, 4247, 16009, 32178, 2939, 29926, 46332, 4196, 42485, 23762, 1851, 50148 +, 27860, 20093, 28759, 37222, 30387, 13501, 49410, 20526, 32825, 2806, 772, 40477, 54015, 42474, 58670 +, 7947, 1536, 34088, 4200, 26098, 38336, 56561, 58276, 17627, 2840, 20960, 21823, 21677, 44722, 26 +, 11825, 12583, 20119, 16936, 26157, 26858, 30438, 15567, 47385, 39615, 54725, 24509, 56444, 48740, 6983 +, 55115, 33039, 44872, 5555, 13592, 10970, 20243, 10153, 45598, 37870, 49345, 6558, 36045, 11023, 27633 +, 36071, 59200, 16568, 56190, 16137, 42725, 59401, 22927, 34644, 46786, 2542, 29369, 47647, 58986, 54462 +, 54631, 54101, 27501, 15855, 36009, 41093, 26825, 56252, 27599, 48775, 34123, 16944, 31685, 10168, 27967 +, 59318, 22592, 27168, 52238, 18782, 19657, 34963, 54535, 42584, 45959, 41321, 21478, 51681, 5321, 20464 +, 46143, 59952, 50918, 13644, 15807, 26927, 54738, 18984, 59531, 58689, 44111, 33654, 15633, 15796, 20175 +, 19953, 51467, 42767, 23473, 43705, 37901, 43130, 55021, 32437, 2066, 40980, 50110, 23544, 9013, 55431 +, 20360, 55156, 31735, 47630, 45153, 23894, 14557, 16243, 19230, 50441, 14932, 3341, 447, 30565, 55490 +, 20622, 50518, 46957, 39741, 13991, 7014, 53995, 33473, 2035, 2784, 35539, 19368, 29246, 35435, 28381 +, 1030, 55796, 59890, 32765, 43426, 45043, 33012, 34336, 1286, 52242, 24777, 52570, 31936, 25224, 23135 +, 27426, 22199, 50006, 50735, 38292, 40349, 57749, 8639, 50175, 36137, 47775, 2066, 55505, 17022, 37502 +, 23886, 18052, 33298, 23776, 27169, 53076, 45171, 36533, 3764, 46457, 28776, 28541, 15379, 712, 30118 +, 38515, 4490, 28669, 4873, 55225, 43313, 21574, 52974, 51953, 11749, 29111, 39728, 13816, 968, 33102 +, 51318, 24855, 27506, 968, 24983, 31028, 30396, 46507, 7561, 34161, 9316, 12689, 39054, 24696, 49753 +, 45524, 3211, 54243, 50545, 44436, 49468, 33859, 6010, 42443, 2164, 17760, 47906, 41892, 31576, 48875 +, 51347, 59246, 50082, 18853, 36566, 51417, 26233, 6962, 37924, 33795, 17475, 47241, 22836, 56530, 11937 +, 12590, 42054, 51500, 6833, 32600, 35936, 56302, 42811, 41946, 15097, 44975, 36058, 39355, 3219, 43986 +, 4582, 54566, 43232, 54664, 49772, 56150, 46082, 52357, 3113, 24006, 2504, 20588, 47599, 25341, 53470 +, 59536, 37931, 11877, 51036, 21116, 20829, 3324, 17418, 3640, 21623, 8867, 48615, 57681, 48223, 28186 +, 41668, 52805, 59105, 1252, 23822, 48877, 57403, 46256, 17586, 36868, 46614, 20091, 33808, 34214, 45432 +, 27279, 10102, 59715, 39156, 1139, 20831, 59985, 40815, 14602, 3625, 2438, 59821, 28592, 120, 48044 +, 56778, 18140, 17202, 55883, 55744, 17376, 21112, 53147, 3632, 38699, 6367, 50246, 35142, 40176, 812 +, 56926, 7455, 10915, 56641, 46611, 48406, 53824, 22948, 29221, 8426, 26573, 31660, 8248, 31517, 8132 +, 32644, 4647, 26272, 26198, 36883, 22016, 43574, 57995, 51516, 23558, 13046, 57883, 50157, 24540, 14411 +, 50969, 21466, 21866, 1884, 18107, 44829, 50290, 48284, 7777, 55864, 56710, 10702, 27524, 41310, 42219 +, 12008, 50307, 23219, 14632, 16505, 102, 36648, 36432, 58097, 4516, 36342, 47496, 38752, 26499, 12036 +, 53163, 17469, 9855, 15030, 55705, 4314, 36211, 22348, 52598, 43989, 18212, 25661, 31043, 22088, 6971 +, 49615, 10448, 33630, 12834, 25080, 50136, 12936, 1728, 2920, 47385, 42597, 39262, 11233, 21349, 42114 +, 59622, 50864, 35935, 9477, 42246, 31640, 13791, 18458, 30340, 6390, 38799, 24904, 32051, 9842, 46992 +, 15374, 35809, 57440, 49005, 48643, 22520, 15493, 37931, 601, 54765, 25317, 19550, 10379, 36550, 17251 +, 52493, 12524, 8115, 28428, 22001, 50362, 36421, 35793, 8820, 6761, 18535, 23971, 31666, 26938, 10165 +, 55010, 42312, 45975, 28803, 7669, 34618, 27675, 23162, 12550, 4628, 17927, 14219, 24178, 4659, 27121 +, 41429, 57152, 39646, 25897, 1933, 1647, 16259, 14706, 13792, 1431, 57819, 32327, 1754, 5837, 35617 +, 11919, 848, 17930, 57894, 6003, 1951, 32513, 33678, 25114, 21415, 14659, 19393, 35634, 38837, 24052 +, 2755, 56619, 57557, 42401, 58868, 59490, 20401, 51479, 50548, 10545, 52910, 48367, 42873, 54664, 54205 +, 54842, 6583, 31405, 12772, 40830, 37408, 14724, 13343, 11086, 16190, 34758, 25745, 11935, 46744, 40935 +, 12340, 49499, 13906, 9897, 8253, 12774, 45739, 28654, 4253, 36287, 39199, 33515, 1006, 58424, 4531 +, 55211, 53267, 47466, 26616, 42391, 28296, 4024, 33467, 17991, 51463, 26009, 29101, 53560, 37945, 15845 +, 10847, 26637, 5345, 24753, 36534, 49950, 13879, 58625, 18604, 54484, 11264, 34155, 27999, 12270, 8932 +, 8882, 7482, 2199, 56349, 10450, 20942, 997, 14475, 30762, 18989, 42290, 56771, 48090, 12202, 11068 +, 3936, 23050, 37705, 45633, 24155, 50591, 35583, 38035, 49216, 30539, 8871, 480, 41046, 13223, 49103 +, 49978, 22105, 56585, 28529, 54806, 7035, 49472, 55804, 57862, 56586, 51145, 16504, 29709, 39235, 28707 +, 17130, 19523, 51757, 54835, 41508, 15912, 21779, 53443, 30299, 47347, 23982, 39171, 24180, 5029, 52394 +, 13283, 31359, 14499, 9868, 59889, 45658, 53255, 25713, 17814, 27470, 22299, 8959, 43974, 28360, 24546 +, 12681, 45490, 20422, 40790, 16678, 1930, 56703, 38457, 55374, 27002, 25804, 55708, 42525, 26336, 37089 +, 34919, 39619, 8449, 25771, 49487, 44690, 47781, 19095, 10403, 5595, 46565, 9054, 14554, 6891, 37414 +, 39100, 19573, 22905, 59522, 363, 39583, 37805, 33418, 54392, 9531, 36773, 56548, 5239, 19298, 22885 +, 18681, 30570, 2504, 3482, 56341, 28344, 48172, 44122, 47439, 58575, 49717, 10356, 7629, 40623, 17247 +, 21395, 19723, 36820, 44300, 55598, 13536, 23883, 33403, 46954, 54627, 42934, 23727, 51176, 24525, 19378 +, 14061, 43206, 49948, 16565, 46688, 22641, 44909, 11212, 43115, 8700, 9787, 9184, 19056, 53768, 49807 +, 12656, 15164, 45882, 49476, 35816, 17832, 39364, 36052, 51235, 2671, 30679, 10521, 2750, 21855, 35047 +, 22128, 35916, 54605, 48428, 28834, 17646, 11069, 50095, 28858, 30536, 35148, 14998, 39720, 54204, 45118 +, 5879, 6860, 282, 51762, 32689, 36099, 9594, 48405, 12151, 37182, 51076, 19182, 47703, 53827, 41038 +, 59102, 52307, 53306, 30060, 40736, 58492, 47706, 28157, 48588, 52916, 58694, 23736, 7914, 38414, 54292 +, 29385, 44294, 37505, 29667, 12408, 46546, 42118, 58354, 34951, 30621, 35536, 2380, 49804, 59592, 56207 +, 7194, 58694, 24866, 500, 28754, 5602, 58993, 52812, 10112, 47581, 45729, 8806, 47669, 29995, 23572 +, 18313, 59380, 44218, 55818, 5400, 56626, 18716, 47518, 54981, 53668, 54492, 6869, 56048, 44296, 6461 +, 28607, 51490, 41508, 29825, 28342, 10262, 35428, 27335, 39427, 21892, 51268, 25156, 30698, 15289, 31503 +, 54270, 33603, 30884, 14841, 5773, 36284, 11467, 24490, 154, 42800, 54510, 30998, 26022, 50558, 51646 +, 8835, 55517, 43136, 50343, 25342, 47831, 36958, 37122, 51518, 16385, 59014, 42787, 17893, 6064, 34428 +, 49396, 36687, 8031, 20280, 51528, 50157, 32916, 39347, 14647, 9423, 58500, 9157, 40421, 24522, 36067 +, 32068, 33357, 7936, 51556, 53, 33278, 39387, 37011, 46753, 30906, 53396, 22119, 50045, 11289, 4536 +, 24473, 685, 41223, 8857, 57318, 9103, 59014, 6586, 48450, 50013, 16009, 46950, 59170, 56431, 47824 +, 11589, 4851, 57534, 19525, 56407, 57587, 29155, 12147, 34598, 15908, 43053, 4346, 14380, 9450, 51987 +, 18916, 10275, 29024, 36491, 19132, 26342, 45594, 54498, 9281, 34044, 44511, 25290, 57347, 43681, 58073 +, 45171, 55270, 2924, 19057, 14795, 59332, 16644, 20303, 11479, 27594, 12563, 30884, 8292, 26943, 40334 +, 279, 22211, 50609, 29304, 58702, 46094, 31998, 44296, 40592, 41279, 18341, 25104, 42922, 52040, 45137 +, 40995, 13563, 16760, 43920, 32621, 31555, 43252, 25617, 28210, 31083, 53212, 40774, 1967, 37856, 7717 +, 18653, 38136, 29929, 45614, 43792, 4983, 31708, 52142, 49280, 48653, 33422, 43973, 50109, 16344, 36013 +, 35246, 57339, 49576, 52006, 41259, 22197, 59914, 863, 47815, 28124, 31946, 17379, 8898, 10265, 55235 +, 52968, 5270, 9723, 59249, 50885, 29867, 4232, 58945, 22010, 29864, 23950, 55432, 13837, 14059, 48128 +, 49850, 49306, 21819, 39427, 17664, 39431, 37976, 17578, 40294, 2143, 22055, 48593, 19522, 7305, 35210 +, 51110, 36625, 40481, 37185, 35874, 7718, 7053, 16459, 6663, 29063, 46323, 30614, 847, 161, 21025 +, 25327, 26363, 10331, 47146, 5790, 4348, 2929, 20119, 21926, 19576, 22262, 20333, 8169, 18137, 27639 +, 19731, 45599, 4264, 212, 22784, 16491, 7930, 6189, 32950, 50946, 11604, 55625, 57912, 48803, 32138 +, 18937, 14130, 58502, 5621, 37629, 40644, 9969, 16910, 763, 8247, 36486, 23026, 28581, 44655, 17515 +, 32572, 4387, 3114, 36836, 40951, 2250, 29679, 48882, 8440, 38981, 39828, 56396, 34607, 37740, 45200 +, 43097, 33029, 35682, 17951, 38650, 49663, 58596, 48619, 6574, 35711, 33219, 43060, 35089, 1800, 4068 +, 52604, 34372, 44807, 55718, 47560, 25758, 57969, 17240, 50992, 42761, 32573, 7172, 15509, 7180, 21264 +, 37061, 26630, 54294, 12744, 44581, 32944, 38759, 43177, 57916, 21685, 18889, 31135, 41098, 30330, 9287 +, 21518, 22935, 20011, 6325, 55005, 43923, 8435, 29326, 37515, 35780, 12087, 10089, 42952, 3949, 53621 +, 40569, 41010, 20251, 34863, 30106, 4833, 44159, 8866, 24362, 42075, 6903, 19603, 49562, 24353, 49934 +, 35201, 45871, 12869, 55212, 28548, 44226, 39136, 13336, 13553, 53003, 49116, 1992, 3092, 8420, 5941 +, 56714, 48989, 46952, 53317, 204, 17058, 58150, 44364, 2276, 22513, 2791, 45532, 42116, 28706, 9885 +, 8402, 3907, 55757, 57623, 35472, 24305, 41850, 14608, 13993, 55403, 43963, 3109, 57395, 47056, 47882 +, 3337, 20122, 36871, 26641, 13439, 13428, 20051, 11590, 57792, 22328, 10455, 36935, 7860, 28923, 5641 +, 54097, 37326, 45901, 49854, 34949, 21373, 50512, 53151, 12333, 40857, 48554, 56296, 43967, 22302, 19704 +, 31849, 1991, 39826, 45072, 28632, 53266, 58500, 48683, 41208, 32644, 47363, 28015, 45932, 31575, 33290 +, 27925, 25673, 10616, 13826, 51879, 21918, 11551, 18743, 51421, 236, 59601, 39976, 56533, 19920, 38630 +, 52589, 28121, 40621, 32416, 49545, 45605, 2034, 48046, 10640, 19594, 57042, 58004, 23961, 42974, 5931 +, 57251, 10900, 7956, 7868, 1078, 36188, 6138, 12630, 31283, 57559, 12866, 7236, 13887, 45751, 27156 +, 52517, 38341, 55277, 33138, 47109, 21175, 55095, 25495, 9221, 5736, 45089, 42615, 40092, 9050, 1942 +, 46023, 6301, 12842, 30332, 50521, 50272, 42872, 33011, 39254, 14155, 6923, 28473, 21392, 20810, 50576 +, 24900, 13328, 28917, 56530, 22818, 52378, 17705, 17914, 17873, 26926, 2, 39314, 45893, 40094, 24716 +, 47835, 2469, 31018, 37029, 32801, 57891, 27302, 15673, 30903, 42908, 6181, 37826, 11381, 27573, 34988 +, 1958, 52473, 24668, 7227, 49003, 47487, 59606, 43060, 41753, 53831, 46338, 18107, 33146, 32232, 58201 +, 57862, 20067, 37022, 5232, 57097, 9824, 39476, 751, 1849, 10379, 43659, 44382, 24557, 31393, 48307 +, 59545, 33351, 40781, 24214, 16930, 6136, 48053, 52888, 49197, 6158, 46720, 35535, 617, 56218, 44119 +, 58818, 30432, 40539, 35840, 35665, 37636, 22016, 15141, 14739, 218, 1872, 34750, 44600, 2781, 6143 +, 32908, 38678, 15846, 50041, 39244, 9129, 32529, 3649, 2017, 58078, 9807, 25089, 9966, 10424, 57659 +, 54085, 45594, 28092, 34624, 57787, 40109, 48612, 56155, 31602, 39703, 56373, 9826, 14454, 17326, 12607 +, 56949, 26586, 51285, 49148, 52979, 30530, 58277, 25508, 34179, 36646, 59939, 20339, 1736, 9905, 7115 +, 59395, 40342, 29062, 3839, 51319, 26849, 20300, 39931, 23004, 51902, 55987, 55730, 1728, 10441, 13056 +, 50687, 43742, 39642, 41973, 32890, 8973, 48855, 7519, 34481, 59386, 44166, 34420, 56077, 22254, 20677 +, 3193, 58001, 37372, 32255, 1841, 28691, 35456, 58493, 44974, 58460, 50396, 40961, 54190, 28476, 27754 +, 43598, 19164, 11497, 59592, 37489, 20739, 8565, 2696, 28259, 19399, 2082, 48777, 30171, 58160, 47383 +, 50849, 37705, 45384, 28221, 46312, 23577, 56912, 21768, 22071, 41886, 56580, 48819, 59200, 27123, 17295 +, 26954, 10721, 12811, 38451, 10314, 50300, 35543, 55231, 52996, 40154, 14630, 31431, 28931, 44802, 5943 +, 52666, 12003, 20000, 38050, 16576, 6312, 1628, 49840, 28080, 51, 8078, 1012, 48870, 7278, 28135 +, 42517, 34233, 38857, 55329, 49036, 25523, 45629, 24579, 57106, 14978, 41085, 11737, 22761, 46368, 56539 +, 5056, 39034, 44894, 25056, 17085, 1470, 31368, 55065, 51310, 35800, 31468, 59388, 36812, 20338, 6667 +, 4948, 2855, 17252, 20157, 58184, 6288, 45680, 20166, 7220, 42786, 11496, 48305, 30875, 10609, 11026 +, 3766, 15665, 50060, 48660, 40721, 43497, 50130, 48441, 38562, 17792, 24241, 10030, 17181, 1053, 6720 +, 200, 42353, 45928, 17452, 2510, 20464, 23740, 48190, 40630, 7312, 7329, 28478, 31970, 38204, 39087 +, 42996, 18323, 31104, 33056, 6983, 48177, 16554, 33466, 36618, 31468, 51258, 859, 17851, 44791, 38265 +, 24571, 44991, 20618, 10499, 38795, 23129, 30964, 38888, 47671, 47946, 46200, 55000, 52777, 18170, 9557 +, 8216, 1166, 4232, 39321, 10575, 11215, 27498, 27129, 21033, 40469, 58597, 48644, 41328, 52800, 33435 +, 19593, 17372, 54779, 16564, 4223, 33574, 39693, 11539, 12462, 27364, 59486, 35015, 58717, 28615, 53185 +, 44626, 36831, 30704, 48858, 16152, 41279, 36425, 20003, 44760, 57459, 472, 19709, 22455, 18152, 12510 +, 55890, 14098, 6234, 27021, 30662, 10457, 596, 10355, 21997, 49410, 14071, 57835, 777, 49140, 2802 +, 53963, 10118, 39633, 1019, 58976, 32138, 18650, 11754, 28493, 3410, 45565, 5317, 23119, 8020, 23469 +, 11981, 40262, 37567, 18215, 7284, 44581, 5025, 44232, 54936, 3374, 33642, 45360, 37561, 10772, 10852 +, 40363, 41087, 20971, 19996, 42106, 19947, 28486, 756, 8053, 56979, 40518, 53618, 2296, 39989, 1638 +, 25766, 51971, 41901, 39685, 46538, 25537, 24267, 51563, 9769, 55555, 54937, 19763, 17267, 32498, 30535 +, 28120, 12861, 11622, 49091, 9210, 30080, 45390, 14048, 30836, 53444, 11028, 47706, 23414, 49676, 27696 +, 1405, 51794, 19667, 43306, 31480, 42557, 45195, 32099, 34121, 54964, 4006, 29058, 14727, 21274, 37909 +, 21615, 49394, 27122, 33237, 38485, 12684, 3318, 227, 26733, 10506, 53671, 37761, 58213, 53438, 27437 +, 2261, 54843, 19232, 58280, 14501, 27064, 40837, 59696, 35515, 14958, 54660, 39521, 20369, 45739, 795 +, 58278, 7354, 50189, 1752, 16944, 5026, 14437, 56614, 41606, 41170, 7120, 11629, 18931, 41685, 5067 +, 22720, 43946, 59910, 18304, 42226, 14411, 21720, 23064, 14107, 57235, 14374, 45119, 36757, 34743, 7211 +, 37552, 9373, 14565, 4094, 11126, 7861, 45472, 25563, 4475, 27078, 6733, 47948, 38708, 2016, 5985 +, 20127, 1088, 26284, 20038, 19393, 44862, 34449, 17465, 44278, 24909, 14701, 58653, 10028, 27810, 9748 +, 17239, 41714, 19122, 8157, 22160, 30248, 52370, 7633, 55811, 33198, 11063, 38896, 57498, 26123, 17264 +, 3483, 46251, 18352, 29767, 6289, 14097, 14630, 17090, 31563, 35260, 41999, 22616, 33913, 28380, 50426 +, 43662, 21971, 32140, 2784, 30128, 54301, 9384, 58851, 38286, 41547, 32049, 25701, 20443, 29547, 51825 +, 37707, 33030, 14428, 32411, 39150, 57069, 46509, 30132, 50511, 18072, 5392, 32511, 17040, 15658, 37243 +, 7466, 59320, 59214, 15958, 38456, 5695, 10259, 24192, 4546, 24897, 5739, 12947, 50599, 2534, 42494 +, 18776, 16593, 51876, 9556, 49004, 7378, 6625, 35513, 37510, 57136, 29937, 19255, 5999, 46977, 11265 +, 19594, 30795, 10585, 18809, 46754, 25393, 856, 33365, 49585, 5402, 58263, 31676, 18349, 25214, 34210 +, 37195, 20342, 50803, 29071, 29898, 39807, 36450, 12875, 51673, 50312, 46363, 21610, 45919, 28715, 8588 +, 57184, 48309, 39383, 44121, 7118, 2489, 45866, 7974, 35855, 11803, 49728, 10470, 43479, 44429, 12036 +, 17689, 21624, 32378, 44844, 50696, 2276, 24652, 3498, 51503, 52677, 30162, 37866, 14287, 52434, 6581 +, 59227, 49618, 54891, 14963, 10092, 38361, 17452, 55958, 22688, 29659, 7762, 12416, 16481, 51241, 33198 +, 28517, 45283, 54822, 895, 30127, 21870, 39523, 31131, 25368, 31026, 23808, 31883, 8893, 14448, 24317 +, 51826, 13675, 50287, 46717, 28638, 379, 1431, 22443, 56338, 24119, 52102, 40452, 12887, 8584, 8045 +, 46085, 37101, 53328, 40908, 14349, 59808, 2778, 53872, 30939, 4499, 1251, 31100, 36382, 46496, 45548 +, 699, 38322, 35575, 50986, 25040, 4214, 27718, 26471, 26657, 408, 26942, 55111, 40860, 39829, 3695 +, 48905, 25915, 17149, 18586, 43175, 7850, 18394, 45953, 38074, 25685, 26804, 39325, 56785, 3186, 25821 +, 18685, 40237, 40496, 54261, 7576, 5536, 34827, 35294, 8359, 37836, 12054, 11653, 32947, 52914, 51482 +, 12995, 18171, 53749, 6496, 36757, 36924, 14346, 55151, 59230, 52420, 57189, 26034, 8098, 53974, 5573 +, 33919, 49012, 45810, 50767, 19625, 29738, 32655, 54452, 41384, 41014, 32288, 53438, 29019, 41587, 46352 +, 20502, 54582, 40876, 50603, 1078, 17633, 27528, 51776, 49137, 3110, 44197, 46326, 5496, 52295, 16652 +, 11069, 2566, 5664, 33232, 53334, 25289, 2970, 25989, 56093, 44355, 43356, 28381, 14145, 12375, 46321 +, 498, 9229, 40903, 17726, 59833, 18334, 35359, 3713, 10110, 24496, 6823, 54307, 10822, 12319, 22954 +, 3827, 59741, 1873, 9491, 32973, 55207, 11133, 35943, 57548, 7226, 56650, 17256, 11960, 10796, 29632 +, 58281, 47646, 15213, 15536, 5372, 15046, 33870, 17083, 55111, 20333, 17932, 38286, 50992, 5106, 50606 +, 13947, 8933, 26699, 15820, 18425, 59672, 47379, 5910, 11967, 44927, 49488, 44970, 2184, 1448, 32118 +, 8168, 36081, 19764, 59733, 27970, 1488, 14780, 1840, 54923, 46243, 58525, 12855, 24530, 49518, 17962 +, 51488, 3465, 26895, 18187, 55637, 21672, 17859, 43016, 27582, 6178, 4295, 17071, 51148, 42831, 54871 +, 59618, 27351, 7305, 19382, 27085, 35275, 57222, 18217, 13467, 52146, 4460, 11993, 41353, 28990, 1511 +, 59315, 56830, 41328, 2563, 15017, 36965, 24235, 9228, 56333, 28170, 51759, 36980, 21593, 19259, 19812 +, 16464, 18878, 23515, 23769, 38260, 50600, 59044, 11835, 45169, 12512, 40333, 49630, 857, 21686, 54972 +, 2368, 57354, 51803, 43696, 36269, 43172, 20661, 504, 52401, 53346, 5026, 44160, 30326, 26619, 3419 +, 26490, 43084, 22297, 50006, 43205, 36910, 16958, 18602, 25097, 2128, 31114, 41782, 51758, 8323, 39820 +, 23082, 10691, 37174, 51237, 54387, 13443, 34410, 51400, 50300, 3163, 44746, 55326, 23675, 51424, 21946 +, 3446, 17915, 41382, 25744, 44273, 24587, 39006, 1231, 43189, 40455, 3359, 50655, 22237, 31469, 58978 +, 2057, 30904, 9669, 15584, 22141, 40408, 5379, 32903, 31808, 55679, 36066, 52906, 27358, 59741, 20683 +, 49304, 3188, 14950, 30686, 5284, 59223, 31625, 20642, 36806, 14815, 1097, 40166, 5470, 59686, 47987 +, 40801, 1743, 18891, 26822, 53679, 41033, 7231, 59059, 13936, 15391, 31090, 26355, 44650, 58448, 26096 +, 5333, 24104, 5636, 56635, 54790, 10920, 55858, 26416, 31562, 32664, 17583, 9011, 49182, 59405, 8697 +, 37170, 40206, 46793, 32413, 43381, 16824, 49798, 50612, 15883, 3735, 42355, 46974, 6442, 27005, 21774 +, 8890, 8690, 45879, 14527, 5325, 40669, 1799, 37535, 43437, 9714, 46552, 37372, 18725, 35734, 36778 +, 3775, 49256, 53336, 26920, 21670, 36717, 43744, 11468, 3681, 59628, 51555, 46037, 22954, 57997, 13042 +, 44728, 6888, 58085, 30607, 21415, 3410, 47629, 59566, 17298, 7418, 9280, 3850, 44791, 28006, 15936 +, 57921, 8133, 5193, 27609, 35053, 26863, 4327, 55149, 14683, 44360, 31129, 6239, 30397, 54083, 40588 +, 19792, 15164, 23828, 17877, 22123, 21595, 57639, 46104, 21162, 51289, 29875, 30442, 55139, 51018, 34800 +, 11076, 48939, 42933, 52621, 52900, 54338, 55836, 57227, 49488, 10519, 17940, 56969, 53110, 48337, 27405 +, 10051, 44481, 42569, 33879, 38710, 41044, 55475, 12702, 3501, 52989, 3991, 33376, 23431, 35483, 24394 +, 34584, 22911, 49685, 17517, 15532, 42585, 48208, 11368, 16165, 14048, 58239, 34105, 11017, 27702, 58794 +, 14774, 14105, 43276, 57343, 47984, 21986, 14740, 19811, 34688, 18241, 12800, 15032, 51617, 12584, 50515 +, 52363, 47168, 13426, 42048, 41037, 28958, 24633, 29245, 16678, 40798, 19645, 51269, 14903, 7015, 55323 +, 13698, 21789, 9428, 33326, 55485, 33765, 31664, 46577, 29928, 6353, 4818, 42729, 57737, 32787, 31665 +, 48252, 1502, 18833, 1678, 43550, 59870, 6988, 8183, 5468, 18, 25334, 1465, 27639, 40237, 44832 +, 22963, 30287, 6622, 8743, 39965, 38459, 18860, 11630, 25036, 48789, 54335, 6206, 7870, 52072, 15345 +, 39535, 40324, 16847, 34720, 18354, 36749, 10942, 25342, 21284, 16410, 1712, 46618, 54228, 29351, 3208 +, 39060, 52314, 9847, 22034, 37410, 49813, 493, 56270, 1443, 1881, 45059, 55778, 44439, 52929, 47850 +, 59784, 8816, 4526, 52983, 43536, 22880, 29732, 54479, 24574, 51017, 47241, 26286, 13987, 41469, 55637 +, 17195, 56882, 24304, 27043, 18916, 1714, 16856, 55762, 57984, 54651, 57643, 19396, 26781, 18435, 48677 +, 50983, 18219, 57494, 55509, 11203, 17382, 54741, 17287, 48213, 55667, 8304, 35455, 58305, 22292, 53276 +, 53942, 15839, 26510, 54598, 19234, 21779, 56312, 12442, 17541, 30649, 7093, 51536, 26397, 33874, 9971 +, 15074, 24857, 4543, 48920, 56718, 15746, 6303, 51459, 9385, 30868, 23478, 17690, 42675, 21783, 16334 +, 35952, 15726, 8525, 38814, 46676, 27760, 593, 19341, 40202, 54486, 49990, 23648, 46023, 16387, 57522 +, 32346, 7813, 58732, 36889, 56734, 55450, 28987, 39389, 23262, 14725, 10257, 46740, 8767, 52933, 8524 +, 25101, 5237, 602, 9978, 44051, 23630, 37738, 44645, 42971, 54293, 15483, 32961, 17941, 37858, 25700 +, 15463, 10205, 33514, 50547, 23446, 6600, 45998, 28786, 45989, 45612, 43511, 56246, 8704, 52278, 49179 +, 17228, 53731, 54416, 54182, 40061, 14820, 17813, 17800, 59465, 37136, 12093, 51300, 10098, 6386, 29159 +, 12150, 21849, 39364, 22016, 48749, 39162, 28616, 34747, 44300, 14605, 56711, 4163, 47204, 5415, 56441 +, 36383, 58996, 26524, 7152, 29530, 6586, 21972, 47343, 738, 57789, 24480, 49183, 49089, 10930, 55569 +, 18248, 59432, 53770, 33964, 57801, 42519, 49479, 26417, 17266, 33779, 17375, 50329, 37943, 4579, 55745 +, 10736, 17314, 54741, 13613, 24466, 24271, 20199, 22790, 47967, 57289, 20579, 48799, 46472, 9669, 36081 +, 42041, 4269, 35513, 35811, 38234, 9666, 18331, 27713, 12436, 11949, 37844, 29811, 2279, 15787, 10742 +, 34376, 2876, 4408, 29117, 16489, 28875, 29740, 13040, 51665, 17707, 10329, 48597, 42858, 56801, 58266 +, 18939, 15194, 2535, 30805, 27357, 17121, 40471, 45688, 21186, 52907, 33990, 59031, 59070, 12621, 51170 +, 9812, 46997, 54046, 14221, 52466, 46887, 19448, 22206, 59927, 47465, 16266, 10256, 36062, 59124, 43409 +, 10680, 18064, 58603, 13216, 25221, 25961, 6689, 5692, 48001, 27876, 34952, 58343, 26907, 34022, 10964 +, 54429, 20187, 57961, 48476, 10760, 50427, 35363, 6560, 48986, 11643, 54025, 5252, 58251, 30088, 4376 +, 41661, 40768, 58792, 16616, 30336, 24013, 18929, 13378, 6058, 43283, 41254, 41010, 41626, 44513, 51384 +, 28943, 38942, 11571, 26904, 3770, 58683, 53684, 15486, 5243, 19022, 27129, 59269, 24274, 25380, 5709 +, 5002, 43393, 22829, 3795, 36362, 29518, 27808, 55291, 42896, 33866, 14926, 502, 51228, 56553, 45015 +, 42613, 25496, 309, 30536, 28752, 4080, 5572, 58788, 55918, 10815, 17810, 59399, 46436, 18436, 1131 +, 28497, 23439, 44525, 27679, 3586, 57239, 57197, 31394, 28882, 16445, 41613, 43809, 16947, 9193, 16714 +, 38314, 28158, 18562, 38623, 35047, 23666, 19055, 40619, 22455, 14973, 27786, 16617, 14372, 14223, 11406 +, 51856, 19072, 34845, 36381, 46751, 38431, 9972, 43948, 46177, 38854, 393, 4142, 59015, 53692, 13336 +, 15729, 32006, 41494, 34291, 46982, 16541, 57958, 6037, 33512, 56765, 57363, 1299, 49734, 48087, 51874 +, 1140, 39943, 10946, 12337, 52676, 57698, 27120, 39000, 17998, 13298, 17855, 54744, 53792, 16870, 48436 +, 7128, 8952, 56795, 24975, 19595, 43777, 17868, 17553, 26166, 51381, 50670, 59881, 29032, 16757, 24321 +, 20906, 17897, 4264, 8204, 6587, 33293, 5902, 33707, 12293, 253, 23357, 6500, 54997, 17150, 23371 +, 19785, 24278, 32323, 16580, 25605, 51918, 36709, 43474, 45824, 39228, 11207, 12846, 39109, 16591, 29603 +, 3430, 37497, 23853, 44047, 22053, 30440, 17340, 4308, 4147, 5985, 4561, 27505, 12486, 59558, 21007 +, 12209, 55695, 21637, 20884, 48628, 47243, 49154, 25337, 7069, 11330, 40917, 54628, 24177, 20027, 11219 +, 30132, 59809, 25068, 53985, 43856, 47121, 777, 37548, 51429, 41277, 19886, 32342, 45134, 32372, 31900 +, 6141, 20933, 3948, 27778, 41817, 52576, 51373, 30971, 54265, 58442, 42302, 35183, 29422, 42831, 31562 +, 40641, 12963, 31371, 42061, 43301, 51580, 29183, 20430, 5480, 56964, 1707, 25366, 29307, 46841, 34090 +, 37559, 29334, 55023, 41507, 57113, 36840, 10435, 48486, 44164, 4701, 23281, 26466, 39884, 52703, 9297 +, 11446, 9697, 58612, 19169, 51758, 18265, 10749, 57293, 38696, 16230, 30610, 40403, 17948, 59917, 3597 +, 52039, 13828, 32931, 23414, 31688, 6396, 36607, 42123, 31235, 20771, 46824, 54516, 23589, 3060, 23571 +, 9238, 50858, 9620, 44202, 10028, 37731, 2468, 20777, 35024, 41164, 13359, 41986, 57919, 31308, 18255 +, 37868, 59699, 32084, 10800, 59465, 40124, 53548, 36072, 22247, 24783, 33195, 45424, 55651, 56784, 24836 +, 55575, 42374, 15695, 5195, 26577, 25723, 42926, 29045, 22852, 54303, 46561, 12564, 36289, 20832, 20224 +, 54545, 58701, 19923, 2981, 45853, 55740, 43105, 39401, 31813, 41704, 4185, 5008, 3480, 36188, 38145 +, 28317, 31763, 20519, 20364, 36959, 47096, 46087, 19885, 52493, 45291, 50540, 15406, 57855, 26830, 36239 +, 54431, 57727, 34940, 14354, 37060, 20793, 10095, 56517, 194, 18260, 38221, 40731, 59620, 41702, 16920 +, 37765, 46371, 48683, 34637, 6735, 1994, 21733, 29174, 58232, 50579, 14465, 48772, 5985, 48673, 51954 +, 42224, 19456, 26033, 17164, 33811, 3093, 14309, 20258, 35962, 50856, 14870, 14184, 31587, 14490, 32238 +, 24859, 52256, 18609, 13543, 26893, 25344, 51889, 24978, 30870, 50121, 51909, 21687, 15246, 57895, 46712 +, 43552, 16471, 6169, 9586, 9988, 16332, 49031, 24297, 12942, 24994, 15153, 27812, 15530, 23093, 42302 +, 47768, 47952, 10910, 42729, 37847, 14155, 44425, 29737, 15486, 15295, 56210, 7395, 36982, 11456, 41642 +, 23695, 31361, 34466, 29864, 40947, 44454, 46196, 6330, 45103, 59138, 7676, 257, 3302, 23206, 23350 +, 21956, 47326, 47654, 9219, 30055, 25502, 23374, 14480, 31591, 15212, 29775, 27801, 58960, 43110, 15610 +, 40602, 43157, 46971, 15068, 49373, 4270, 35874, 35569, 46952, 20978, 11059, 54629, 57587, 50713, 54187 +, 57289, 12669, 41514, 44943, 21888, 47921, 46797, 21615, 2402, 18388, 36827, 8529, 22542, 35787, 27991 +, 14504, 52742, 11148, 37827, 44162, 521, 18449, 56389, 12442, 5401, 17367, 59853, 36382, 14954, 50566 +, 30570, 12243, 39588, 48436, 57186, 1476, 36357, 43984, 23091, 38759, 38724, 36271, 23641, 37618, 48410 +, 51632, 52122, 17504, 2781, 6301, 38019, 39654, 24750, 34408, 52097, 6504, 51775, 51950, 42886, 43081 +, 18869, 13456, 55324, 58457, 1892, 28862, 59933, 38250, 49198, 59377, 53361, 27923, 12000, 53354, 41893 +, 410, 44987, 34016, 54267, 24120, 40317, 32286, 40126, 41420, 6694, 32223, 47924, 58469, 526, 30810 +, 17902, 55747, 20619, 13226, 54204, 58863, 42088, 30489, 13465, 7639, 6218, 43179, 35562, 18218, 36533 +, 17455, 54981, 57872, 27823, 49248, 21992, 44493, 21534, 2119, 2265, 28228, 10694, 50189, 3049, 47572 +, 57351, 20951, 43319, 54322, 10529, 37523, 53186, 28969, 44365, 43003, 36608, 50583, 26182, 48522, 8802 +, 2716, 42330, 3783, 588, 10153, 53031, 58933, 30998, 50917, 37404, 33263, 19145, 24450, 23452, 58546 +, 12023, 57156, 55849, 55342, 51478, 6378, 9218, 44664, 35347, 53583, 27668, 11956, 44166, 30202, 478 +, 29320, 32918, 42808, 9455, 9859, 29314, 38838, 45144, 312, 29755, 22548, 9928, 25252, 46998, 33380 +, 23798, 35373, 6888, 19647, 30716, 58367, 26025, 16286, 19383, 37725, 9869, 23403, 49681, 30387, 53606 +, 26511, 59708, 2876, 9320, 9163, 12735, 14986, 48002, 57879, 15298, 54109, 56779, 25226, 19362, 20130 +, 34959, 43160, 55503, 41847, 39160, 2571, 16566, 41537, 18857, 35950, 19262, 28726, 35705, 45295, 35466 +, 29311, 11807, 35174, 32188, 57479, 20689, 21275, 12465, 45043, 55507, 4115, 39153, 28638, 29342, 58515 +, 48768, 40653, 18027, 44272, 58852, 57187, 23195, 15419, 15077, 42053, 27721, 34339, 47131, 3426, 55987 +, 22597, 9090, 44146, 34123, 17630, 41625, 54813, 15257, 30442, 16208, 10764, 34557, 55361, 15755, 3899 +, 30228, 4523, 20904, 48256, 25147, 19757, 21795, 48343, 11528, 36872, 6748, 39249, 47564, 53879, 19027 +, 43551, 52829, 4469, 27697, 26952, 22099, 45674, 58117, 13709, 16116, 14326, 24473, 50673, 46039, 16580 +, 30925, 16268, 21104, 51829, 40876, 22603, 47938, 2671, 47298, 59466, 39544, 54046, 15067, 3460, 24278 +, 10447, 23363, 53459, 14916, 27412, 20411, 13368, 13086, 54881, 27077, 29202, 45559, 27902, 56227, 7950 +, 44483, 27152, 24218, 41939, 55334, 5094, 4542, 19624, 44118, 51841, 19091, 14, 22239, 10510, 3474 +, 46517, 20957, 26837, 39976, 12226, 54249, 36740, 1946, 43687, 7973, 29023, 49241, 53532, 56925, 45468 +, 1482, 17760, 48973, 2053, 59699, 20659, 43499, 4242, 40283, 27617, 32435, 35726, 3983, 54674, 46237 +, 7457, 17544, 43546, 10646, 57520, 32124, 41247, 10612, 34070, 24934, 18585, 39445, 14175, 48469, 36371 +, 35996, 26304, 30483, 1321, 4709, 30183, 21980, 48208, 10777, 2263, 52178, 43212, 37990, 56161, 37886 +, 579, 39971, 55430, 20477, 26969, 29303, 28954, 8217, 39915, 3024, 9503, 34853, 42470, 31, 59674 +, 55193, 12379, 25978, 25676, 13700, 30687, 32211, 35680, 55248, 42988, 14295, 23778, 2552, 28637, 56291 +, 40439, 5568, 36262, 12221, 26046, 39584, 17876, 31352, 24153, 34144, 34376, 10008, 8997, 53198, 10039 +, 45023, 24743, 58770, 11002, 50420, 12470, 18041, 58983, 24502, 49641, 41972, 38798, 13419, 44524, 43787 +, 9711, 1315, 49356, 22325, 49889, 51754, 1909, 7765, 23106, 26062, 18261, 33834, 36071, 3610, 3385 +, 22462, 48634, 28128, 21233, 59636, 54900, 10055, 54029, 53884, 34558, 43671, 35856, 49708, 57090, 56732 +, 9847, 43153, 58048, 59203, 5479, 24289, 27309, 43740, 8406, 50415, 46155, 26668, 602, 22226, 30278 +, 3987, 21040, 18912, 32115, 18625, 54900, 27016, 5033, 48930, 20900, 15943, 8953, 33108, 5651, 42395 +, 6192, 15498, 25549, 40592, 51054, 7380, 4881, 18363, 51120, 13288, 45131, 37275, 16308, 22085, 35853 +, 46586, 26072, 33246, 41851, 34539, 51871, 13103, 37907, 56904, 2033, 35159, 12847, 47338, 8267, 54850 +, 29734, 50812, 46701, 55283, 31404, 14107, 2663, 36286, 8822, 30135, 25926, 30305, 7411, 42234, 52390 +, 19616, 5172, 54814, 52862, 23375, 29354, 44734, 36479, 43613, 17990, 14864, 18773, 7190, 2203, 3392 +, 2040, 31937, 54204, 25093, 3572, 25609, 39200, 42587, 38247, 48023, 12722, 40525, 18328, 20133, 59111 +, 47071, 39750, 4283, 41885, 32612, 4011, 47591, 53698, 40490, 31205, 11689, 31706, 49978, 55231, 10261 +, 53370, 57271, 42198, 47575, 58717, 22122, 49536, 37917, 4709, 27783, 2292, 17432, 8308, 20621, 13917 +, 7419, 44044, 53667, 48054, 25929, 2632, 28417, 13521, 32682, 8907, 44726, 20723, 16966, 34704, 15954 +, 27227, 4426, 13226, 45778, 28353, 11943, 7900, 17889, 26212, 12610, 22024, 28505, 6394, 6684, 25478 +, 20311, 50455, 9522, 50331, 14862, 11803, 52963, 43279, 25324, 1997, 28539, 46402, 22721, 45505, 57458 +, 38675, 12732, 1885, 51901, 34862, 30238, 40196, 42763, 24480, 42761, 31725, 22856, 47618, 38119, 29541 +, 13096, 34782, 19996, 58970, 25113, 34858, 47125, 54428, 18138, 12450, 56426, 46677, 58852, 19147, 8534 +, 32663, 57822, 57618, 34548, 26076, 32481, 41138, 42624, 51596, 5618, 25385, 23321, 28475, 13003, 37792 +, 34368, 2451, 12574, 30716, 37773, 14040, 5575, 24899, 8468, 65, 13701, 4894, 23094, 48905, 393 +, 7980, 21568, 58216, 5598, 32468, 644, 38079, 13607, 43268, 29675, 55577, 45006, 29348, 404, 34361 +, 7140, 34772, 13165, 56067, 5489, 50938, 10107, 47416, 52189, 18575, 23833, 42242, 59822, 23279, 31148 +, 215, 31259, 29068, 34783, 36857, 1537, 35427, 51289, 15144, 18696, 57316, 10721, 40054, 26665, 11126 +, 14415, 10157, 22250, 27580, 6224, 27739, 54871, 52683, 51507, 47060, 47611, 15340, 5655, 47433, 38619 +, 36803, 24000, 9878, 42223, 58784, 23088, 43760, 10563, 14377, 58904, 29259, 48045, 45978, 45665, 14710 +, 33456, 81, 1220, 55706, 27661, 43796, 59798, 22532, 36480, 51305, 45945, 24091, 6646, 51600, 47876 +, 21617, 4755, 48228, 7848, 46978, 47012, 30936, 7091, 57576, 21665, 5995, 3187, 9710, 28325, 48853 +, 773, 38133, 25286, 1993, 10192, 52947, 22141, 9990, 51832, 58621, 37647, 14129, 59064, 20645, 42081 +, 23292, 42263, 46836, 11521, 50111, 10166, 34885, 57399, 17257, 32461, 19064, 59605, 12001, 5126, 4282 +, 37206, 5899, 42416, 2492, 44244, 52608, 31791, 6386, 38950, 23623, 41359, 16597, 14104, 40424, 37243 +, 56185, 40068, 55858, 19373, 51589, 45969, 5892, 26475, 19720, 59501, 35288, 38784, 59106, 23641, 43910 +, 39741, 847, 26162, 22157, 39691, 10406, 51117, 11483, 53144, 30067, 11458, 34504, 23016, 1915, 51280 +, 259, 58100, 31348, 56117, 53826, 22938, 18438, 59718, 25765, 38158, 59219, 1053, 53294, 34678, 1047 +, 13557, 50771, 38246, 39719, 12928, 17938, 26477, 40397, 5773, 19622, 46816, 53583, 30478, 9832, 55498 +, 21758, 10092, 29951, 29458, 42561, 129, 28748, 37352, 59847, 54513, 15510, 35418, 31919, 45157, 46448 +, 32966, 58714, 37219, 47564, 14785, 26499, 5502, 41262, 43248, 47627, 37236, 30064, 17563, 7714, 39897 +, 49413, 5824, 26341, 19364, 11635, 45254, 55845, 40383, 22606, 32044, 11249, 14469, 43815, 43168, 59626 +, 30263, 52486, 34692, 43835, 40050, 49477, 46686, 21905, 30739, 29935, 45884, 44328, 36351, 3447, 28394 +, 16248, 29213, 10571, 18941, 24929, 22206, 4196, 20775, 2589, 3154, 52819, 13838, 53975, 36634, 33358 +, 29953, 43250, 2196, 4645, 27085, 18599, 54122, 50123, 16856, 1214, 20058, 39092, 21894, 56410, 42540 +, 50288, 49010, 48105, 859, 7952, 13034, 59417, 48500, 33809, 2007, 51654, 26629, 52197, 21982, 3263 +, 1908, 51935, 46513, 40456, 56581, 49950, 59055, 27055, 40074, 52263, 4621, 36484, 31356, 2867, 9246 +, 13896, 53156, 58257, 2001, 30367, 42561, 51387, 29785, 7413, 25197, 8144, 35419, 51826, 36693, 57401 +, 31441, 38601, 49337, 54307, 19058, 22270, 20609, 54465, 25677, 37035, 46729, 30299, 13520, 18085, 33166 +, 22766, 8333, 2674, 57375, 46686, 9394, 16288, 38073, 15531, 23701, 3270, 23675, 59121, 31448, 36720 +, 56522, 39242, 15322, 22211, 33549, 10732, 44481, 30510, 41549, 10159, 7546, 28278, 16810, 21066, 22715 +, 26328, 20184, 31048, 5355, 53912, 54086, 14749, 10200, 32160, 30280, 33902, 11782, 30307, 9375, 43231 +, 7027, 42249, 22473, 58701, 4461, 32374, 45785, 25294, 39236, 27335, 11805, 46782, 31965, 4967, 44200 +, 54681, 31296, 40737, 2081, 13003, 34649, 56168, 4104, 21201, 28328, 10736, 31455, 40110, 41043, 40830 +, 59693, 24422, 59432, 58518, 59476, 3893, 30892, 45261, 5539, 10129, 48948, 17345, 33263, 20914, 22312 +, 17464, 15595, 29960, 34553, 54028, 42963, 9202, 50196, 47067, 6755, 18524, 57803, 38211, 34987, 15198 +, 55393, 34680, 39621, 54825, 9551, 39097, 58718, 16795, 710, 40610, 26924, 49659, 57955, 36540, 10573 +, 56619, 30356, 2520, 26580, 4909, 56548, 45895, 50463, 23097, 32963, 57218, 17973, 7118, 35429, 52960 +, 58669, 30823, 3993, 38290, 25648, 13544, 53739, 719, 30339, 30801, 41329, 33616, 20460, 15636, 46508 +, 7385, 12255, 16864, 46257, 15187, 21773, 19158, 1083, 48588, 42255, 10398, 45806, 228, 17516, 57588 +, 29541, 16185, 28411, 9886, 30827, 30411, 59782, 918, 7482, 6473, 31720, 25163, 16441, 28532, 17151 +, 2949, 12270, 5759, 56165, 58527, 20946, 54290, 54037, 22029, 42878, 36292, 8779, 28685, 12873, 26296 +, 26273, 18766, 18833, 31036, 28652, 26013, 37799, 4786, 26931, 21634, 11259, 35003, 46797, 27701, 39888 +, 40301, 7002, 52158, 46060, 3168, 27037, 7006, 57458, 21075, 5388, 40337, 33719, 14167, 45374, 22944 +, 16815, 47999, 41710, 12001, 55387, 46714, 38014, 9538, 51500, 41297, 31172, 2760, 52653, 54322, 6813 +, 32541, 34623, 13815, 1051, 57035, 53335, 28088, 4041, 27146, 25515, 45781, 7483, 35587, 36301, 29209 +, 58531, 29468, 17208, 40242, 41469, 48947, 26956, 55835, 58485, 18457, 37133, 29658, 57569, 29786, 332 +, 4382, 38679, 11307, 54549, 16082, 8342, 24237, 44170, 12383, 51383, 46038, 34517, 35218, 21625, 10818 +, 4427, 20156, 40286, 57987, 398, 58108, 46934, 3707, 53943, 45419, 58516, 7428, 51429, 56085, 37214 +, 51761, 36819, 52245, 3068, 7720, 8327, 11410, 31957, 28850, 146, 59692, 14888, 11015, 34910, 12865 +, 21833, 39337, 33021, 38471, 13676, 9772, 36579, 610, 49831, 30523, 22382, 48347, 14303, 50163, 20784 +, 51518, 41925, 57603, 20115, 21345, 41675, 4795, 9108, 49985, 33645, 45606, 49677, 24885, 56621, 24588 +, 37750, 18454, 40277, 47123, 33277, 30306, 33247, 46209, 30916, 59430, 16732, 29650, 47777, 7387, 19814 +, 8561, 58905, 38091, 42516, 55373, 59436, 544, 168, 44896, 50529, 10165, 30502, 40206, 11402, 27123 +, 41146, 49152, 21929, 57776, 12627, 31559, 28082, 22227, 17768, 35350, 21657, 10852, 41353, 45787, 18239 +, 1167, 30700, 53497, 39258, 49569, 48870, 15046, 50113, 25390, 36295, 40642, 35555, 6797, 57200, 46957 +, 10273, 14699, 12461, 8554, 48827, 1440, 40113, 16909, 19, 57881, 28611, 21677, 8733, 9964, 43816 +, 26973, 47483, 14516, 56822, 3093, 4085, 45692, 18140, 30550, 47434, 54435, 11192, 59341, 37584, 44745 +, 22650, 24209, 59444, 11463, 32764, 48271, 12903, 49229, 41532, 49275, 47111, 46495, 47304, 32196, 56460 +, 31120, 35521, 20295, 21988, 32343, 23389, 26074, 54387, 17881, 32976, 41821, 12316, 44169, 41162, 26252 +, 5266, 40164, 50462, 4710, 51627, 59578, 29333, 40883, 48807, 47217, 30158, 12270, 33712, 17462, 20819 +, 6524, 48582, 32692, 26820, 10570, 5036, 50209, 12996, 35775, 8090, 45973, 53949, 56758, 6494, 11463 +, 59362, 48112, 51628, 26176, 52822, 43255, 25754, 58507, 24138, 50914, 45724, 54296, 3184, 19436, 11758 +, 355, 25961, 36692, 33048, 29133, 23615, 14436, 55694, 12963, 50211, 40136, 35288, 44160, 13246, 18134 +, 55624, 12608, 6246, 23604, 38785, 35420, 6859, 40891, 33927, 7350, 31805, 19651, 1646, 11342, 15440 +, 49757, 11697, 17753, 2801, 21097, 46886, 26416, 35533, 42580, 15732, 25745, 22716, 51020, 46257, 35962 +, 45507, 41881, 24922, 51753, 41837, 3707, 27174, 48697, 20951, 1101, 56047, 29108, 57105, 34045, 40450 +, 12545, 23802, 28500, 6650, 2956, 49597, 53536, 5724, 25131, 12468, 21456, 27228, 35184, 48829, 13485 +, 47498, 34336, 31719, 12420, 26089, 13556, 52480, 53263, 38605, 13431, 30717, 34652, 42539, 4174, 45050 +, 59342, 53071, 8852, 4194, 59721, 48160, 30143, 29609, 53885, 31626, 42077, 15341, 58854, 17261, 40522 +, 48692, 41111, 14858, 20411, 29883, 40948, 10319, 22363, 10563, 48925, 12146, 17632, 59929, 31038, 21806 +, 44979, 6732, 51229, 30184, 10926, 50950, 18344, 41069, 20559, 48581, 12696, 2636, 3923, 47902, 56249 +, 44445, 36594, 13712, 35656, 33357, 43596, 16604, 20029, 42311, 3519, 45306, 54458, 57504, 45235, 1848 +, 19310, 6567, 44932, 46892, 36751, 32210, 37842, 31447, 13279, 34754, 20029, 2327, 13742, 304, 26582 +, 46344, 21101, 39528, 56, 56757, 12886, 43652, 49713, 32915, 25964, 53233, 18221, 56774, 50737, 39808 +, 34974, 46399, 46375, 19906, 33291, 59478, 52116, 47486, 7278, 41747, 58592, 27307, 20427, 12334, 27611 +, 47009, 58678, 25064, 26537, 35087, 21822, 15775, 18739, 11535, 25042, 21055, 41120, 19615, 54181, 8209 +, 35776, 5507, 54609, 22151, 1765, 4252, 57982, 30233, 28090, 5260, 48333, 26682, 8919, 8760, 15369 +, 12882, 32121, 14047, 37946, 35010, 25486, 59768, 27138, 20578, 47656, 52180, 41633, 28776, 48148, 12167 +, 36986, 23924, 54026, 7947, 46075, 55792, 48551, 20409, 26025, 16642, 25669, 14358, 43324, 34588, 59470 +, 58693, 23822, 7943, 49093, 1769, 42954, 50931, 1537, 10092, 11509, 25545, 38624, 29495, 54322, 26772 +, 41662, 7660, 50696, 35688, 51959, 13124, 7832, 40510, 9885, 10210, 57152, 35555, 24568, 16829, 46495 +, 391, 15522, 10318, 8334, 40967, 48439, 51288, 31899, 26328, 37732, 19760, 51874, 52709, 49255, 22548 +, 19481, 30917, 30208, 46530, 42958, 22167, 36006, 27142, 2677, 45891, 37352, 36182, 57798, 38273, 53011 +, 44294, 38664, 44885, 30964, 23350, 2205, 55755, 14639, 10456, 22083, 28723, 30216, 13957, 21432, 19472 +, 36505, 17266, 26741, 43065, 3796, 46051, 41584, 39802, 13194, 20614, 25693, 26898, 56796, 23492, 5171 +, 26159, 44138, 20187, 11044, 51454, 43538, 13249, 47209, 34529, 23705, 9292, 3252, 53922, 59602, 1037 +, 13394, 36107, 18303, 40135, 55525, 22099, 2539, 13461, 38253, 15733, 34075, 40298, 42631, 7223, 3790 +, 24155, 33382, 24280, 44342, 44427, 15734, 27880, 34028, 2943, 2409, 57734, 48588, 42014, 28008, 48190 +, 43051, 17754, 649, 1354, 34241, 32526, 59805, 36780, 45988, 14410, 52513, 56415, 54708, 11497, 3639 +, 58499, 35652, 13373, 22779, 19994, 34152, 14866, 24227, 8181, 54161, 26636, 42267, 42749, 8650, 10275 +, 30939, 51701, 4381, 7941, 29407, 38622, 40467, 5564, 15403, 26455, 19974, 44268, 59223, 14683, 55765 +, 2862, 49534, 7769, 16235, 48665, 4116, 26740, 3531, 28343, 34921, 57693, 31331, 53540, 16794, 39982 +, 40167, 24086, 8035, 44548, 32027, 13795, 23170, 48846, 19359, 38573, 15302, 39334, 59194, 14525, 54017 +, 31311, 53739, 19903, 15433, 46326, 8568, 19549, 13066, 12100, 24244, 24339, 46145, 55575, 17879, 2939 +, 11909, 58046, 27025, 56297, 42594, 35404, 10092, 42117, 24251, 29451, 57042, 15905, 45137, 56236, 6782 +, 15506, 27548, 521, 35409, 42981, 23199, 43978, 38882, 12618, 32430, 3126, 36957, 18575, 35053, 31189 +, 57866, 46963, 29235, 24892, 19612, 48182, 296, 29704, 30299, 899, 35507, 27341, 16804, 56997, 59930 +, 23586, 12503, 27478, 459, 24265, 46811, 23659, 8243, 25693, 12629, 17025, 5171, 49586, 35600, 40224 +, 57127, 33466, 3539, 2715, 34710, 23151, 50897, 11359, 29207, 57548, 12258, 4715, 1241, 29063, 1712 +, 1171, 52649, 50567, 5001, 29461, 14832, 28164, 53120, 59427, 53857, 5749, 16452, 35380, 31687, 28404 +, 51957, 28815, 38223, 55496, 31530, 12933, 55000, 58779, 24292, 24207, 56327, 12903, 5274, 33920, 41966 +, 43338, 35092, 10967, 33906, 16445, 40428, 25090, 44610, 9900, 24518, 14819, 15649, 17322, 50200, 23689 +, 22079, 42157, 28856, 302, 14005, 36738, 13235, 9005, 35517, 13880, 9565, 8196, 26783, 14839, 42116 +, 45101, 58178, 53560, 56068, 32084, 10006, 36497, 57174, 54616, 22749, 58044, 45787, 14751, 51719, 35987 +, 38440, 13798, 54496, 7296, 14100, 8502, 44034, 3687, 53859, 55903, 17567, 3424, 4099, 20702, 54616 +, 22567, 5803, 52794, 52480, 38224, 1230, 38838, 14721, 34756, 33454, 13822, 32801, 55593, 28573, 872 +, 31581, 7013, 14670, 2429, 50661, 5122, 47283, 11047, 8809, 41143, 43302, 2729, 20919, 23753, 59783 +, 15535, 46321, 5587, 44681, 15153, 43811, 45911, 53991, 34884, 20668, 3797, 48706, 29821, 59390, 53632 +, 30693, 30971, 645, 21715, 9753, 27659, 26837, 57036, 15058, 11998, 38179, 58361, 51079, 35451, 22114 +, 50863, 27338, 44787, 32802, 12020, 59940, 52965, 57931, 53931, 4201, 18599, 57728, 29259, 24772, 57119 +, 22891, 55465, 4442, 59889, 17180, 14195, 27548, 20369, 11232, 42606, 8720, 25763, 17319, 59799, 37566 +, 39434, 27014, 4905, 24221, 59816, 16925, 24162, 52781, 51208, 54445, 33334, 46160, 28526, 2594, 10932 +, 1997, 25485, 6398, 6439, 25374, 59930, 56987, 52922, 56652, 44571, 11881, 5372, 46686, 29200, 41523 +, 24253, 44986, 8538, 5510, 9208, 8354, 58787, 9722, 37488, 49995, 4167, 10822, 36155, 32693, 49768 +, 47088, 11042, 15254, 29838, 53834, 16980, 6120, 50821, 46255, 2772, 11744, 58136, 44496, 34782, 3688 +, 26020, 59035, 48675, 34558, 40897, 34235, 19264, 39684, 43957, 33104, 6032, 24476, 20279, 42187, 33522 +, 10047, 5627, 44564, 1653, 11817, 38398, 18634, 17938, 5571, 4889, 57062, 17315, 39377, 41559, 28450 +, 43065, 43931, 27485, 8092, 54841, 44735, 42327, 14105, 24419, 2636, 23562, 30451, 3465, 43841, 48991 +, 36987, 30240, 30970, 57903, 31894, 42788, 36302, 50528, 37078, 18225, 31769, 10492, 11893, 11146, 28403 +, 40343, 30563, 12334, 44180, 15008, 7175, 28915, 33687, 57633, 29687, 12676, 21195, 138, 16141, 41388 +, 25481, 53128, 11628, 56452, 51031, 43522, 15592, 3685, 10402, 29022, 58263, 18523, 39514, 10156, 6021 +, 7918, 50499, 12937, 56604, 11031, 27945, 3780, 39947, 37984, 37765, 9634, 50660, 35312, 46124, 6801 +, 16700, 47958, 36281, 28328, 44410, 3665, 48203, 36354, 7350, 34957, 5376, 41965, 29833, 44890, 52121 +, 35854, 29160, 18972, 48791, 25765, 6356, 53088, 5897, 46303, 31073, 43662, 32289, 21733, 18974, 54765 +, 4887, 35674, 42723, 41168, 40354, 3485, 44833, 4909, 39839, 28536, 16219, 21567, 10501, 46052, 6458 +, 38975, 21906, 11970, 34299, 47050, 37735, 40655, 40138, 43632, 26958, 47563, 3646, 35599, 45649, 22620 +, 30365, 50536, 34646, 13088, 31704, 51353, 16574, 16538, 56262, 32765, 21426, 12481, 54333, 31927, 58533 +, 37143, 10902, 56792, 49113, 21554, 43842, 26849, 2209, 332, 46833, 29168, 24248, 50480, 41119, 9897 +, 49452, 11484, 433, 451, 24573, 8489, 51804, 17499, 1379, 24418, 50264, 22805, 36900, 44597, 31085 +, 11785, 58092, 18339, 44929, 47206, 39893, 5123, 50407, 42103, 5456, 13592, 47623, 6056, 4072, 28742 +, 15953, 29877, 40227, 52738, 30328, 41152, 37579, 58484, 35003, 38959, 22902, 25267, 38116, 59802, 46217 +, 45553, 47940, 20661, 3893, 32869, 7867, 43786, 37993, 34626, 2241, 19801, 48219, 49864, 25857, 28643 +, 54959, 18162, 34872, 11538, 47252, 5200, 29042, 1183, 3684, 4045, 40142, 26587, 5664, 54611, 2741 +, 28233, 40164, 50681, 48895, 20409, 59903, 56762, 40548, 37896, 7741, 42789, 34049, 55960, 9006, 36258 +, 955, 3965, 30772, 35828, 51855, 18024, 41028, 20897, 19207, 21065, 24942, 35702, 24004, 30606, 6665 +, 26745, 58840, 23181, 53779, 24087, 43591, 30034, 20849, 24139, 44282, 4942, 43280, 18331, 902, 52286 +, 30941, 38210, 32603, 1713, 14038, 810, 56089, 31418, 21707, 51648, 28835, 23001, 3702, 52839, 53608 +, 10367, 55937, 28800, 33549, 26068, 52887, 53492, 56102, 50088, 17631, 40384, 31383, 37263, 35067, 8637 +, 5902, 6008, 46847, 38505, 44073, 885, 39316, 40162, 8656, 37375, 31810, 37491, 377, 35513, 30331 +, 30337, 22232, 26268, 35489, 32133, 28688, 28376, 25625, 24790, 54816, 19608, 41526, 2551, 56872, 16593 +, 11189, 2774, 58953, 58036, 17631, 43026, 35274, 33299, 59540, 43930, 10675, 31350, 21421, 11052, 43215 +, 51752, 41389, 5448, 54372, 16878, 13933, 59412, 21606, 39559, 24202, 52774, 59167, 5728, 55326, 32391 +, 58673, 42867, 35165, 57626, 40903, 29149, 17004, 16177, 2448, 16544, 36459, 49475, 24247, 57881, 527 +, 7462, 25985, 18268, 49262, 56710, 11498, 3196, 56122, 9456, 19107, 20325, 2231, 18274, 2405, 33909 +, 27018, 37431, 16776, 38535, 11409, 34031, 7684, 28414, 26561, 46485, 44958, 3020, 35960, 9205, 901 +, 36488, 53020, 3239, 31108, 18634, 59949, 42607, 58182, 56071, 52063, 17289, 52748, 30646, 11916, 31506 +, 40907, 38934, 8937, 34035, 17469, 20346, 8067, 1506, 25112, 10980, 47991, 10071, 14000, 23951, 55628 +, 51254, 36791, 25000, 54493, 44252, 43635, 30794, 3211, 41817, 26865, 31626, 35459, 55966, 2273, 47375 +, 3824, 19532, 26309, 49113, 29920, 20130, 9459, 37987, 57988, 34572, 25319, 45979, 20995, 39319, 46283 +, 52975, 30573, 59426, 17976, 1418, 43678, 1611, 32212, 46889, 19780, 35430, 54868, 55239, 31396, 33493 +, 42614, 11572, 53025, 45275, 685, 22945, 41758, 46496, 37284, 39746, 21068, 2603, 2078, 18415, 18275 +, 48361, 11391, 25200, 24139, 5719, 26619, 44170, 43682, 58831, 31059, 3462, 34261, 2279, 35054, 42009 +, 35772, 54020, 29933, 28798, 39296, 30618, 28095, 57406, 17115, 41732, 37152, 14535, 20687, 39230, 32951 +, 38962, 3943, 20694, 40515, 28083, 2765, 7134, 12253, 46447, 42317, 19664, 26261, 52931, 21944, 1315 +, 11292, 34068, 55336, 41226, 39218, 10984, 11844, 7314, 44742, 28959, 25398, 21894, 43495, 22437, 37477 +, 52798, 37752, 17772, 49844, 18267, 22207, 28961, 25401, 10812, 15408, 44070, 30477, 41669, 37001, 28773 +, 19337, 48294, 2841, 51025, 29520, 18412, 38361, 17716, 2078, 23103, 46676, 27476, 44997, 6523, 49913 +, 58826, 35673, 4017, 52951, 1869, 22284, 15158, 30830, 24037, 25971, 22590, 8108, 32800, 40611, 45109 +, 37925, 59948, 9755, 40766, 27325, 39275, 35530, 5686, 56992, 37608, 28789, 20020, 5084, 50139, 2895 +, 31350, 25317, 14920, 35367, 18268, 16789, 34004, 33427, 23971, 58041, 59398, 22913, 6149, 8550, 3524 +, 27611, 46475, 39825, 37366, 3593, 7150, 16642, 39124, 49189, 49986, 16732, 17978, 46358, 58169, 8117 +, 25605, 29519, 33435, 40525, 41238, 28055, 33666, 15242, 1482, 33989, 49636, 37232, 56902, 55785, 45782 +, 36778, 23396, 32257, 16603, 763, 35851, 106, 53757, 14975, 49295, 20095, 31707, 43625, 42805, 29876 +, 28095, 8410, 35747, 37882, 25287, 53338, 5937, 58953, 8580, 7420, 32942, 58216, 21004, 6196, 30354 +, 6787, 42974, 30102, 39044, 35930, 7217, 51247, 12388, 974, 6222, 1683, 57421, 14282, 21660, 40226 +, 20510, 49755, 24988, 56258, 3989, 50275, 25948, 9927, 49228, 34528, 53699, 58522, 9097, 14703, 41070 +, 15803, 57842, 24045, 45905, 13239, 36327, 53123, 4486, 48715, 30449, 47061, 26750, 4223, 1343, 48410 +, 44449, 58205, 14518, 45790, 30815, 18507, 36065, 56763, 4786, 1646, 7644, 58485, 36520, 16741, 49541 +, 17591, 8896, 47383, 17988, 54801, 622, 54315, 47924, 41461, 19382, 54726, 28522, 46132, 58949, 6217 +, 10894, 19750, 4422, 1764, 5540, 35238, 20272, 41606, 32001, 25058, 19604, 39645, 59896, 56124, 32738 +, 49437, 13715, 41634, 36820, 8055, 36436, 13795, 2370, 712, 55256, 58104, 31790, 130, 44236, 30739 +, 6347, 31483, 50490, 10769, 33247, 32382, 22359, 29871, 13988, 54361, 31282, 9944, 10358, 31178, 6069 +, 43097, 20615, 56136, 24731, 33787, 4192, 37519, 23934, 42914, 14584, 19190, 41019, 46374, 19320, 1607 +, 17114, 2019, 9442, 43956, 12789, 42690, 16338, 35148, 48913, 6679, 5861, 20195, 16623, 16220, 51373 +, 22692, 59317, 48340, 55181, 400, 58480, 59373, 37920, 22414, 18639, 28856, 17957, 59658, 15230, 13629 +, 37618, 32344, 15649, 47060, 16300, 4790, 6102, 32639, 16290, 31368, 39318, 22152, 51563, 32293, 38372 +, 19289, 54986, 14041, 43981, 50167, 50793, 42461, 25892, 5065, 41228, 44531, 33921, 59185, 20542, 49152 +, 12814, 34512, 57848, 4815, 57924, 14149, 9605, 40379, 23140, 25896, 11747, 38810, 24400, 3310, 11103 +, 2772, 58951, 42441, 53165, 42933, 8960, 43958, 25394, 34852, 25376, 6622, 55736, 59297, 42159, 52630 +, 48449, 31326, 27142, 46298, 36141, 1418, 36799, 22099, 41797, 36291, 47995, 53544, 15101, 12395, 33207 +, 2556, 51519, 32158, 44998, 21036, 15091, 30310, 41346, 16838, 41515, 6722, 59812, 37251, 6020, 41972 +, 29881, 30821, 13298, 33375, 53471, 25791, 34793, 6622, 47890, 52943, 42913, 12237, 22839, 34366, 24632 +, 56046, 13275, 52503, 4557, 34625, 13539, 56000, 4935, 54886, 12838, 46450, 1608, 49003, 53, 43980 +, 30975, 6286, 14802, 20625, 39661, 8273, 22768, 50807, 51248, 10659, 20102, 34161, 22896, 42941, 44880 +, 23881, 38988, 58155, 16384, 19897, 32780, 6276, 15897, 14067, 1162, 5088, 518, 2770, 30443, 571 +, 23103, 37770, 6858, 37905, 58395, 22871, 22530, 57515, 50030, 13778, 8174, 10132, 24292, 7423, 53074 +, 9172, 31304, 8414, 43679, 24040, 28311, 16459, 30316, 20560, 6878, 31478, 2000, 7396, 10601, 32443 +, 44320, 33704, 10213, 27530, 47961, 44960, 50401, 10491, 42476, 40432, 622, 50650, 26916, 24914, 34425 +, 19990, 10438, 5729, 28404, 54117, 29770, 33067, 46928, 86, 53628, 53806, 7917, 55628, 1203, 18518 +, 4424, 21875, 52222, 14637, 49405, 40183, 35950, 16158, 27026, 18426, 32942, 27648, 45428, 59859, 28914 +, 19854, 56201, 39352, 25583, 24606, 33469, 31705, 34025, 20397, 31792, 27653, 14204, 39709, 59634, 51759 +, 34579, 40410, 13634, 3153, 55047, 39391, 19688, 30997, 31901, 46714, 25775, 41196, 50715, 11204, 41055 +, 19629, 31058, 13608, 58982, 32993, 14566, 32451, 4699, 48592, 29201, 12843, 52597, 43405, 52552, 52231 +, 35164, 3483, 32641, 25150, 6636, 4041, 40893, 26324, 11390, 12794, 49390, 37166, 53990, 40105, 24722 +, 11397, 36087, 55780, 1358, 35069, 28773, 15924, 43872, 9824, 4516, 13073, 22667, 57114, 56478, 51571 +, 25697, 7994, 55054, 34691, 9496, 38042, 15084, 50389, 4366, 26474, 39536, 30109, 39992, 9878, 10214 +, 4714, 57628, 46301, 36846, 58986, 57722, 5620, 14910, 41595, 51796, 55779, 31020, 14464, 52893, 3851 +, 42387, 18590, 11845, 37442, 29633, 57694, 51836, 44717, 24435, 56203, 11192, 3971, 26312, 27536, 50202 +, 12878, 32251, 24182, 35532, 45449, 23168, 9606, 27421, 14430, 27553, 19218, 10209, 58574, 10034, 39454 +, 2425, 52421, 34397, 50622, 6215, 4030, 48316, 58052, 48748, 12752, 30607, 36292, 53075, 33271, 3828 +, 19629, 46149, 12431, 43811, 58033, 57881, 43331, 7640, 25302, 57762, 35193, 20872, 44323, 33767, 30906 +, 23778, 12544, 23328, 58175, 3167, 5895, 38557, 27835, 3947, 27305, 40587, 34554, 39949, 10015, 44177 +, 43778, 29644, 30327, 32561, 13456, 4712, 6794, 56787, 48704, 8449, 30901, 23898, 5673, 15225, 34017 +, 36580, 15355, 22914, 36260, 49882, 26081, 42155, 28439, 53916, 22455, 55745, 10856, 57009, 35694, 20871 +, 17539, 55824, 26867, 47866, 4738, 40323, 28930, 47884, 13463, 17635, 56333, 44364, 17885, 2007, 35941 +, 51902, 14939, 51296, 14816, 51199, 41178, 17249, 9706, 9618, 47518, 32161, 41715, 34726, 5523, 53761 +, 31949, 23062, 49586, 58816, 47280, 30676, 15492, 16210, 18560, 28955, 33845, 51246, 49671, 51730, 29605 +, 25613, 19985, 20896, 53261, 11153, 12095, 10792, 4755, 58153, 56762, 52273, 30315, 38477, 26999, 12190 +, 32238, 58948, 35252, 58176, 34116, 22532, 5204, 49608, 15094, 117, 54915, 25292, 51363, 44587, 53374 +, 57320, 46552, 13359, 18216, 16165, 865, 6663, 26957, 5620, 4816, 71, 34245, 11483, 38548, 37596 +, 23673, 47139, 12896, 58925, 21667, 47012, 57809, 26872, 12973, 12904, 26989, 7888, 38196, 54704, 28827 +, 31570, 52024, 51731, 21282, 46592, 7897, 58499, 53255, 11206, 4119, 58071, 11278, 14716, 9555, 26178 +, 52312, 33228, 13317, 5208, 8506, 11337, 52220, 6315, 38209, 5193, 19219, 41550, 49434, 33767, 36254 +, 18261, 41690, 4630, 9993, 2972, 51222, 54242, 1471, 44477, 41800, 41942, 18900, 53078, 56658, 4807 +, 55609, 25322, 14388, 8926, 30530, 22894, 56615, 59102, 29209, 34824, 40648, 24781, 52726, 30082, 58548 +, 5332, 48343, 40238, 9962, 34688, 19562, 37536, 5282, 57385, 58365, 47083, 15679, 17266, 16513, 48689 +, 22073, 12122, 14011, 12813, 57401, 44541, 35707, 54016, 43644, 4917, 5193, 24292, 6050, 57919, 30726 +, 4598, 3252, 19069, 21189, 13214, 30110, 40751, 27103, 35392, 14489, 25468, 22475, 30168, 42734, 38989 +, 55210, 41160, 51111, 9221, 53973, 48512, 53763, 6033, 42529, 13759, 47302, 47722, 14403, 53352, 21993 +, 45129, 57950, 25245, 40550, 55491, 14812, 10660, 12595, 41915, 22405, 27084, 43735, 44880, 33604, 26470 +, 221, 28814, 43982, 51333, 38036, 14307, 16197, 8151, 20340, 35078, 58262, 7642, 59152, 49017, 37346 +, 21146, 34146, 35297, 22743, 51048, 30788, 37555, 38061, 43383, 55822, 466, 46819, 39558, 45346, 56776 +, 42380, 45568, 25590, 2714, 13253, 39978, 53373, 5802, 24481, 50066, 40881, 22743, 34060, 16385, 11760 +, 11407, 37531, 22258, 23056, 36627, 13307, 53844, 50534, 51368, 13580, 46357, 28186, 36751, 2267, 49884 +, 33527, 20999, 11804, 35470, 23713, 25057, 51800, 17086, 7212, 16282, 43504, 48093, 39025, 17565, 4478 +, 27138, 28972, 18362, 49396, 52028, 54989, 39055, 22224, 45523, 6775, 12156, 8232, 34961, 25260, 46851 +, 1198, 58787, 7850, 13002, 10609, 7915, 14412, 2410, 1354, 21624, 18692, 44858, 9717, 34069, 2423 +, 50547, 1207, 7747, 45261, 26956, 36127, 16602, 42363, 58352, 38478, 49139, 46860, 46710, 452, 12120 +, 33562, 1650, 47260, 17764, 14653, 57869, 25680, 5417, 36631, 27034, 27041, 55323, 11892, 13110, 29393 +, 50668, 3657, 6952, 58415, 25271, 33908, 10895, 41873, 16272, 9247, 20351, 41763, 32459, 43414, 18567 +, 20932, 16976, 20218, 8192, 34740, 11223, 42413, 36772, 16640, 19045, 3806, 20033, 50720, 15699, 33143 +, 20113, 6367, 13152, 3418, 41134, 38423, 13678, 52029, 20297, 6302, 37628, 17000, 48065, 46440, 414 +, 6633, 7372, 53742, 3203, 15564, 4835, 50778, 57977, 41607, 43770, 53374, 45414, 3803, 44095, 37465 +, 36946, 40560, 20184, 50098, 43978, 1318, 28522, 57657, 29700, 25171, 40311, 43680, 18523, 28377, 30120 +, 18938, 11362, 37492, 12680, 50917, 53056, 17515, 41695, 27386, 35475, 1817, 20760, 20889, 5620, 4855 +, 58354, 42566, 21768, 18538, 9016, 5746, 56208, 13890, 39755, 2260, 15413, 20067, 45941, 33937, 24796 +, 16061, 52875, 36158, 29906, 41907, 3427, 59314, 35775, 21474, 26700, 11250, 23291, 23813, 32139, 5263 +, 5020, 6845, 24181, 26788, 1735, 33197, 8887, 57943, 23440, 48642, 36556, 38853, 8709, 22497, 12790 +, 33505, 14910, 42017, 46015, 44816, 23925, 25794, 44131, 59700, 47268, 47183, 47302, 46911, 47348, 19441 +, 52174, 28721, 2638, 16355, 31861, 4373, 25905, 40748, 38668, 49345, 29391, 15224, 28198, 14452, 14073 +, 17341, 24310, 28984, 59358, 46677, 50152, 59635, 12472, 10635, 35687, 36092, 34171, 22989, 23004, 21519 +, 18782, 51530, 26592, 57772, 7886, 58454, 2145, 10143, 39202, 17166, 59488, 44945, 32390, 4038, 35750 +, 22816, 21379, 36412, 28152, 57090, 23089, 18304, 33077, 11913, 5292, 8765, 48006, 39463, 8106, 11010 +, 37334, 26889, 2540, 40279, 24661, 46778, 38733, 3159, 56921, 54287, 20325, 32761, 15585, 29067, 36800 +, 27687, 51883, 34531, 4099, 56387, 7973, 27188, 51044, 41051, 39102, 56336, 26168, 3460, 12151, 34274 +, 50822, 25837, 1163, 29714, 6116, 2177, 16493, 44849, 5336, 49766, 15489, 2013, 22528, 31074, 7432 +, 35680, 58761, 35668, 46563, 39212, 32055, 54537, 6400, 23099, 11940, 21854, 55787, 38108, 25314, 7938 +, 12382, 16136, 33776, 49898, 45851, 39892, 52075, 38696, 1094, 33763, 4814, 16583, 12128, 3694, 24009 +, 19560, 39374, 59122, 31580, 2290, 38334, 3636, 33179, 44734, 3087, 45119, 42941, 58875, 59579, 44607 +, 6813, 11961, 744, 16941, 38211, 22947, 56834, 6638, 37995, 34280, 16753, 42809, 50863, 28881, 46504 +, 14872, 24794, 2230, 13994, 56374, 4520, 28680, 36362, 14051, 13414, 39450, 35522, 32707, 38325, 35101 +, 17315, 21490, 23415, 54411, 38432, 1626, 53710, 11618, 44617, 31705, 45898, 1370, 14514, 36761, 6604 +, 37370, 27985, 7750, 39601, 18331, 4124, 20473, 47011, 16839, 10877, 36777, 56289, 46399, 9485, 34614 +, 21501, 26800, 32456, 21268, 57563, 10888, 59246, 51273, 22506, 43863, 22978, 8404, 21586, 13844, 45165 +, 4542, 51215, 49502, 12292, 7168, 7833, 52768, 3993, 31196, 9607, 14870, 7974, 5896, 37622, 17459 +, 16862, 35475, 20611, 49319, 56743, 18174, 207, 32341, 9447, 59066, 16205, 8777, 7470, 14143, 22621 +, 28988, 18685, 50188, 18490, 30977, 33708, 2676, 23745, 37702, 33872, 9705, 28924, 18198, 15601, 42898 +, 35657, 8816, 18373, 32620, 58135, 51468, 27146, 34694, 23810, 12945, 10112, 16367, 21722, 17583, 30510 +, 44344, 22923, 25547, 10884, 17765, 56524, 44593, 20441, 56621, 58647, 30666, 6326, 3923, 48864, 58280 +, 46822, 874, 7096, 5195, 9846, 41583, 33016, 36993, 52629, 56826, 49938, 2742, 49545, 11661, 56677 +, 20055, 32357, 55952, 21954, 19593, 13717, 54830, 4186, 10511, 51451, 39185, 17529, 34130, 43109, 6393 +, 8762, 29931, 43619, 52210, 11478, 53466, 10145, 44494, 6811, 2774, 41320, 56749, 41868, 30865, 44762 +, 14897, 27272, 53471, 10849, 49226, 13065, 919, 44056, 53603, 11430, 11860, 32789, 28959, 22342, 15898 +, 11704, 31104, 22181, 31676, 23314, 33659, 25142, 33459, 18154, 8305, 12585, 35826, 5054, 30806, 43044 +, 26169, 22055, 10316, 55992, 32905, 35895, 45409, 10176, 56303, 39013, 21606, 44515, 48154, 26917, 6857 +, 4052, 14973, 14313, 26233, 46649, 13979, 36244, 48143, 47438, 54398, 56448, 36376, 6577, 1503, 43534 +, 49621, 4024, 5589, 36289, 16, 14846, 48536, 45426, 25022, 21192, 791, 22980, 5707, 48945, 49897 +, 48917, 29349, 41223, 3230, 55582, 27872, 17210, 8178, 16016, 41000, 2577, 12464, 53728, 45506, 50319 +, 37262, 35127, 30695, 42852, 47768, 30712, 57698, 36305, 52490, 59073, 57497, 53281, 22053, 39556, 18578 +, 48303, 28473, 47927, 29526, 8056, 19861, 33750, 25266, 28039, 49766, 42618, 6968, 38583, 36347, 52474 +, 28902, 13609, 27601, 59598, 56461, 51722, 6662, 30512, 28027, 35504, 29585, 1876, 5137, 27990, 41432 +, 23715, 16293, 46258, 11642, 22171, 54314, 31503, 55922, 19580, 59542, 22040, 2198, 6511, 623, 14897 +, 35337, 29526, 28507, 39291, 5476, 1320, 31013, 48490, 31832, 59040, 23994, 37769, 37268, 29131, 42112 +, 18700, 29198, 34757, 4958, 40840, 56929, 59272, 48695, 29203, 55204, 24589, 51243, 33755, 7452, 51867 +, 48652, 42790, 57745, 53511, 22081, 39573, 54832, 29446, 28063, 3016, 4838, 28409, 17138, 42106, 33892 +, 59250, 37158, 3090, 34007, 42117, 20282, 7288, 17741, 45329, 36491, 49298, 9918, 4087, 59405, 53723 +, 32306, 24409, 12865, 6403, 54273, 11298, 45976, 49105, 40744, 50391, 28473, 45582, 55152, 21963, 27688 +, 29044, 21213, 4846, 8486, 31573, 23315, 5120, 38861, 17409, 26801, 51705, 43059, 13071, 55792, 18816 +, 6794, 4450, 43225, 19659, 10853, 37498, 30957, 56829, 2955, 11701, 23572, 7781, 33635, 18724, 29744 +, 37675, 24120, 50958, 18874, 8958, 58883, 42189, 50430, 37744, 35950, 17231, 5801, 55361, 30302, 1593 +, 14177, 13449, 6043, 33755, 33108, 16896, 11253, 40418, 50077, 50561, 28471, 50001, 58342, 2107, 45077 +, 4438, 16134, 9197, 55396, 35008, 54507, 30631, 53550, 21289, 8376, 29500, 38520, 14177, 1214, 45175 +, 52123, 15391, 58624, 34518, 49146, 8084, 27767, 36752, 48502, 54196, 3665, 53326, 44198, 2007, 31785 +, 29275, 6445, 47919, 14825, 38194, 22928, 45684, 8825, 16478, 6974, 53553, 22330, 21846, 44083, 23544 +, 7021, 12558, 38936, 41997, 47076, 4434, 50082, 51195, 17538, 14936, 45392, 21203, 8262, 29590, 59562 +, 16399, 35217, 42360, 4319, 50042, 56906, 27247, 35727, 42083, 20077, 19053, 35637, 42407, 40899, 56072 +, 5952, 47921, 8630, 21240, 29918, 55706, 2026, 56352, 23254, 19565, 11289, 8646, 17120, 55903, 14588 +, 16683, 12303, 49805, 35395, 52974, 16200, 32301, 20221, 51927, 14384, 40298, 10980, 50021, 22705, 28231 +, 46093, 5009, 16152, 31075, 26249, 22423, 26782, 4628, 55127, 50036, 24193, 42768, 35034, 41313, 38672 +, 49622, 34348, 27327, 39427, 9743, 20301, 55627, 42044, 16874, 23906, 56429, 33524, 11238, 22802, 32581 +, 39470, 45248, 37591, 31974, 16323, 40192, 30749, 19457, 44820, 2229, 45845, 45365, 44997, 57231, 3031 +, 21, 46853, 37379, 27348, 2633, 23475, 24001, 34612, 41871, 40875, 34871, 14652, 50751, 22461, 37455 +, 23333, 38283, 59055, 924, 46610, 51730, 17468, 17359, 47540, 2289, 19588, 33385, 24006, 40938, 6969 +, 27037, 40959, 53822, 40769, 44660, 32807, 4244, 8661, 7420, 22467, 25889, 18643, 37120, 16640, 41104 +, 50927, 39973, 19388, 49982, 17249, 5998, 18064, 34718, 59709, 5604, 13359, 19298, 15342, 37365, 36588 +, 22311, 4403, 17547, 52485, 21524, 2207, 25293, 2120, 47221, 9065, 24587, 49462, 27708, 1707, 42454 +, 8812, 52634, 58780, 28200, 18968, 16029, 34198, 37033, 27099, 33908, 18989, 40458, 29558, 34331, 17824 +, 6146, 56642, 58579, 45, 25480, 20103, 38605, 50773, 22223, 2178, 59838, 23162, 51640, 27546, 24870 +, 10446, 36358, 53856, 9226, 40911, 49177, 1608, 15109, 26210, 28707, 25369, 21551, 9166, 31279, 55883 +, 3342, 13777, 28877, 1921, 13823, 54357, 58376, 28780, 21482, 56951, 30958, 21320, 20113, 58950, 25218 +, 21335, 9396, 1577, 15192, 18623, 42488, 4369, 56583, 33949, 6931, 25290, 35671, 28482, 10808, 6950 +, 717, 14150, 57080, 5947, 52423, 47255, 36656, 50799, 16035, 58139, 47750, 46993, 19459, 44216, 22295 +, 44678, 5551, 31691, 22607, 20743, 26666, 41447, 1464, 23249, 51748, 8395, 48540, 27419, 13230, 35700 +, 10722, 13947, 49851, 7802, 56246, 18626, 31409, 32903, 9426, 47444, 31042, 33528, 10789, 26853, 17744 +, 33084, 47883, 23296, 41127, 46842, 20391, 7794, 28289, 21856, 31043, 20038, 6603, 55935, 23809, 19833 +, 31636, 34531, 10133, 57839, 18685, 6379, 16465, 50094, 15634, 25891, 13890, 46676, 35772, 1031, 49882 +, 53516, 34115, 37765, 53164, 15243, 960, 13556, 59389, 29249, 11764, 30432, 49287, 18367, 26368, 13097 +, 14553, 34356, 23980, 24686, 32195, 42666, 7417, 48660, 9112, 59404, 50904, 59355, 46080, 26676, 386 +, 12314, 56544, 10854, 26432, 26061, 2449, 27392, 39617, 1838, 56641, 27733, 32270, 22281, 46100, 34990 +, 11730, 37005, 9346, 12062, 1691, 17893, 31080, 45461, 6554, 40193, 44865, 33810, 39548, 7297, 486 +, 16286, 55964, 33382, 27140, 22396, 59443, 29589, 49788, 15412, 31427, 22781, 43145, 40050, 21414, 5598 +, 15040, 9496, 42603, 739, 21559, 20647, 18632, 52639, 42460, 25186, 9184, 27325, 35348, 25084, 10974 +, 35834, 41371, 6938, 45569, 8511, 29334, 45012, 14453, 55474, 36777, 45880, 54608, 19922, 25930, 16022 +, 1872, 17323, 1871, 20828, 18062, 23430, 41475, 36694, 52421, 23935, 38233, 1606, 27612, 13581, 26690 +, 14938, 25768, 44413, 21877, 47689, 29277, 27563, 9053, 43730, 59390, 45830, 5962, 53998, 42105, 8245 +, 46372, 43977, 25568, 48243, 4805, 19982, 11673, 22632, 56676, 40447, 22919, 11261, 42053, 50531, 1195 +, 45095, 5470, 3315, 5861, 3699, 51004, 35138, 31262, 57, 55220, 7004, 22240, 1182, 1002, 4345 +, 45779, 23727, 24674, 47699, 11970, 5832, 7681, 59996, 28464, 40710, 40443, 51384, 51971, 58848, 18267 +, 29518, 43943, 23737, 32833, 26156, 3788, 189, 1294, 11403, 36599, 32866, 18407, 58839, 10401, 19410 +, 3184, 56180, 19489, 4210, 43880, 31459, 10042, 51561, 7807, 38507, 32271, 48250, 6243, 595, 23450 +, 24510, 6465, 43746, 24600, 15651, 9902, 28388, 15840, 47549, 39791, 52439, 20415, 58199, 27630, 30816 +, 53961, 30814, 26997, 13450, 35025, 47229, 21261, 21419, 15142, 29069, 59926, 23766, 53671, 42521, 24361 +, 53474, 7032, 7178, 37220, 7984, 22829, 47122, 36372, 15022, 34671, 52516, 7461, 55087, 27067, 35092 +, 2255, 57380, 42258, 29252, 47182, 53635, 52833, 8443, 15055, 7976, 13864, 51333, 31742, 43888, 33855 +, 32455, 37362, 17239, 39633, 14582, 25223, 38815, 38056, 37947, 53837, 12728, 30463, 37650, 44167, 33882 +, 49094, 46422, 31262, 31353, 52027, 18444, 1340, 21212, 3240, 52747, 29188, 53456, 44081, 37282, 37344 +, 54288, 9737, 51058, 11527, 25723, 5640, 36750, 40890, 20049, 14697, 34727, 9129, 21513, 12377, 53296 +, 55395, 1472, 16070, 3010, 9177, 44449, 21454, 10517, 42014, 1046, 39617, 11202, 54503, 23698, 24837 +, 8199, 17986, 10926, 59258, 5865, 36649, 41250, 42615, 17539, 1299, 33664, 28618, 10428, 55177, 40996 +, 40076, 50573, 18820, 32499, 53583, 27997, 53300, 51389, 14866, 35314, 28788, 54483, 22869, 59643, 54533 +, 47706, 7842, 48871, 58632, 43452, 54736, 11634, 1055, 37351, 5525, 2354, 47368, 34144, 49135, 42545 +, 51492, 5563, 9470, 10312, 14414, 39405, 14661, 44067, 7147, 29527, 55733, 35935, 363, 18602, 35578 +, 54896, 42660, 19772, 43768, 41293, 39577, 14856, 29279, 40632, 28560, 34804, 19338, 15928, 8948, 44825 +, 58473, 36792, 26741, 7944, 47104, 41155, 23701, 1765, 1574, 30848, 7645, 57308, 6783, 8008, 15910 +, 18713, 39256, 58571, 14838, 59376, 16216, 30767, 14233, 45495, 11399, 42793, 56651, 30737, 58721, 5600 +, 51915, 33546, 18744, 18656, 17842, 5849, 36163, 41544, 43966, 37738, 12392, 51611, 35046, 55528, 35971 +, 50956, 50593, 51580, 25879, 41783, 50956, 18447, 12550, 41541, 40294, 301, 24334, 36946, 7391, 59407 +, 18898, 59306, 32954, 37642, 17962, 27148, 43491, 30477, 8692, 27458, 8215, 57437, 55421, 43261, 52965 +, 7745, 10570, 19910, 59325, 12801, 1694, 50281, 31249, 50596, 31823, 11543, 50898, 32509, 48489, 34641 +, 8269, 7387, 33947, 17575, 21382, 28261, 44723, 4873, 58738, 53416, 8683, 6954, 50853, 40457, 26567 +, 20170, 48202, 37137, 16432, 47527, 26291, 54478, 14160, 57540, 45075, 22335, 45435, 12325, 31197, 33925 +, 46966, 39466, 17664, 57265, 57041, 15398, 25526, 41764, 20272, 24264, 11532, 5307, 7570, 38737, 22116 +, 34138, 58907, 10318, 47627, 15340, 34197, 13918, 9818, 24710, 47810, 31245, 47045, 33246, 19922, 54594 +, 43523, 6888, 34060, 37539, 4153, 7453, 52938, 6031, 25570, 49562, 6648, 13454, 31221, 14218, 52192 +, 53338, 24708, 27451, 40008, 48688, 19143, 14206, 38958, 5314, 15268, 26769, 36559, 38665, 36367, 32834 +, 33260, 19890, 39722, 43672, 57429, 20228, 51126, 26719, 26259, 53048, 16281, 32907, 6502, 47503, 23478 +, 35046, 17193, 48186, 2498, 57201, 13226, 57993, 47759, 52185, 3307, 3027, 18954, 16219, 41693, 55321 +, 49053, 51305, 51563, 5127, 34977, 48992, 25355, 2455, 52064, 27967, 55503, 8345, 874, 38358, 32200 +, 24352, 13404, 25745, 48891, 52254, 22947, 2117, 50248, 47058, 54302, 29907, 26438, 49608, 46126, 8131 +, 21281, 11531, 59436, 12844, 16659, 10765, 38189, 18366, 13221, 30253, 46333, 45076, 14950, 23560, 23434 +, 23503, 24264, 13191, 49248, 13155, 41797, 48547, 51625, 8397, 35606, 22279, 14657, 2044, 48240, 37135 +, 46527, 9521, 48667, 22315, 22366, 41678, 33080, 36907, 44, 46301, 7160, 22730, 7730, 58462, 46290 +, 7516, 21965, 10554, 20707, 47566, 62, 38857, 36113, 28039, 23606, 11719, 50318, 38263, 50115, 14910 +, 15399, 36642, 24432, 40418, 58957, 23150, 22096, 8390, 57, 58492, 54691, 43569, 57574, 38773, 18383 +, 43864, 46290, 40349, 30771, 43349, 27915, 7185, 58558, 40380, 35224, 22165, 52100, 1894, 428, 42215 +, 16805, 52179, 55210, 41237, 32597, 54167, 40739, 31045, 2557, 40796, 29538, 33601, 717, 27112, 48726 +, 19100, 47329, 35016, 35801, 54452, 18366, 40068, 1637, 16924, 20449, 36861, 15441, 48901, 38755, 15870 +, 7468, 55560, 44401, 2678, 13149, 16999, 33198, 53888, 48044, 12107, 11036, 53934, 22060, 48105, 57399 +, 10787, 43558, 21080, 45803, 19359, 15532, 40521, 59428, 17169, 33798, 56229, 54030, 49239, 45130, 9137 +, 41461, 52598, 41050, 25863, 31629, 30551, 19214, 4827, 792, 43610, 16934, 48180, 37545, 15347, 36286 +, 11296, 26134, 19844, 32376, 48289, 15555, 47908, 28811, 14983, 41429, 38961, 47564, 11811, 4552, 32694 +, 20948, 46014, 1645, 38350, 48229, 33274, 45254, 7443, 38101, 46046, 51053, 31387, 34226, 4950, 46734 +, 10512, 16246, 49220, 6708, 24974, 37510, 22264, 49234, 42673, 13599, 30663, 21634, 1164, 42474, 26186 +, 33858, 39775, 48552, 11855, 54477, 36781, 45129, 39731, 44224, 23230, 25777, 35278, 30970, 4, 16580 +, 54056, 46868, 32827, 43277, 29929, 34153, 20787, 52193, 23388, 3460, 5792, 54051, 1446, 43308, 36526 +, 27632, 53519, 52653, 16185, 5374, 47130, 52966, 50504, 26862, 13543, 50086, 28991, 25173, 57408, 28995 +, 41753, 51465, 52216, 50932, 34742, 22145, 25086, 55529, 50690, 48474, 35341, 32834, 42525, 36787, 16143 +, 55403, 4419, 46014, 48056, 56956, 51388, 11539, 26275, 18244, 38401, 16170, 8331, 7392, 41343, 5739 +, 12740, 23096, 33556, 41308, 14029, 8298, 39805, 39115, 3827, 30495, 3941, 15520, 39681, 46466, 52307 +, 55824, 18222, 33079, 18190, 6278, 6387, 9579, 17817, 32662, 27823, 32570, 25184, 12506, 16315, 6527 +, 54598, 29055, 5976, 28154, 46715, 20005, 36453, 26520, 35472, 16632, 33367, 15765, 32153, 13048, 2231 +, 24460, 45225, 20453, 33891, 3415, 3084, 40279, 12994, 57253, 49293, 17170, 6176, 14478, 6028, 22491 +, 21005, 626, 27898, 26981, 5133, 14613, 23338, 41586, 41133, 35162, 34570, 14500, 50927, 6723, 3900 +, 29511, 7536, 49125, 26316, 41427, 52541, 29400, 58058, 41887, 3006, 47352, 35409, 9182, 1830, 41438 +, 31673, 22835, 18416, 59571, 26169, 23549, 50536, 25859, 41487, 8021, 1022, 16058, 58873, 28301, 59133 +, 2773, 57812, 43021, 51899, 481, 24449, 20792, 29881, 58859, 39031, 32887, 46211, 14441, 18421, 48041 +, 32231, 50094, 47229, 50647, 26017, 49750, 50549, 16553, 15609, 32036, 926, 52983, 48094, 59799, 57637 +, 47228, 2573, 31801, 30249, 30824, 32282, 31050, 51616, 2164, 29910, 30647, 11403, 52473, 21440, 29825 +, 40515, 30023, 56271, 4096, 20671, 58641, 53846, 47572, 51546, 45807, 19608, 52473, 38791, 7703, 52272 +, 36428, 31283, 31197, 8229, 1532, 2021, 40512, 8935, 53637, 19028, 15197, 637, 6783, 7670, 58429 +, 36608, 24537, 28453, 9232, 28633, 25476, 7873, 58831, 13048, 35771, 44639, 32656, 28244, 59782, 16711 +, 56869, 36210, 47994, 28066, 20791, 25879, 30088, 37655, 11166, 77, 56683, 26363, 37066, 3467, 10385 +, 11848, 16427, 34923, 16653, 2011, 39908, 42129, 46236, 15092, 31529, 22008, 59731, 40537, 50252, 35865 +, 33601, 47121, 48427, 21595, 51540, 9218, 23826, 21628, 23226, 11344, 58057, 19909, 14059, 35124, 59728 +, 24445, 23324, 52508, 35720, 39977, 54519, 51980, 22106, 40756, 7072, 29987, 2764, 43155, 10524, 29368 +, 19020, 20477, 52842, 7447, 18425, 44382, 53018, 42251, 42362, 16244, 29948, 40419, 12505, 44007, 51895 +, 48586, 8452, 15219, 41094, 20524, 55196, 11965, 12505, 53654, 29073, 55929, 59993, 8189, 15437, 46870 +, 37558, 10809, 7347, 30400, 54609, 25772, 51134, 47627, 8024, 33496, 40223, 37972, 50267, 52728, 58331 +, 42163, 17666, 6784, 33734, 58760, 3660, 5283, 47078, 52517, 58937, 16151, 24799, 58931, 24341, 40236 +, 45801, 1899, 51045, 29500, 8651, 22006, 55273, 36137, 9633, 3297, 45985, 26208, 17621, 36252, 55289 +, 52304, 54767, 12955, 35440, 28502, 48068, 39101, 10137, 35146, 31618, 9074, 27649, 56417, 44357, 51990 +, 13005, 6510, 30241, 40403, 36011, 15244, 2409, 31284, 51381, 48395, 10933, 13718, 14603, 4906, 49971 +, 46244, 57210, 44738, 59200, 9003, 49592, 23620, 48104, 59729, 35118, 56074, 45156, 2767, 28844, 5865 +, 54758, 41849, 48728, 1351, 58604, 1091, 16596, 1014, 8727, 44329, 49409, 56012, 58048, 40364, 37270 +, 48019, 26609, 10832, 9109, 2161, 19835, 35054, 25781, 7939, 11135, 899, 40366, 32643, 3666, 9210 +, 14861, 34776, 27411, 39941, 36128, 26016, 41032, 52724, 27030, 26111, 13405, 52791, 22123, 11453, 33155 +, 59393, 35824, 36116, 10225, 44934, 38277, 6413, 56340, 40410, 14352, 43827, 41309, 31070, 16471, 21328 +, 40280, 7684, 32456, 7692, 47625, 8584, 10060, 28657, 37660, 37090, 54768, 51066, 6233, 53243, 38871 +, 39388, 28988, 14696, 15505, 39213, 35982, 30134, 21978, 32322, 10545, 12683, 16149, 28206, 43753, 8972 +, 25886, 24034, 16656, 58343, 8078, 4281, 43279, 18138, 9290, 57292, 31580, 40410, 24710, 37813, 33653 +, 3581, 53553, 2641, 54629, 45410, 18207, 30611, 15545, 40185, 39285, 26090, 52868, 31787, 30648, 36622 +, 17111, 56535, 37008, 33768, 31230, 21438, 14401, 50861, 39576, 23692, 48153, 47508, 4102, 49215, 1673 +, 14108, 52797, 55226, 53101, 23778, 40637, 11308, 54390, 32534, 27846, 10027, 34976, 57066, 41814, 5624 +, 10040, 58926, 38511, 47048, 9046, 46093, 8486, 23447, 36955, 24414, 23491, 1460, 48274, 3946, 50676 +, 49947, 18054, 19825, 45174, 11155, 43603, 2163, 58816, 14345, 34697, 26662, 725, 46025, 80, 18891 +, 51649, 10121, 54169, 6513, 57169, 3215, 52606, 42008, 3015, 5913, 42774, 26506, 7374, 31049, 30452 +, 58050, 20996, 24858, 54227, 42522, 12366, 14182, 44685, 47534, 4880, 55734, 50548, 5605, 41759, 50628 +, 24496, 9761, 749, 18666, 16274, 34271, 21881, 8880, 16279, 1248, 51146, 35405, 27755, 58520, 6454 +, 34559, 32922, 27451, 35770, 27149, 9973, 24488, 17683, 31011, 12022, 22563, 3097, 38922, 28168, 44857 +, 29550, 29017, 30970, 6652, 47683, 47244, 40923, 45916, 32476, 33554, 47165, 23622, 8959, 51272, 22142 +, 15414, 2183, 31416, 19217, 14305, 34917, 5542, 38793, 52601, 36553, 27167, 51516, 16003, 6089, 19685 +, 860, 11992, 25054, 31830, 18644, 12737, 55426, 35919, 35005, 27902, 45825, 58522, 27877, 54784, 49794 +, 26371, 46550, 28330, 57788, 42119, 42635, 32705, 47662, 21429, 1658, 567, 24948, 53175, 16570, 31038 +, 49212, 53782, 19382, 14266, 1964, 38026, 3355, 33742, 50297, 38360, 37997, 36122, 36883, 5874, 7258 +, 3029, 32245, 53809, 7711, 6385, 12280, 50347, 15443, 36294, 48128, 53453, 36862, 13076, 46628, 29784 +, 20466, 12192, 59919, 16200, 26458, 38235, 54226, 6165, 11978, 20875, 44526, 49975, 56997, 57761, 32201 +, 4256, 37142, 40798, 34417, 44854, 47184, 46697, 11553, 38979, 59344, 59681, 32432, 12558, 49109, 55413 +, 42342, 45928, 7605, 18613, 2128, 10416, 33201, 32707, 16581, 45179, 53582, 37459, 11506, 50580, 11572 +, 43707, 31188, 25067, 24505, 5605, 9921, 48041, 28654, 21474, 3372, 27998, 57507, 12157, 40556, 46616 +, 7570, 59251, 32544, 51527, 54216, 34673, 38295, 27417, 7380, 31229, 48948, 962, 45040, 454, 27894 +, 56613, 20513, 59082, 21680, 45019, 41039, 7953, 9412, 9694, 29427, 49137, 14044, 26934, 1294, 30953 +, 49902, 45216, 30204, 22447, 13095, 24420, 33472, 51391, 28190, 40852, 22620, 17138, 18166, 44012, 17593 +, 46061, 40625, 14458, 21495, 38657, 35829, 2535, 46610, 45242, 48581, 52389, 34379, 2625, 19323, 12025 +, 33578, 45578, 57241, 40134, 8025, 10336, 40907, 41497, 38079, 45449, 58701, 37051, 2587, 16867, 21064 +, 56532, 39280, 1689, 10991, 37128, 40347, 46820, 16015, 3309, 8414, 4596, 55699, 19145, 43573, 51374 +, 31170, 53504, 36952, 28411, 9990, 21329, 15100, 50897, 2826, 53179, 36346, 1527, 30231, 15286, 54747 +, 51295, 48170, 10379, 29336, 59161, 47507, 46035, 22334, 39874, 49345, 30748, 44470, 21396, 26246, 28044 +, 12770, 57416, 57900, 26075, 2180, 7890, 47404, 53632, 35140, 50231, 46811, 47838, 28110, 53394, 3124 +, 59209, 21041, 51295, 45941, 50378, 26808, 9800, 12765, 49142, 49675, 2110, 56243, 34145, 59858, 22489 +, 38541, 12629, 56257, 12793, 15056, 58437, 20684, 2460, 52069, 32176, 29043, 15233, 20014, 33506, 44979 +, 23139, 32715, 6021, 50786, 55008, 56399, 17594, 4809, 45516, 43089, 54484, 47627, 15684, 4981, 23837 +, 14525, 19875, 36466, 10782, 32668, 27874, 45572, 29704, 30335, 13993, 1880, 59378, 29226, 21895, 9236 +, 50558, 21386, 41952, 56579, 48524, 13312, 29330, 42470, 18121, 14846, 25559, 48957, 38825, 17595, 30291 +, 2663, 32120, 50166, 15481, 42903, 59186, 43356, 28475, 28891, 13691, 18820, 30771, 49421, 48047, 29018 +, 35010, 38605, 26756, 53314, 11536, 15280, 6626, 40866, 57751, 24748, 32064, 59662, 50057, 10890, 53610 +, 20348, 13553, 25730, 10514, 29034, 44985, 9701, 48742, 13460, 14944, 38785, 32281, 22067, 4559, 56680 +, 51086, 39569, 11637, 54194, 32883, 59525, 45827, 39509, 40391, 43578, 40609, 12455, 19592, 30667, 59697 +, 13202, 51015, 13250, 15285, 37882, 18637, 270, 23935, 43731, 50083, 38879, 22517, 58716, 946, 27076 +, 31748, 28384, 6645, 43385, 58931, 15880, 19262, 44758, 55389, 36005, 4688, 12351, 48460, 24280, 43018 +, 24510, 13835, 10385, 37760, 29120, 24619, 32749, 5742, 48554, 16481, 55825, 3785, 15350, 54541, 41084 +, 42426, 26289, 45820, 25423, 46026, 44751, 17655, 5288, 5861, 13044, 41293, 10549, 25395, 6106, 11182 +, 44765, 30616, 1369, 31503, 44728, 30489, 56122, 53830, 12583, 21029, 46663, 8409, 24814, 2013, 39302 +, 42250, 20791, 5592, 28071, 46214, 27970, 49174, 3869, 9611, 55036, 53265, 27256, 41937, 55013, 9714 +, 53119, 39778, 16682, 54488, 11281, 1411, 1329, 43756, 31593, 13913, 4785, 18256, 22322, 5951, 20269 +, 37976, 48202, 41060, 43568, 52625, 3626, 47891, 41799, 43847, 57502, 13187, 37112, 24758, 55125, 8477 +, 34473, 24596, 48256, 51155, 19085, 35889, 28918, 56766, 19645, 511, 10679, 782, 55119, 9353, 6734 +, 15388, 47330, 54936, 32800, 7250, 23913, 36426, 55141, 42064, 56625, 28995, 55252, 10090, 53754, 26729 +, 18567, 4579, 27677, 6823, 55734, 46762, 19065, 1005, 19881, 15062, 37868, 6912, 15845, 32988, 16266 +, 22579, 24728, 39948, 53867, 33881, 23550, 54132, 46659, 18692, 36196, 43285, 47687, 7800, 53375, 17793 +, 34529, 11942, 22372, 2207, 55118, 54459, 25321, 14183, 31816, 21554, 5597, 9684, 28467, 21442, 19024 +, 21085, 20373, 20105, 1033, 50592, 53986, 935, 44724, 40645, 55979, 20921, 23930, 43667, 28721, 53657 +, 37812, 39603, 5600, 36537, 18162, 37070, 30996, 19835, 27605, 39164, 41390, 33202, 25200, 9857, 30997 +, 44225, 30942, 51370, 40682, 8327, 18315, 34668, 9262, 3039, 51665, 5242, 312, 51948, 25261, 5386 +, 45605, 3073, 44989, 27557, 39610, 3151, 4627, 46958, 59338, 32232, 2474, 40728, 5435, 27675, 50585 +, 36432, 48252, 21527, 4154, 28934, 29854, 58821, 3602, 39117, 38213, 55267, 20711, 38525, 23567, 45972 +, 20263, 9173, 25397, 5252, 36730, 41360, 44755, 17710, 28318, 44094, 49942, 7145, 24822, 31729, 34820 +, 51760, 44513, 23072, 49639, 25020, 52006, 19494, 23841, 31960, 34963, 2054, 3579, 55674, 16932, 27147 +, 17998, 37195, 12672, 43395, 18800, 49402, 24755, 39907, 43464, 29426, 24001, 9759, 36571, 25176, 41488 +, 47743, 53288, 2354, 10815, 42927, 3726, 39173, 38773, 3919, 11133, 13736, 5974, 51064, 45762, 59258 +, 18211, 3760, 12805, 30883, 23508, 31605, 56638, 48263, 11513, 40102, 17689, 11866, 26213, 30612, 13394 +, 7702, 18355, 6682, 46408, 29170, 25962, 50134, 44695, 4735, 54053, 32180, 18472, 36379, 23245, 40586 +, 11989, 41456, 20699, 24795, 48692, 44207, 32752, 45330, 8822, 20617, 1784, 26512, 32484, 27998, 57124 +, 22230, 12052, 51832, 5265, 34812, 21002, 31227, 24946, 42050, 35962, 55351, 14230, 30786, 8083, 37475 +, 11373, 20072, 55284, 8424, 21219, 43976, 28983, 53972, 29306, 37805, 14589, 7442, 40669, 23425, 35440 +, 37794, 45656, 23844, 29626, 27273, 58656, 26980, 58500, 59954, 45382, 34462, 55306, 59613, 41601, 39741 +, 13440, 52974, 59813, 8724, 37750, 57385, 52700, 6733, 51357, 58358, 44538, 42298, 5801, 1560, 42076 +, 17593, 39354, 4084, 41438, 45332, 31357, 40094, 48664, 29857, 40049, 34047, 40671, 11707, 10012, 22272 +, 51448, 23452, 51598, 27613, 32177, 5700, 24998, 24877, 12433, 52707, 59588, 33324, 11358, 41741, 34884 +, 53434, 59334, 50590, 57518, 17124, 12274, 5227, 57219, 37290, 11436, 13620, 11337, 52107, 25327, 21349 +, 50732, 53127, 21154, 18682, 20740, 53331, 24383, 22091, 54560, 36816, 14798, 54148, 46492, 2508, 35889 +, 57728, 55942, 11576, 48318, 29812, 28700, 592, 11391, 25919, 14235, 22827, 15891, 25572, 51287, 17570 +, 23274, 18371, 10697, 44428, 37053, 31438, 14111, 1436, 29881, 8671, 14605, 21031, 2820, 37449, 23540 +, 15061, 35178, 55834, 26637, 23496, 1999, 31690, 441, 13390, 33961, 14676, 12570, 49853, 16600, 3857 +, 7423, 16226, 58580, 18121, 654, 35633, 25911, 14765, 13422, 32144, 59789, 4379, 53175, 38961, 41828 +, 16715, 54022, 53358, 48902, 57012, 53207, 50901, 28702, 30000, 40643, 2663, 44676, 53213, 28868, 37628 +, 33422, 36292, 53855, 8354, 30765, 30861, 43988, 33028, 21979, 33762, 5172, 58120, 14493, 58347, 37081 +, 32673, 51415, 7455, 26032, 40317, 4467, 19239, 7570, 9521, 49239, 48213, 48537, 10267, 17779, 17405 +, 47895, 27553, 30049, 18102, 35908, 814, 25316, 56248, 33842, 23647, 30010, 39014, 21767, 20855, 13714 +, 58848, 53528, 5129, 6303, 19560, 21798, 47123, 38799, 29368, 32996, 4390, 53933, 21533, 14657, 48064 +, 38939, 38905, 15618, 8988, 33359, 51526, 46155, 35027, 47774, 56349, 58674, 54136, 35364, 56793, 14991 +, 25430, 31993, 8519, 6911, 38297, 4432, 28709, 1772, 19583, 34429, 34768, 23974, 4714, 56302, 38631 +, 52779, 11593, 53888, 8397, 56933, 3600, 36275, 19440, 38627, 401, 15790, 13654, 30889, 27506, 10447 +, 22232, 52936, 42441, 7103, 59847, 57090, 11535, 4908, 58862, 31119, 39337, 9982, 55093, 44051, 6284 +, 10076, 36830, 54229, 40317, 21579, 27515, 43917, 34206, 46955, 22544, 34607, 2745, 36198, 5496, 30251 +, 22998, 27728, 59539, 5439, 34832, 35738, 2529, 22719, 40646, 1391, 53838, 56335, 47725, 25283, 16739 +, 54010, 35360, 29921, 24591, 52029, 51501, 28458, 35946, 25707, 15414, 34842, 36667, 54511, 11041, 18515 +, 1115, 10391, 22596, 37006, 15830, 33780, 12745, 18359, 56499, 29743, 56102, 50338, 26079, 43827, 51973 +, 42818, 14189, 27333, 12739, 15133, 55714, 40592, 43591, 31660, 42652, 35357, 6503, 19319, 6221, 53896 +, 37834, 7336, 4287, 430, 44342, 56469, 34210, 33439, 51180, 7062, 3183, 47282, 33752, 29262, 7461 +, 25725, 12080, 58003, 29411, 1171, 49488, 25125, 41764, 33079, 56786, 768, 44789, 39641, 20087, 51010 +, 9889, 34273, 58346, 14176, 11056, 19040, 46997, 21618, 52480, 38177, 28680, 55663, 1811, 2432, 1277 +, 9272, 28158, 49709, 43627, 57569, 27232, 33115, 22694, 8996, 42547, 55832, 46116, 27336, 35473, 6203 +, 18346, 45362, 40477, 53044, 35890, 27885, 48436, 22887, 49503, 17268, 1064, 18184, 49283, 2875, 20616 +, 50560, 48500, 25126, 16621, 8479, 22695, 43854, 17947, 21742, 29202, 494, 17574, 15319, 4182, 29400 +, 21522, 58880, 51114, 38351, 28276, 27005, 6236, 16712, 26244, 55740, 33981, 3661, 50276, 59616, 42888 +, 47244, 50177, 7740, 12371, 43150, 16220, 11418, 27004, 34167, 33160, 56207, 11013, 27087, 11526, 15195 +, 56487, 9400, 50427, 23953, 24104, 18703, 50958, 30340, 11767, 53555, 2432, 22100, 57216, 29060, 21717 +, 40104, 16305, 48246, 47845, 28676, 31396, 40417, 40094, 58401, 14584, 49607, 54608, 25597, 16694, 42486 +, 17144, 49533, 51886, 7571, 13486, 15990, 2626, 40797, 22683, 14393, 34352, 1467, 36494, 31568, 30528 +, 58211, 48024, 46833, 46457, 12221, 51861, 17853, 52638, 31955, 16254, 43574, 21562, 47214, 45523, 38256 +, 29700, 2667, 4141, 57939, 46590, 17628, 50281, 49216, 58425, 49316, 3610, 9129, 27136, 16456, 17049 +, 57664, 14667, 5073, 20849, 1124, 53647, 12710, 55329, 46285, 21017, 47936, 29860, 42580, 35150, 15383 +, 57188, 41203, 54403, 1330, 15494, 17345, 55310, 42127, 42914, 30087, 31444, 22876, 39216, 58580, 39332 +, 56265, 32596, 53999, 37690, 29797, 31475, 31337, 42507, 26804, 17623, 39876, 14740, 23835, 22456, 26243 +, 15570, 55997, 43798, 46325, 33679, 35644, 3671, 28989, 17771, 46585, 35428, 49215, 9461, 14644, 24147 +, 48793, 47261, 33095, 19144, 24951, 2892, 50619, 56289, 21751, 53775, 13912, 1628, 44868, 14099, 436 +, 11111, 29669, 32785, 31261, 15995, 6464, 6905, 56018, 11805, 24676, 18955, 47233, 50244, 28416, 38229 +, 50743, 53561, 25490, 23839, 49057, 50442, 3083, 39676, 46731, 1187, 9803, 36995, 39167, 54671, 51094 +, 15955, 42134, 57115, 48741, 13395, 13110, 31557, 20300, 45480, 19715, 44977, 4435, 43300, 11573, 9203 +, 21530, 2316, 39116, 23372, 2507, 28173, 13814, 41943, 44201, 36897, 19482, 54005, 50244, 58649, 48676 +, 17690, 14604, 30811, 14806, 39697, 20558, 4268, 47607, 40859, 49749, 7322, 2188, 54184, 50622, 50113 +, 39740, 48504, 52429, 18856, 11877, 31289, 47030, 2043, 13232, 7583, 38941, 32714, 1588, 29185, 7715 +, 26617, 23228, 58671, 33780, 38034, 14721, 54338, 42302, 2328, 11549, 8403, 9650, 50089, 38940, 36624 +, 40202, 18680, 25129, 8984, 13888, 13358, 40273, 37270, 15401, 29857, 44854, 54342, 38923, 46442, 59880 +, 22990, 49411, 23108, 21661, 23191, 37494, 36382, 53882, 56148, 15062, 5431, 4552, 1064, 55521, 19844 +, 37689, 12075, 14876, 39170, 21059, 28764, 52528, 1332, 6035, 7929, 7541, 50889, 38624, 22816, 13683 +, 14856, 45806, 39447, 14316, 7468, 38990, 51810, 20202, 32872, 47958, 35265, 14656, 28862, 12681, 46529 +, 25058, 50370, 58604, 39934, 5892, 19664, 45051, 34772, 57348, 27438, 19054, 4890, 54679, 57678, 27706 +, 44714, 48886, 49865, 24161, 3202, 57333, 3152, 31364, 53887, 36024, 55674, 5504, 27032, 889, 18186 +, 13561, 2299, 44908, 12166, 18586, 27153, 31830, 3637, 1925, 29178, 31075, 20979, 10420, 2106, 55009 +, 14479, 46820, 43895, 4344, 10982, 23449, 38029, 14134, 31165, 8268, 26510, 3192, 13773, 53543, 4081 +, 8311, 7104, 6380, 29571, 19270, 24966, 56724, 27452, 4955, 58650, 32983, 12382, 19629, 43403, 14488 +, 50991, 34234, 1309, 34886, 38578, 48643, 34688, 52959, 39129, 42205, 1228, 5639, 45397, 51353, 35534 +, 25830, 59664, 18991, 32211, 29235, 38261, 33529, 2312, 42066, 14837, 962, 15049, 27219, 56943, 34804 +, 18060, 47934, 9039, 55721, 59173, 23969, 44364, 10213, 16929, 59845, 52418, 54509, 5484, 14168, 45862 +, 17371, 39998, 21878, 36362, 48561, 27465, 50975, 58443, 29777, 33041, 13280, 7091, 24442, 16851, 4035 +, 35599, 34911, 28321, 20990, 6984, 3846, 44959, 27700, 14059, 38240, 27545, 42830, 9101, 9382, 56998 +, 54963, 3105, 36996, 16841, 39467, 1910, 20659, 30442, 353, 50436, 39836, 13633, 57528, 40630, 30484 +, 37915, 16229, 41748, 42588, 37219, 25084, 46435, 58531, 29137, 36846, 13123, 56682, 56028, 22225, 42416 +, 53026, 53540, 45521, 6375, 46734, 24988, 8285, 7393, 31783, 8638, 34181, 47971, 58623, 31709, 28601 +, 5459, 45976, 44831, 23559, 28565, 22050, 48644, 51352, 56933, 17781, 28198, 10057, 50815, 24227, 8634 +, 33232, 53605, 2174, 55105, 59980, 48908, 56446, 44617, 32653, 28229, 29607, 6835, 52552, 28230, 14896 +, 21153, 33690, 873, 5984, 57249, 29438, 4387, 22245, 20790, 1320, 16378, 25340, 47729, 7194, 25919 +, 56363, 16778, 19525, 34890, 48235, 55857, 150, 44681, 40475, 32804, 49262, 10082, 15991, 41814, 14665 +, 30887, 39320, 24707, 8112, 45304, 58308, 37550, 26043, 20554, 34692, 3716, 13284, 36385, 51445, 56830 +, 2304, 24161, 49960, 21829, 35403, 38196, 17687, 35553, 59229, 34514, 44709, 48492, 20948, 37052, 6658 +, 35613, 7940, 45978, 320, 16052, 7635, 58629, 29955, 33678, 55535, 40999, 13746, 8819, 17384, 41544 +, 42002, 56041, 42057, 31962, 54222, 17460, 10158, 48261, 53013, 9388, 22775, 14075, 34232, 20076, 51127 +, 40890, 32041, 35419, 3221, 8714, 51472, 10856, 43695, 57779, 20886, 39230, 15130, 34633, 24401, 8867 +, 52529, 6403, 4908, 34586, 38366, 59130, 52046, 24876, 47392, 21411, 34264, 46519, 35486, 44848, 6595 +, 2966, 2091, 38637, 38385, 5312, 47351, 6209, 52520, 31046, 40340, 49758, 46628, 55471, 743, 47381 +, 4338, 53272, 53785, 9246, 27858, 8503, 44728, 19904, 33379, 32120, 17668, 43996, 54992, 29506, 28844 +, 1587, 32472, 7287, 16576, 47210, 12599, 40279, 29771, 41471, 47677, 10112, 31230, 10657, 41935, 31973 +, 58039, 46273, 1598, 28176, 31871, 29456, 36679, 16599, 25713, 46410, 25072, 43381, 6758, 56416, 49239 +, 11955, 58003, 58064, 19242, 50932, 45274, 8194, 7563, 51397, 49665, 55241, 37861, 20895, 42250, 19796 +, 29221, 40289, 6069, 30819, 44817, 14292, 36627, 57848, 7244, 38692, 44259, 32316, 58425, 27369, 28732 +, 47665, 39324, 3087, 45729, 34919, 30371, 7355, 43113, 37935, 35104, 32778, 9528, 12966, 30026, 51778 +, 32762, 35599, 8420, 15184, 42770, 53237, 29476, 19397, 51086, 36720, 34442, 11697, 45388, 32867, 15418 +, 50472, 20532, 31095, 53560, 42613, 6014, 283, 26320, 49127, 14570, 1425, 58257, 24098, 14391, 28283 +, 52229, 47153, 3882, 37001, 2337, 23004, 6590, 8166, 18754, 34028, 44886, 53196, 22077, 6627, 26063 +, 37496, 57099, 22948, 8591, 27011, 5561, 14605, 27295, 31882, 40084, 41865, 9659, 38341, 42316, 24050 +, 6625, 10897, 47555, 46859, 47898, 26245, 46216, 54488, 34411, 4970, 28517, 55649, 58166, 50594, 2276 +, 581, 28090, 59376, 23529, 13033, 2739, 5443, 3990, 30034, 13677, 44074, 48252, 23336, 58768, 6920 +, 47386, 41745, 17817, 34941, 28604, 5715, 1186, 51172, 36555, 11949, 56142, 5072, 7599, 54308, 32019 +, 9875, 31242, 36461, 45603, 54771, 49495, 48343, 214, 29837, 54729, 13891, 13912, 19333, 37227, 12680 +, 26253, 965, 54425, 44070, 12259, 59381, 49785, 49797, 50554, 2693, 1747, 23048, 7765, 45698, 53709 +, 16136, 31925, 24951, 52598, 17529, 19722, 18445, 42224, 56289, 48282, 13305, 46532, 38546, 32639, 112 +, 27578, 58892, 1077, 58355, 42963, 49688, 34089, 9100, 39486, 995, 11793, 17585, 24043, 55911, 3283 +, 17752, 48399, 35208, 42703, 17349, 29089, 38778, 35794, 47665, 11419, 429, 971, 57951, 15327, 33610 +, 58063, 42906, 8854, 59141, 17613, 51817, 25181, 51702, 37270, 4667, 52697, 25415, 22252, 16741, 57678 +, 25535, 10845, 46078, 37096, 53549, 3427, 6185, 8679, 15574, 53851, 20098, 16003, 54822, 18049, 31330 +, 4784, 52465, 50588, 13638, 51606, 8202, 41808, 16787, 59904, 19078, 57807, 52602, 44493, 20059, 45695 +, 18524, 21947, 56540, 4602, 59043, 26441, 44381, 5228, 35120, 59955, 35431, 31570, 52310, 6605, 25972 +, 59993, 11389, 18437, 50581, 1380, 46395, 35135, 43188, 39534, 35040, 38618, 37341, 3994, 59463, 33753 +, 26041, 17987, 55700, 22581, 22589, 31095, 49023, 6971, 12675, 495, 43278, 48107, 32066, 35589, 31064 +, 58038, 35582, 18806, 16475, 26163, 20186, 39222, 37651, 3374, 18756, 49043, 41992, 56098, 53037, 41455 +, 29851, 55430, 35795, 1903, 18011, 58384, 32998, 43386, 41707, 22025, 43882, 24986, 10132, 52300, 575 +, 17549, 26690, 12509, 36355, 19517, 38672, 56541, 58739, 16323, 36267, 17495, 5366, 54611, 49945, 34755 +, 12418, 56148, 30185, 48213, 58051, 24549, 22950, 7401, 7935, 4657, 29427, 28169, 5995, 15911, 56821 +, 42922, 33460, 59863, 55431, 9815, 55732, 10456, 42708, 30823, 3131, 18975, 48319, 44850, 49938, 14616 +, 55957, 2357, 10765, 2495, 50570, 8816, 27044, 49872, 52570, 11331, 30882, 58349, 15853, 36877, 14260 +, 49026, 56152, 24073, 48890, 51583, 10240, 44622, 38391, 52949, 15446, 41523, 48276, 40117, 2725, 38215 +, 54733, 58682, 16924, 41850, 37529, 43846, 27019, 4573, 33719, 19589, 52257, 4601, 17938, 8110, 17830 +, 8550, 33488, 13982, 32623, 22378, 41918, 19216, 43353, 20309, 48517, 35151, 38184, 36793, 51620, 40909 +, 51360, 22705, 15944, 44636, 4556, 53473, 28483, 31575, 34399, 38554, 27516, 26656, 43155, 21806, 11118 +, 37337, 30356, 20958, 51320, 39332, 43337, 33238, 58548, 3042, 29899, 47065, 14545, 8084, 210, 6165 +, 25345, 51571, 28870, 17641, 36207, 9778, 47467, 41042, 17705, 21866, 19596, 45221, 24874, 39103, 7027 +, 12344, 16441, 37384, 33302, 44113, 53068, 52991, 17351, 51616, 32385, 23602, 38681, 46930, 8038, 38891 +, 53095, 33384, 6814, 58318, 27377, 19374, 44448, 14844, 36768, 2154, 36710, 56365, 23727, 37936, 11820 +, 30755, 50280, 28261, 44491, 59935, 12374, 37559, 52926, 6077, 29175, 25312, 6032, 44208, 12242, 14070 +, 59451, 41690, 23806, 42618, 16360, 51184, 1992, 808, 6028, 38760, 39314, 19091, 11477, 3042, 33379 +, 23298, 10149, 23660, 27911, 54640, 23595, 16638, 8551, 52873, 59067, 14078, 18185, 5099, 58286, 6780 +, 19170, 34089, 48470, 42976, 16707, 41182, 10512, 55051, 18342, 52893, 10164, 57657, 48336, 21641, 699 +, 21715, 21291, 10848, 45375, 25555, 41840, 45322, 42193, 50391, 38196, 17612, 40821, 32733, 22712, 15459 +, 39513, 18234, 49548, 4335, 37562, 42608, 45517, 48075, 37659, 40212, 17320, 47823, 37869, 5656, 45817 +, 14920, 27371, 43460, 25768, 49099, 45367, 43960, 10773, 27560, 10703, 25321, 21525, 51524, 58055, 44237 +, 6983, 13920, 2471, 32883, 18256, 40033, 51843, 40125, 4460, 29503, 20337, 21780, 53678, 34558, 3788 +, 15847, 49478, 31160, 59308, 51598, 56611, 44675, 35558, 43736, 48588, 46261, 9058, 10113, 14137, 43465 +, 30702, 57472, 57385, 33173, 6708, 51993, 49558, 58551, 8471, 54019, 28054, 5160, 52151, 58085, 39719 +, 55940, 13932, 29197, 3452, 13240, 20796, 36415, 34268, 32706, 20151, 59208, 55320, 5561, 45673, 9457 +, 49026, 16375, 43282, 22764, 25900, 49990, 51109, 51810, 48541, 59580, 45829, 52948, 4741, 14333, 51033 +, 20812, 10273, 4965, 26361, 50077, 54558, 23509, 26492, 5178, 56216, 22995, 4386, 27888, 28557, 50059 +, 37345, 53935, 42786, 56979, 16699, 8686, 46969, 7809, 496, 11863, 43741, 22678, 4811, 24834, 13363 +, 32196, 45646, 59988, 37161, 48360, 50065, 8071, 11869, 52909, 13249, 44437, 15904, 53987, 12325, 44461 +, 20398, 26023, 38397, 3184, 23002, 31448, 48222, 9972, 15609, 25071, 21835, 59351, 24101, 2998, 24185 +, 37464, 35194, 46184, 13804, 48707, 34544, 3869, 56779, 22765, 56778, 46380, 7203, 12682, 40368, 55880 +, 33496, 766, 21903, 48245, 40303, 44906, 19693, 28525, 31230, 35303, 53596, 29417, 11006, 54049, 32415 +, 11543, 7865, 43961, 34079, 21669, 32668, 44975, 25538, 29447, 7741, 58668, 15828, 51296, 47703, 32548 +, 47176, 21199, 33314, 9080, 9444, 13617, 30338, 5489, 18495, 1568, 17144, 48443, 30985, 4502, 42493 +, 39752, 16046, 50358, 23713, 50125, 12028, 56381, 11453, 13918, 2181, 19194, 12587, 54361, 10490, 290 +, 26909, 57666, 21489, 36575, 43098, 7285, 26545, 13436, 12774, 45040, 51356, 6271, 9835, 58693, 10773 +, 52328, 38445, 26819, 42687, 38510, 53297, 31067, 11244, 4750, 44985, 49777, 296, 57572, 44138, 10786 +, 34214, 47399, 44804, 55703, 326, 27903, 39340, 3223, 17691, 28467, 24615, 9048, 34738, 34451, 7741 +, 45511, 26779, 22539, 48683, 45818, 37401, 18332, 16885, 48645, 59434, 38223, 38422, 59730, 35795, 58912 +, 46868, 10010, 22663, 8024, 42065, 59342, 12279, 57758, 2565, 29971, 26225, 3533, 15371, 37315, 37984 +, 23112, 22826, 4763, 22003, 47861, 26934, 59405, 42545, 20171, 24402, 18331, 58394, 39177, 18061, 34190 +, 14441, 41281, 20552, 37105, 49306, 38969, 12799, 37937, 36727, 51716, 7908, 2952, 55249, 23279, 16619 +, 33233, 22744, 39446, 14349, 21099, 3659, 17635, 20504, 22557, 37806, 21259, 40888, 36201, 436, 35302 +, 46743, 14877, 16583, 43647, 28334, 42241, 22616, 41133, 20179, 35696, 9202, 4439, 15000, 4451, 4071 +, 31620, 14037, 3167, 47418, 4738, 24266, 51077, 22373, 21123, 49986, 36531, 42382, 30875, 12732, 42818 +, 42529, 59475, 34047, 35464, 19474, 2382, 54058, 42091, 19867, 50589, 17787, 29069, 55028, 32787, 9873 +, 35451, 4407, 262, 38618, 51825, 5000, 39237, 19255, 3725, 360, 9241, 40256, 19094, 16468, 52989 +, 38264, 58997, 28816, 12311, 34462, 48291, 51045, 28520, 6734, 10913, 19109, 24521, 16334, 50489, 33660 +, 26207, 2293, 14420, 26469, 40911, 6245, 7821, 56500, 1852, 11546, 33212, 47446, 51803, 52306, 3914 +, 21144, 6922, 39264, 26312, 19234, 50078, 50955, 10279, 54950, 57689, 57544, 50411, 58562, 13879, 17252 +, 8575, 40086, 19545, 22995, 42908, 457, 5592, 50729, 33309, 7445, 2276, 6522, 54891, 30431, 35180 +, 35157, 51575, 42103, 14421, 54239, 1337, 40851, 45195, 47968, 35801, 42884, 45513, 2564, 17799, 59392 +, 19817, 26374, 15830, 39362, 49369, 58738, 16171, 54961, 49468, 49481, 38758, 28096, 32355, 33649, 58527 +, 7535, 45159, 26454, 49638, 59580, 20693, 27327, 16784, 5888, 15296, 28937, 25125, 37161, 31502, 42924 +, 36553, 27671, 45650, 28735, 7033, 35019, 27474, 59557, 6332, 53294, 25390, 45091, 21390, 57745, 55092 +, 19917, 5280, 40251, 46371, 54919, 16184, 7064, 22246, 32968, 49305, 13894, 1905, 14430, 51055, 9759 +, 33706, 3960, 37430, 19356, 32696, 20816, 30727, 36522, 20373, 13411, 29816, 45763, 58502, 51206, 43508 +, 53595, 47475, 25140, 33846, 33846, 20059, 26382, 17262, 18658, 59350, 6567, 8904, 37608, 57349, 59960 +, 47367, 7407, 40272, 1150, 3115, 49320, 21966, 33842, 25842, 18691, 23606, 32010, 40806, 22108, 59568 +, 666, 52055, 47043, 25806, 2254, 57241, 22218, 28636, 50856, 17228, 4339, 57423, 26132, 41947, 31125 +, 26092, 5666, 38532, 42717, 6816, 41648, 32037, 5134, 51842, 34232, 23825, 15448, 42594, 40983, 13909 +, 42163, 41649, 42316, 5558, 7456, 20922, 39152, 29674, 25911, 30008, 46902, 30250, 3783, 13034, 12197 +, 34908, 15479, 54215, 49793, 34548, 37384, 7793, 42937, 42518, 35987, 17169, 42696, 27788, 59764, 23679 +, 41697, 18279, 41681, 365, 189, 49137, 21288, 39341, 55163, 47199, 9349, 42065, 53801, 13133, 31451 +, 42350, 24393, 23282, 36565, 50538, 57830, 13949, 58331, 40768, 32820, 34319, 34289, 51868, 2107, 10405 +, 51899, 20156, 28684, 33580, 20521, 5226, 22717, 18161, 44567, 17880, 41712, 30269, 36297, 35513, 19754 +, 44101, 17863, 44147, 7383, 30781, 34686, 5214, 44730, 9369, 22334, 53902, 43688, 56623, 45770, 45795 +, 43381, 14022, 42303, 48417, 47602, 2825, 53643, 46672, 57338, 38211, 40904, 39051, 44832, 17202, 50916 +, 4586, 1303, 45132, 25085, 45038, 15913, 36123, 26604, 36995, 45493, 48938, 7250, 5533, 21914, 53020 +, 51329, 5295, 7042, 9984, 53712, 30997, 49161, 23708, 17669, 46500, 38271, 58573, 1903, 23103, 52127 +, 29171, 27689, 29782, 14303, 29126, 14821, 6568, 5250, 41425, 43564, 27095, 30364, 50814, 32628, 28630 +, 20186, 309, 10277, 3581, 10294, 40341, 34578, 59455, 4049, 28599, 45955, 42320, 3524, 24210, 5423 +, 32004, 53382, 9464, 1786, 7685, 38591, 16607, 14254, 20193, 58033, 34170, 47288, 4749, 24984, 19916 +, 9731, 21522, 20226, 20008, 25103, 30520, 349, 36033, 29975, 40751, 40984, 52283, 23071, 20861, 16493 +, 4847, 52865, 9875, 50663, 54651, 53913, 5606, 11259, 8167, 25799, 45644, 18689, 49439, 26745, 20025 +, 9356, 36476, 41547, 5934, 32836, 43003, 36454, 33185, 19036, 42781, 50288, 36373, 11416, 49712, 57234 +, 27910, 54559, 50099, 14137, 21574, 21102, 8050, 27181, 8713, 52569, 29332, 54357, 11258, 18772, 57454 +, 31283, 28128, 33930, 49183, 34062, 43118, 32186, 46868, 52656, 27574, 6001, 42944, 3947, 17418, 32656 +, 37533, 21680, 27215, 27632, 12169, 25142, 25087, 56572, 52323, 33800, 49141, 21655, 4510, 36752, 40427 +, 1964, 44387, 44907, 12247, 33570, 55321, 55365, 42108, 18541, 48021, 9683, 24543, 30966, 49982, 18313 +, 39974, 27516, 16345, 43542, 31500, 28514, 8684, 56587, 25086, 1007, 6740, 50580, 22662, 11250, 27332 +, 39442, 13214, 48071, 24349, 1813, 57994, 56023, 57179, 40102, 14564, 21552, 26137, 39107, 28870, 16120 +, 33772, 8845, 43636, 50117, 52387, 51488, 54984, 1071, 24428, 20070, 2078, 31168, 10650, 1092, 42418 +, 14334, 16886, 31984, 2406, 17588, 33798, 400, 13611, 7329, 16854, 28175, 5233, 42992, 43635, 34104 +, 59112, 17407, 42949, 19100, 43877, 35336, 46940, 38861, 12759, 11368, 35283, 51189, 42536, 45934, 28633 +, 1306, 36620, 45520, 9643, 15378, 3108, 19793, 52130, 53071, 27122, 8985, 21246, 8707, 51977, 4881 +, 42811, 27441, 58641, 25760, 22893, 18870, 37448, 9833, 34083, 26559, 21202, 9366, 17748, 40090, 31652 +, 46382, 17749, 8273, 8254, 27392, 23651, 47714, 47185, 15782, 40785, 50659, 1119, 2031, 59366, 29448 +, 43265, 42178, 56889, 18258, 44290, 19782, 13480, 58091, 5967, 47563, 24650, 3521, 56929, 18751, 19964 +, 28582, 41485, 37713, 13207, 26091, 5105, 13210, 13805, 28642, 5344, 30942, 19301, 6463, 32973, 55019 +, 35911, 52590, 13549, 32800, 47200, 34192, 28934, 680, 8635, 11254, 48243, 9637, 14775, 21525, 28388 +, 34739, 26459, 46225, 12452, 16018, 12316, 53909, 29228, 2473, 58903, 34573, 33415, 18204, 41036, 42741 +, 49576, 16948, 35331, 3125, 26100, 58884, 13669, 31387, 59564, 22304, 42641, 24160, 31942, 33768, 22037 +, 36682, 8508, 24848, 22908, 57312, 40866, 35224, 27574, 10094, 37698, 26477, 44667, 11113, 21034, 2056 +, 53854, 10610, 55356, 5538, 50087, 57808, 40774, 3757, 5547, 40338, 26061, 48188, 40850, 34355, 58309 +, 39239, 11038, 6817, 4087, 33946, 40481, 44953, 45522, 8055, 31400, 59572, 34533, 52419, 47038, 55567 +, 54475, 17244, 42529, 26183, 22782, 32616, 23992, 39908, 12725, 5891, 20247, 15139, 30432, 37449, 49494 +, 28741, 53041, 532, 11910, 57128, 34478, 52391, 42082, 56353, 447, 49834, 55925, 11332, 42253, 42963 +, 6899, 36729, 208, 25780, 39264, 59342, 58396, 39608, 39251, 11122, 45500, 35850, 2613, 15932, 49651 +, 52107, 21025, 42692, 52640, 32935, 16173, 3470, 25326, 34607, 59823, 2125, 24441, 55749, 13457, 6694 +, 15064, 56708, 19775, 51624, 22488, 59040, 50967, 57237, 38648, 6570, 44711, 500, 18772, 47324, 52784 +, 8423, 39431, 13809, 27468, 32071, 46744, 43641, 35542, 12071, 18248, 11717, 14196, 42689, 43818, 4006 +, 25735, 58883, 714, 45511, 50507, 23203, 44551, 17826, 20440, 59551, 24396, 41503, 36404, 43168, 28827 +, 29188, 27944, 8258, 42998, 31764, 16682, 29742, 15405, 28576, 18165, 10005, 40293, 8714, 29046, 24112 +, 12720, 54781, 22995, 49786, 40292, 49854, 12989, 1195, 7681, 9781, 37099, 32077, 27636, 13503, 51598 +, 56463, 42691, 55894, 4722, 2041, 27658, 57756, 8136, 19415, 26332, 26301, 29420, 6625, 11367, 58466 +, 7089, 439, 53247, 6436, 50226, 9892, 56291, 39567, 11087, 3972, 25701, 48186, 36049, 53337, 1689 +, 3999, 49801, 20733, 59893, 30875, 22774, 3903, 28631, 7262, 23318, 54963, 9916, 29090, 37940, 21283 +, 27556, 45030, 21723, 57156, 51466, 48301, 7048, 24109, 27868, 54487, 28081, 53569, 42674, 40483, 23259 +, 20715, 44482, 13060, 17800, 20728, 20287, 16927, 24631, 48918, 24189, 24302, 20233, 34105, 53392, 58173 +, 31741, 57301, 19555, 53464, 30809, 47374, 18117, 14209, 11483, 45985, 8696, 39565, 15907, 27722, 20048 +, 39166, 48438, 40882, 28578, 6238, 37962, 25217, 59517, 38946, 14135, 23707, 3248, 10720, 34164, 32992 +, 8893, 5905, 30293, 28449, 35721, 37454, 52175, 53838, 51663, 3658, 39824, 360, 43223, 32083, 28082 +, 39623, 47601, 52872, 56858, 52531, 35463, 34820, 17748, 34980, 13766, 8235, 58687, 53366, 18955, 32852 +, 26359, 4200, 38757, 33004, 9001, 50831, 10459, 1176, 44669, 38474, 4835, 845, 38834, 24410, 32928 +, 6917, 40386, 56881, 36141, 37244, 49412, 11604, 48416, 43512, 46585, 2183, 51747, 21624, 31901, 10702 +, 30828, 34612, 14903, 45938, 7617, 256, 36769, 54428, 1433, 21438, 32902, 6268, 22284, 48089, 7030 +, 31564, 31358, 47416, 28446, 7499, 24660, 17858, 19104, 13077, 37723, 42041, 51612, 29470, 3665, 59865 +, 16525, 34494, 34478, 7780, 20432, 18447, 8036, 57201, 49227, 9469, 18639, 58481, 52089, 17275, 46570 +, 59120, 48840, 17928, 46536, 17286, 1780, 47549, 11496, 57236, 36978, 49219, 39277, 4942, 55042, 42942 +, 4807, 47919, 17436, 39285, 55699, 14220, 57732, 40087, 47773, 46959, 25909, 6413, 21793, 54350, 40 +, 8363, 53470, 48880, 2644, 16359, 6166, 40776, 40260, 54015, 38012, 17238, 43234, 17289, 22180, 14628 +, 231, 26987, 2547, 54020, 42625, 34598, 44592, 16709, 51038, 32366, 40021, 16947, 15131, 1814, 47649 +, 15171, 10177, 41120, 4052, 49173, 33831, 46570, 29949, 14091, 40585, 7961, 7681, 172, 1602, 6213 +, 51152, 1834, 9552, 53700, 32206, 52177, 4650, 53150, 8887, 55688, 25516, 48908, 48987, 40647, 50722 +, 36637, 32171, 37251, 54109, 36223, 26425, 27940, 59145, 32726, 18383, 16083, 17040, 2416, 16255, 18642 +, 8629, 7407, 56828, 18181, 37459, 29034, 10359, 18462, 58537, 55598, 14150, 24053, 20858, 39490, 41053 +, 47932, 16127, 13224, 25183, 10236, 25799, 27960, 14528, 1296, 687, 9263, 17379, 54079, 11679, 33634 +, 12721, 20308, 17394, 9550, 14841, 31205, 14936, 1552, 49667, 13473, 57150, 40170, 13879, 54360, 19660 +, 54932, 42292, 12139, 44508, 7476, 22375, 46659, 11788, 13255, 47955, 48827, 58870, 5335, 42906, 10549 +, 15321, 55628, 7209, 9067, 5178, 58402, 16625, 20114, 59955, 42644, 9940, 33457, 22814, 23819, 27818 +, 18826, 55103, 10110, 30965, 39611, 53938, 53340, 2622, 5727, 42947, 26929, 54554, 41817, 32264, 13813 +, 28718, 23938, 9441, 12279, 9357, 50971, 10682, 25982, 47437, 46989, 8627, 57377, 20446, 7793, 21196 +, 24616, 26620, 16299, 34727, 57585, 32262, 28665, 27278, 34884, 10744, 46577, 1814, 5299, 4747, 10430 +, 55464, 9817, 10720, 4905, 22097, 20078, 32228, 9131, 22412, 19665, 32472, 7391, 17043, 29270, 15185 +, 38239, 53887, 18157, 30891, 28614, 15742, 3153, 33631, 19372, 14390, 44376, 5950, 52556, 26027, 10697 +, 39338, 21491, 20514, 50059, 2748, 18963, 46489, 34976, 4446, 8901, 54641, 36918, 16293, 11684, 6189 +, 7830, 26276, 36428, 25987, 33519, 5042, 18081, 13024, 38673, 37454, 27414, 59401, 43404, 56322, 25428 +, 30453, 35661, 46919, 27319, 2072, 26019, 22635, 48561, 995, 27081, 33814, 55637, 40352, 26459, 43673 +, 22893, 34289, 46301, 59321, 276, 19820, 4363, 54710, 32845, 19388, 32164, 36611, 18790, 51920, 9286 +, 20570, 22373, 44947, 43842, 26044, 23371, 9861, 48679, 11932, 10857, 15761, 22098, 42846, 32465, 48558 +, 2871, 55358, 22847, 25525, 31031, 59476, 21697, 11746, 54186, 30894, 7486, 2702, 43858, 26276, 54622 +, 53144, 23199, 53347, 38091, 7041, 19391, 1462, 53254, 44423, 49746, 40463, 36536, 11844, 59661, 9001 +, 402, 2533, 40711, 59602, 4410, 11742, 59078, 26107, 23488, 29616, 57002, 30974, 32318, 40860, 33603 +, 3292, 34004, 33154, 56639, 48447, 40195, 52382, 26261, 33449, 36805, 52359, 50265, 13341, 4203, 49926 +, 22342, 40958, 52459, 39405, 40560, 33221, 51147, 15990, 59329, 50987, 45606, 32683, 58314, 54276, 49895 +, 31917, 57568, 251, 5071, 54207, 48698, 21618, 22941, 51311, 31419, 59747, 43670, 21684, 13088, 47873 +, 11611, 11783, 5183, 40422, 51188, 22095, 13644, 18688, 38085, 49325, 9675, 43, 22008, 7989, 54319 +, 11903, 16258, 28239, 12154, 57681, 58798, 37204, 19299, 21740, 4867, 50719, 21487, 48537, 48755, 10927 +, 12762, 366, 59062, 17946, 17141, 26603, 40041, 30785, 45291, 54479, 56462, 31318, 54522, 18470, 15660 +, 25194, 6725, 8270, 53433, 55231, 5952, 52232, 8787, 25251, 50324, 13654, 52322, 11811, 2191, 17430 +, 59090, 14953, 54148, 34505, 9251, 11289, 1108, 25645, 18426, 22751, 20124, 14888, 30421, 50998, 9710 +, 46081, 52544, 16435, 54352, 22330, 48018, 36656, 50914, 56805, 1907, 41238, 10459, 30582, 29401, 49002 +, 48012, 28491, 40308, 18512, 39348, 49559, 29802, 40456, 51556, 24580, 39559, 48032, 15821, 9981, 39031 +, 25531, 32414, 7927, 18319, 3118, 30257, 6337, 39774, 21171, 39495, 18034, 38761, 26306, 24968, 8162 +, 15309, 49332, 13006, 31969, 7844, 52354, 21528, 13998, 9163, 49437, 14931, 48722, 37469, 30752, 35055 +, 52852, 32635, 43822, 780, 50954, 46940, 7389, 33644, 3067, 4913, 49491, 57453, 43674, 15797, 22421 +, 28189, 7458, 48105, 41195, 39427, 55949, 9901, 37308, 46300, 19064, 26745, 1231, 44139, 4214, 31983 +, 55546, 33419, 4618, 39368, 34199, 31925, 2661, 17940, 41921, 42080, 22853, 31412, 39533, 42880, 47209 +, 38306, 11069, 31020, 26411, 28616, 10447, 58712, 38517, 24107, 21364, 33934, 50852, 22595, 54425, 31419 +, 30930, 49971, 4838, 11901, 5692, 15389, 43826, 44705, 9681, 25747, 3137, 32535, 33511, 42670, 51767 +, 57072, 57328, 2836, 28092, 91, 31452, 14892, 58803, 46321, 38999, 56520, 20255, 6204, 19115, 14680 +, 13975, 26398, 41004, 55165, 38299, 23048, 46906, 58477, 7753, 56587, 24224, 10890, 5474, 34087, 29912 +, 57241, 31159, 27240, 77, 59252, 3683, 7881, 50496, 38838, 54203, 5847, 35358, 14458, 48403, 54474 +, 5491, 2378, 20872, 46495, 33895, 35523, 9543, 20801, 34000, 53648, 53741, 34576, 40890, 59215, 8663 +, 10802, 56457, 39822, 14394, 32886, 15426, 18077, 17120, 42274, 56915, 11323, 48122, 32274, 2133, 36525 +, 3100, 7624, 15256, 324, 30471, 49151, 35847, 16366, 46305, 46199, 46366, 40046, 20775, 27256, 39261 +, 29438, 14410, 12070, 45612, 28804, 21309, 1039, 23233, 38429, 43313, 56501, 26104, 7787, 5127, 28237 +, 20665, 8227, 12214, 35921, 44903, 19037, 1424, 20750, 11756, 24081, 6949, 58122, 4127, 4076, 25379 +, 19741, 33514, 39789, 8163, 55478, 44946, 29472, 56517, 8179, 44253, 16183, 4680, 10357, 322, 9807 +, 14947, 20987, 54386, 3513, 33260, 39289, 58902, 11037, 36391, 10658, 35118, 19692, 45133, 39246, 23768 +, 46864, 35339, 33634, 3005, 43502, 29113, 47951, 49327, 1982, 32483, 33580, 54517, 13515, 20290, 54840 +, 59675, 11589, 52179, 54061, 51454, 25440, 9703, 26708, 12829, 22446, 13719, 47947, 42139, 58852, 3545 +, 42259, 45716, 38884, 15894, 48721, 22387, 45007, 13025, 48066, 23341, 45508, 57998, 17859, 35375, 54640 +, 49051, 35050, 6229, 41230, 5464, 34035, 43022, 15167, 744, 55851, 13965, 14463, 43799, 56104, 49667 +, 47344, 14716, 11735, 2581, 30610, 456, 1320, 51969, 49833, 49386, 51662, 11693, 47384, 9521, 47069 +, 42025, 58572, 22119, 24606, 16155, 27583, 58642, 59177, 19102, 35738, 55029, 9420, 50201, 15180, 5524 +, 16220, 38876, 56592, 27955, 41457, 3554, 4763, 42777, 31875, 54597, 32163, 23538, 6290, 55900, 9411 +, 29711, 14277, 7984, 51831, 38883, 491, 55766, 13877, 59668, 51221, 49615, 31049, 641, 16168, 22581 +, 42517, 32388, 1458, 39110, 343, 19267, 42664, 5107, 2045, 14540, 36056, 10560, 14430, 18698, 6460 +, 23841, 48410, 57089, 8177, 40241, 12325, 8668, 12359, 26202, 8337, 3580, 52170, 15738, 40573, 44690 +, 38320, 23091, 53431, 16130, 38553, 30126, 35397, 57569, 11585, 37442, 48461, 23993, 24355, 2891, 42692 +, 7167, 26733, 31102, 4257, 11262, 47695, 16582, 19931, 54, 19136, 4620, 39987, 47658, 20358, 56912 +, 8701, 35030, 56355, 38484, 51160, 34908, 8610, 2910, 32478, 56548, 16704, 20939, 20541, 41059, 183 +, 3233, 48227, 3268, 10687, 28836, 14530, 58382, 21770, 34461, 34789, 17258, 15433, 51128, 4917, 35792 +, 48040, 49970, 47174, 44396, 28454, 38335, 55656, 13416, 17597, 28134, 9964, 34301, 25426, 30506, 15361 +, 25609, 10091, 39940, 5229, 20779, 8776, 19759, 55513, 30546, 30573, 30302, 47804, 46006, 21430, 29073 +, 58150, 45823, 55395, 45325, 6571, 23849, 12, 2227, 13618, 17609, 6714, 23582, 51910, 32140, 30440 +, 43623, 34101, 16884, 23563, 39330, 37663, 32339, 35441, 33176, 39237, 6014, 39831, 3394, 28373, 37613 +, 8819, 26523, 23436, 4215, 11848, 6359, 4416, 48212, 8587, 54386, 5821, 15301, 17969, 57732, 47441 +, 24761, 41355, 57894, 41645, 41271, 13576, 55660, 49962, 49017, 5189, 29200, 31384, 21372, 8946, 59757 +, 58985, 54117, 2632, 58774, 34684, 50833, 5133, 39101, 39045, 50072, 33487, 21219, 5373, 27808, 18951 +, 29166, 28922, 36658, 27060, 46919, 54281, 16988, 42580, 44244, 6006, 24121, 49796, 37390, 45493, 58742 +, 13499, 20830, 29211, 16131, 19604, 3896, 6964, 1090, 42997, 22362, 51162, 52836, 43581, 32888, 56997 +, 38884, 2054, 25919, 51894, 5467, 12838, 46176, 22455, 31770, 30420, 4813, 32243, 56568, 42203, 54088 +, 31662, 55702, 14919, 873, 48186, 10875, 4769, 31502, 48317, 24118, 53864, 39480, 16955, 13797, 12368 +, 13952, 52681, 50774, 16223, 44576, 32593, 5413, 7104, 31401, 13536, 13876, 36214, 45779, 10444, 54770 +, 39868, 42106, 26824, 31139, 42979, 15010, 18366, 24101, 22865, 6684, 48219, 16729, 46164, 5174, 30527 +, 34884, 55478, 59560, 2010, 48053, 20488, 34604, 53467, 27592, 42357, 7003, 41468, 18571, 29134, 28264 +, 13341, 45354, 10370, 16518, 16493, 29702, 31528, 34860, 30155, 30745, 17896, 18374, 47475, 4060, 59901 +, 54354, 15296, 31731, 30266, 17306, 19785, 50755, 28262, 49604, 18347, 10619, 32959, 36168, 5543, 2093 +, 4432, 55236, 47448, 51155, 11754, 40293, 57209, 19635, 51505, 27364, 50380, 9401, 45738, 14207, 49813 +, 45639, 44913, 5109, 53723, 15180, 58768, 13508, 5935, 3382, 39464, 24282, 50354, 12423, 36802, 55897 +, 50868, 41235, 27485, 14668, 32390, 15592, 54962, 29599, 35227, 46467, 56963, 1959, 32221, 19053, 16167 +, 22034, 4693, 1080, 3496, 58416, 16260, 2264, 48276, 58547, 41998, 27740, 59182, 32352, 16515, 35984 +, 4601, 43735, 17219, 32087, 58404, 25961, 24031, 53366, 55560, 59258, 16185, 28875, 1217, 24758, 47929 +, 53736, 46793, 28974, 54817, 50289, 3742, 47429, 28905, 52018, 22329, 10903, 56110, 21511, 19608, 48977 +, 33847, 24209, 32712, 51067, 32648, 31116, 53380, 56679, 834, 25293, 32289, 53372, 54168, 33507, 18130 +, 18449, 3595, 4923, 47423, 34764, 31564, 27517, 58546, 469, 19535, 20875, 47725, 51997, 18738, 7333 +, 17326, 52585, 7894, 50039, 20004, 40543, 57507, 13385, 13574, 34694, 15030, 45864, 28066, 9198, 55723 +, 46196, 4000, 59318, 27472, 27775, 10435, 35388, 55293, 8981, 12210, 51180, 29856, 59935, 43178, 24946 +, 43620, 36856, 17531, 51514, 3247, 13888, 8409, 755, 27273, 58336, 35449, 42303, 44200, 39867, 27853 +, 16275, 2415, 8205, 51945, 6239, 35981, 2380, 41628, 31274, 11361, 53838, 22454, 17569, 30125, 41984 +, 42515, 50097, 18841, 36399, 41611, 22088, 50287, 26373, 59195, 53912, 24709, 10996, 12567, 45261, 50863 +, 16772, 37888, 29631, 24978, 29833, 35870, 959, 8566, 53850, 8585, 19927, 24040, 7391, 13849, 30517 +, 49376, 32716, 20614, 44569, 45467, 38578, 6657, 35754, 4951, 42205, 6018, 6012, 53201, 18585, 51273 +, 20417, 11710, 5513, 26400, 36688, 35346, 38622, 13999, 43912, 32473, 22584, 40192, 32865, 29975, 30393 +, 3383, 55703, 3109, 349, 40272, 24929, 38927, 23282, 37035, 20230, 5487, 43054, 26242, 35040, 37991 +, 53867, 31809, 49701, 59380, 58209, 26389, 34727, 13184, 40388, 54991, 45657, 39324, 11535, 54874, 45652 +, 41928, 58257, 41355, 21390, 58607, 57980, 46319, 13886, 21262, 23354, 34117, 3101, 42760, 359, 14493 +, 20752, 30579, 46303, 10453, 29959, 20864, 36843, 41038, 34048, 53583, 12382, 56057, 9260, 23917, 50932 +, 31264, 5846, 25541, 48971, 3588, 500, 46951, 49907, 14387, 44565, 49613, 24856, 24018, 32374, 1567 +, 38512, 53126, 32146, 1167, 3579, 2106, 22031, 16774, 19496, 32432, 46710, 31878, 28489, 55970, 55796 +, 55773, 27234, 37994, 57667, 16205, 41582, 34519, 39509, 7841, 25258, 24074, 57454, 50114, 48093, 6180 +, 51682, 2957, 59306, 23828, 4124, 39238, 2286, 2507, 32364, 21783, 34939, 19074, 53661, 39781, 51396 +, 25809, 11906, 18630, 3803, 9573, 11188, 21737, 20445, 27049, 29578, 45703, 27475, 3385, 35818, 51920 +, 9565, 3852, 54877, 8872, 27680, 35353, 24462, 6319, 37861, 56826, 28102, 49152, 15901, 58115, 28933 +, 7297, 277, 17192, 2280, 40432, 3117, 49820, 2170, 23562, 16869, 31748, 9266, 20696, 35133, 21436 +, 12617, 44699, 25288, 7494, 29923, 29320, 42848, 30737, 35639, 57061, 27563, 40093, 46213, 19816, 38209 +, 51499, 3466, 14838, 8691, 42098, 55270, 11808, 31918, 57440, 11723, 25139, 5541, 57341, 45835, 40674 +, 18777, 34804, 1725, 20417, 42299, 8000, 49737, 1499, 15089, 1729, 34912, 19005, 41822, 21125, 38821 +, 56383, 48976, 18639, 11221, 57667, 737, 6492, 45828, 9007, 3932, 57551, 10498, 45825, 31244, 32686 +, 2852, 50021, 7490, 40929, 46790, 26141, 48930, 36527, 3992, 4019, 38256, 38904, 23024, 56431, 36382 +, 38198, 52814, 25358, 33189, 4036, 59378, 10279, 46880, 45206, 19286, 27164, 19109, 6137, 12990, 50353 +, 38823, 15842, 16726, 46313, 56771, 3516, 12455, 22053, 16395, 52799, 2425, 31004, 31704, 1801, 27435 +, 44438, 39999, 56601, 9796, 49541, 637, 9174, 59820, 47517, 30732, 55458, 14682, 26193, 1595, 4024 +, 16546, 40418, 19866, 9624, 3084, 52989, 13140, 15539, 15043, 5888, 44690, 17468, 36892, 16394, 19269 +, 40679, 832, 35621, 37280, 46981, 25162, 14270, 32507, 24982, 38139, 3240, 56792, 52821, 29433, 58388 +, 33197, 22332, 38806, 53063, 31956, 41890, 46053, 21449, 33781, 37448, 27337, 18472, 54916, 40581, 11218 +, 14185, 21260, 48403, 26158, 34892, 35384, 51320, 49162, 7891, 52654, 27302, 47483, 49447, 56475, 16917 +, 47835, 29673, 39249, 2993, 59088, 47557, 21236, 21493, 45358, 55017, 58941, 12695, 49841, 53857, 29628 +, 1060, 44395, 27240, 49463, 10553, 2133, 1199, 1874, 51295, 9090, 30880, 54949, 32926, 20327, 51425 +, 49843, 44514, 57450, 5444, 23860, 56538, 29353, 45096, 54384, 14712, 40113, 53325, 27407, 6307, 23535 +, 33388, 7367, 7930, 628, 33182, 18483, 2761, 10733, 56709, 30409, 56175, 3942, 1710, 29101, 621 +, 29487, 18944, 21488, 26937, 740, 45348, 59828, 30094, 30444, 54212, 44806, 46909, 23889, 48565, 53216 +, 47424, 21953, 36935, 55354, 58934, 46469, 50190, 38047, 57202, 23251, 44808, 53378, 3545, 46519, 22479 +, 4167, 16006, 17776, 25655, 19296, 18516, 11003, 19124, 24962, 17799, 49688, 46120, 4708, 13577, 34686 +, 57925, 1002, 32991, 34860, 32708, 31925, 21330, 22898, 46325, 54884, 22502, 31133, 48262, 26047, 17652 +, 47094, 6566, 10011, 4870, 32221, 29307, 59738, 19576, 48431, 24701, 37375, 38119, 10821, 42084, 28048 +, 21859, 16361, 29050, 54851, 27573, 1759, 3128, 25255, 1009, 49453, 20140, 59863, 20587, 8402, 25911 +, 14591, 55496, 8829, 24602, 36718, 41051, 53909, 36457, 36979, 18692, 37510, 50707, 33163, 24683, 9143 +, 1212, 22895, 25504, 30262, 17746, 53077, 8373, 57226, 54685, 45735, 23032, 14825, 45598, 43619, 59579 +, 47861, 34562, 31428, 56691, 59165, 8146, 14094, 53074, 20955, 27425, 48119, 34817, 18132, 21282, 35853 +, 27275, 22494, 58748, 52779, 29109, 52846, 22209, 13834, 50072, 53246, 59569, 13104, 8071, 21520, 33075 +, 7650, 9381, 7638, 15430, 42424, 43155, 59929, 32870, 12581, 57236, 296, 700, 32054, 18428, 21983 +, 44259, 22056, 20829, 43007, 51187, 49938, 12205, 49748, 40125, 38629, 42994, 39694, 28086, 51065, 1214 +, 1161, 35068, 46948, 45151, 26850, 29372, 28306, 26779, 38595, 40888, 24016, 38891, 17940, 32422, 33671 +, 39923, 16681, 55727, 37105, 36040, 23267, 3395, 48245, 13015, 43520, 26874, 56010, 23215, 54960, 23427 +, 781, 32474, 58495, 47729, 53977, 25346, 53454, 58636, 28477, 32049, 39524, 52493, 47292, 33816, 24915 +, 57315, 50092, 17948, 53043, 27197, 53988, 52662, 30592, 42233, 5677, 50465, 45460, 1687, 50032, 16772 +, 25115, 50813, 49246, 59962, 14895, 19576, 1660, 44701, 18212, 30138, 16750, 34088, 58983, 40394, 7904 +, 251, 37709, 57996, 18199, 7104, 1545, 48540, 59766, 32138, 7125, 5444, 58955, 52585, 43483, 48987 +, 45710, 44950, 39800, 34956, 21265, 54695, 30884, 22925, 39396, 49096, 29415, 32498, 23184, 4751, 49244 +, 31089, 5002, 26954, 5437, 59553, 10410, 6983, 48093, 10177, 15473, 31571, 51973, 14428, 24156, 35456 +, 3415, 9866, 56759, 19567, 21175, 18024, 14263, 52059, 17301, 30011, 17508, 23069, 38862, 40692, 27820 +, 4458, 11781, 9174, 31412, 53571, 45079, 41823, 554, 9525, 28352, 16027, 41096, 20325, 6807, 41604 +, 32133, 10222, 27823, 28892, 29789, 25350, 46916, 20404, 53761, 40570, 26768, 11269, 3639, 41982, 51962 +, 7811, 46440, 40095, 53337, 54205, 33666, 38416, 12380, 10572, 24293, 40732, 26599, 5389, 37409, 33406 +, 23346, 9542, 19980, 51169, 14787, 49770, 16519, 38055, 46526, 10280, 18625, 13294, 57902, 22264, 31628 +, 49864, 6427, 18069, 29959, 59764, 12274, 39978, 14533, 1006, 50550, 38826, 41738, 53502, 44216, 55499 +, 26908, 7562, 41393, 23241, 35083, 56180, 49363, 27954, 34236, 35889, 14586, 52861, 25536, 12488, 51478 +, 57164, 2352, 57905, 15233, 8664, 34022, 3859, 48642, 48555, 4865, 15544, 27381, 22955, 9046, 47949 +, 54806, 12307, 31863, 36200, 35548, 6946, 32380, 24911, 11252, 6616, 37152, 25839, 35830, 2688, 38327 +, 27308, 59853, 40680, 1565, 51438, 25696, 11939, 31650, 50690, 494, 12867, 6234, 4228, 35823, 51633 +, 52177, 30629, 3940, 393, 6829, 15840, 7339, 15562, 40751, 18592, 22178, 54255, 20783, 34360, 56944 +, 59110, 38020, 56797, 16142, 15938, 24587, 41838, 27877, 56237, 32528, 28372, 9105, 15115, 32600, 21280 +, 6748, 1129, 28261, 10688, 1522, 11443, 2880, 45214, 27005, 43631, 40158, 25535, 37886, 941, 36248 +, 11182, 51, 14268, 44331, 16194, 30206, 8919, 34384, 58084, 41508, 6913, 2808, 26965, 58380, 11760 +, 48245, 5128, 12889, 52859, 52168, 50764, 4302, 55048, 35978, 7659, 15031, 16136, 9546, 29269, 17077 +, 45794, 40452, 53480, 63, 1135, 46026, 6621, 10054, 20411, 4705, 27915, 3676, 43865, 54880, 2056 +, 55625, 19478, 43536, 8515, 48689, 35704, 35631, 52991, 7104, 11609, 37002, 22135, 4097, 46548, 27756 +, 57526, 32343, 44560, 51006, 8758, 45696, 37033, 15379, 32102, 33796, 56437, 17, 37472, 40302, 31250 +, 15880, 35928, 50728, 59416, 20795, 39417, 11472, 56426, 8760, 18576, 44387, 22114, 17063, 48484, 45014 +, 44819, 46010, 17357, 29380, 37016, 2467, 15076, 50401, 54199, 47178, 24197, 50636, 23548, 38021, 30938 +, 54798, 53901, 43218, 21878, 53317, 4013, 37647, 41141, 36791, 22759, 59717, 21178, 44873, 16780, 9662 +, 29887, 37952, 32024, 23597, 7332, 45393, 2416, 58760, 35794, 56615, 22290, 36344, 47251, 45838, 14365 +, 54542, 16988, 44619, 37760, 15218, 14288, 41774, 52865, 55430, 18565, 51976, 55147, 39744, 13201, 48280 +, 25758, 43089, 26232, 57783, 43038, 9916, 43176, 45454, 8676, 55322, 18422, 7318, 31666, 5673, 53157 +, 22384, 215, 46497, 7003, 37976, 1716, 21291, 56102, 30933, 16721, 51019, 59262, 48221, 7115, 12463 +, 12853, 32874, 31904, 39085, 7009, 14942, 25353, 50185, 36749, 10381, 21859, 55171, 17699, 53526, 844 +, 47208, 52262, 37412, 33706, 35617, 51740, 11774, 56908, 24194, 19059, 49982, 15213, 18321, 14555, 58681 +, 7137, 27408, 31555, 39041, 42845, 14916, 53984, 8198, 41453, 7085, 18579, 3312, 2256, 12630, 33190 +, 39452, 59839, 25452, 53216, 9897, 1069, 21308, 58023, 34330, 45502, 17082, 664, 37068, 11756, 15219 +, 35749, 18893, 18979, 7304, 57934, 1824, 58572, 28270, 46374, 40025, 11707, 41305, 43337, 50315, 53935 +, 16528, 29768, 53774, 18332, 59336, 40023, 19402, 20645, 38046, 30084, 6147, 55129, 30748, 43215, 43237 +, 45967, 18964, 38482, 4946, 2620, 12768, 43122, 37544, 17391, 5848, 17569, 29098, 47153, 37259, 19414 +, 41088, 53787, 25534, 11215, 48471, 24870, 27590, 44225, 45515, 5637, 14309, 28015, 37118, 45057, 47582 +, 20355, 7376, 42899, 58837, 12322, 21871, 11605, 31796, 59416, 28996, 37644, 16985, 34447, 24797, 30596 +, 53861, 42238, 735, 19395, 29805, 49207, 20617, 57395, 33432, 42485, 39384, 47742, 46852, 16502, 9151 +, 34434, 36857, 16528, 53685, 12046, 28850, 15557, 4, 36999, 51325, 5352, 14643, 44662, 39799, 15793 +, 15259, 33660, 34383, 15994, 29407, 40540, 5201, 50025, 14287, 14986, 32510, 53672, 2728, 55714, 10174 +, 11879, 30148, 23384, 28407, 186, 11782, 33610, 52095, 11786, 46961, 43420, 17139, 37956, 28082, 56938 +, 53749, 43341, 6951, 4484, 35688, 36358, 45024, 40889, 2735, 59312, 55875, 11597, 29336, 34955, 7311 +, 15862, 23187, 13812, 39246, 27946, 13998, 27381, 37908, 6093, 39167, 24869, 49513, 32658, 2826, 53947 +, 5949, 32927, 13641, 12900, 37412, 49329, 25610, 58788, 6570, 4698, 34452, 38798, 16295, 3788, 50105 +, 59959, 19651, 13292, 13771, 35249, 41239, 27769, 2630, 19147, 10214, 41798, 20369, 36079, 50808, 23195 +, 30026, 56757, 56122, 20019, 46009, 33534, 45700, 11620, 8675, 52271, 16318, 43127, 7421, 8965, 46916 +, 57526, 8924, 6567, 47171, 22695, 41816, 4762, 26816, 20799, 261, 13382, 2597, 20630, 49461, 29757 +, 20177, 55840, 26515, 16300, 52211, 48876, 26186, 37912, 496, 34861, 6535, 53166, 17989, 50308, 38484 +, 41257, 24186, 47408, 47824, 11357, 46456, 5992, 52471, 49624, 26791, 52733, 3007, 5740, 49715, 28820 +, 11850, 9893, 1012, 14717, 2545, 53224, 3593, 5083, 7488, 40442, 16297, 50375, 9960, 34286, 40683 +, 48444, 51895, 4869, 35853, 16071, 16227, 58661, 22063, 8698, 24637, 25207, 37783, 3996, 7299, 3851 +, 32817, 19149, 50096, 10181, 33866, 52641, 39757, 13812, 34076, 23597, 54254, 50373, 13972, 4214, 1011 +, 54655, 52659, 52906, 59525, 4864, 8977, 52104, 39877, 7393, 37154, 4514, 32600, 14938, 8511, 16251 +, 55141, 17680, 11753, 45237, 27861, 21971, 14230, 43971, 35783, 48306, 7568, 30037, 38680, 21541, 34252 +, 39691, 16196, 3263, 32598, 52073, 8127, 41575, 44177, 48004, 48968, 21332, 28870, 57920, 12622, 37381 +, 50524, 7763, 55061, 2277, 53000, 59275, 24248, 43582, 43246, 32, 31888, 27166, 30069, 10568, 48707 +, 40673, 26612, 41256, 20288, 59210, 33329, 28415, 17137, 17507, 52771, 42458, 15191, 21642, 16730, 27813 +, 35375, 7254, 35576, 6789, 9531, 4928, 6064, 10132, 48510, 25662, 10164, 56750, 52828, 16585, 7319 +, 17888, 33611, 33931, 35496, 53899, 9493, 8825, 58667, 26630, 2684, 27790, 9088, 17875, 25784, 2171 +, 22040, 1160, 9425, 33968, 7949, 55309, 38896, 14013, 5441, 3758, 16027, 15605, 509, 45207, 8542 +, 44180, 3095, 42153, 18111, 38591, 12405, 3956, 23769, 11072, 30586, 26453, 38862, 16027, 20681, 4647 +, 18198, 42721, 42159, 3975, 16690, 50108, 59284, 31938, 40473, 4725, 12049, 56500, 56682, 12558, 18059 +, 5225, 33090, 21155, 23730, 27553, 36098, 36135, 31509, 59867, 47207, 38447, 2673, 2422, 30826, 23354 +, 43421, 25376, 42427, 25580, 29352, 35469, 15688, 28636, 7408, 32513, 9714, 19457, 5365, 6396, 8367 +, 23424, 47973, 17809, 44579, 11704, 45362, 57030, 24191, 16871, 56897, 11399, 31670, 35922, 50173, 2497 +, 35628, 33594, 27873, 18056, 59174, 33577, 53525, 51214, 38566, 37285, 23727, 48280, 33094, 5444, 31028 +, 17813, 28868, 19002, 35622, 49800, 30706, 20984, 46830, 31249, 14207, 20079, 42648, 22230, 56002, 9173 +, 24727, 31630, 42767, 28952, 26038, 18293, 2530, 55916, 9507, 17448, 9553, 9586, 5728, 42648, 15030 +, 36756, 36813, 20251, 32110, 12436, 10051, 39168, 9772, 56881, 10418, 332, 16960, 53066, 22562, 49314 +, 38592, 23641, 57297, 57711, 28945, 59687, 16005, 7827, 55603, 1864, 25275, 5157, 47803, 31003, 24157 +, 39185, 44112, 970, 59436, 16222, 49758, 9487, 55391, 59531, 6368, 5809, 36215, 59681, 35227, 58777 +, 25347, 50171, 58770, 58996, 47883, 27715, 58684, 3888, 35543, 30639, 5752, 818, 12148, 29907, 8174 +, 36305, 9093, 28638, 13628, 8529, 21212, 3386, 18017, 16603, 39269, 737, 58764, 15484, 36770, 10344 +, 50613, 2118, 515, 25735, 1114, 48398, 53451, 36150, 52286, 5346, 6790, 34391, 42516, 18938, 4298 +, 27042, 31596, 49743, 55680, 45224, 58273, 16893, 24962, 16290, 9848, 40584, 53379, 8613, 32420, 30150 +, 55309, 59386, 8620, 55824, 25121, 9734, 44223, 54924, 22237, 12861, 36622, 29027, 23604, 19139, 24317 +, 27903, 22533, 55913, 17646, 18214, 17489, 52271, 11459, 18804, 8561, 57659, 59388, 38293, 42624, 8160 +, 8443, 37933, 7546, 17063, 33758, 9020, 3149, 54333, 3944, 25386, 7194, 16919, 30765, 30799, 12410 +, 55083, 35054, 34943, 50996, 29052, 29509, 44838, 21324, 40968, 3642, 6237, 38628, 39382, 44530, 21252 +, 47542, 29325, 35538, 55089, 46388, 9296, 4109, 25890, 3629, 44405, 27628, 47175, 1324, 58394, 17974 +, 13734, 53477, 29380, 25030, 20825, 58433, 54539, 5663, 19757, 11860, 45657, 2346, 26840, 25039, 46877 +, 48092, 12582, 16202, 23630, 7671, 38943, 9278, 48132, 4833, 49259, 8889, 32461, 36435, 10214, 7207 +, 30761, 300, 684, 142, 25330, 57862, 58575, 56222, 3525, 54684, 8082, 49183, 57030, 34922, 14222 +, 20259, 59366, 3156, 12814, 59349, 10827, 51757, 8627, 35311, 32942, 57887, 44201, 41755, 10674, 30767 +, 48963, 41435, 7419, 25999, 41577, 9102, 23861, 16504, 5324, 3739, 11188, 13406, 29274, 44571, 24680 +, 19848, 41182, 24046, 23005, 53996, 23395, 10184, 22105, 8375, 45496, 31399, 42614, 29697, 49507, 53288 +, 36816, 38470, 34723, 44235, 40821, 52653, 53337, 41035, 9157, 58661, 21126, 56698, 48419, 50400, 17621 +, 13099, 46600, 58803, 37146, 9605, 52800, 541, 56142, 51257, 45268, 41638, 59009, 27882, 47687, 48516 +, 21170, 24503, 3338, 32246, 8738, 44159, 24899, 2076, 1546, 10408, 37089, 22672, 7106, 25509, 49424 +, 24727, 38608, 36025, 59883, 52106, 21982, 29035, 52648, 18124, 20292, 14268, 59762, 19301, 42151, 23801 +, 7817, 3321, 48304, 11155, 11919, 57043, 31667, 36818, 35471, 33213, 23579, 12560, 32238, 7037, 38069 +, 21662, 31765, 53030, 57687, 8000, 45136, 56022, 37035, 14136, 14146, 57327, 28405, 50261, 52981, 10556 +, 14062, 37150, 50229, 2367, 24658, 2149, 59410, 32677, 15319, 11233, 42242, 15250, 23793, 14480, 22288 +, 38215, 12495, 30405, 31245, 10182, 38405, 52733, 42556, 15440, 6870, 56703, 49119, 11627, 46964, 42100 +, 22183, 1026, 55603, 48764, 3393, 20261, 27265, 39155, 52938, 18937, 50388, 35180, 34187, 50534, 26013 +, 56475, 5101, 38508, 26880, 36346, 25042, 41637, 5431, 7599, 57077, 12301, 4302, 46197, 23928, 27618 +, 4649, 22463, 28644, 252, 47580, 32038, 56865, 14845, 47545, 26155, 10134, 14286, 37688, 44322, 41172 +, 3701, 17149, 46273, 42209, 20382, 22619, 43603, 2019, 4402, 51202, 59097, 16704, 31856, 21646, 16984 +, 59474, 26295, 15800, 28119, 2900, 3380, 36509, 36117, 54577, 406, 2273, 4712, 51044, 39961, 49034 +, 32216, 20014, 42535, 18489, 38575, 2917, 17460, 22178, 4937, 21863, 49733, 40386, 38567, 21589, 2032 +, 31903, 57416, 4679, 47703, 1887, 43931, 27435, 14748, 20049, 22013, 15154, 58674, 26725, 6199, 38635 +, 52111, 38415, 58649, 34646, 56905, 37224, 13916, 50717, 35754, 55205, 12580, 25487, 35591, 51147, 23429 +, 13975, 59403, 57197, 55006, 23458, 59084, 38938, 50894, 13832, 35339, 12907, 5338, 34013, 15984, 47889 +, 49000, 44447, 2657, 24001, 55445, 35914, 37577, 9361, 26631, 13331, 4566, 39212, 15171, 16509, 6711 +, 38600, 30484, 6114, 12149, 1843, 29573, 11233, 40781, 56819, 1417, 52472, 9726, 6755, 26485, 2062 +, 30997, 15485, 46509, 33654, 39486, 41954, 45920, 17063, 27668, 12551, 6746, 8586, 51763, 21917, 25096 +, 34827, 36869, 31932, 17293, 49018, 33775, 46866, 36603, 14556, 43685, 38020, 43380, 29763, 21128, 9865 +, 8177, 52125, 1702, 54686, 2131, 17540, 12993, 48051, 10955, 40661, 602, 17702, 49247, 28718, 15971 +, 14343, 39897, 52841, 22628, 57190, 18211, 56403, 20409, 54815, 47312, 4094, 9187, 30692, 10210, 30315 +, 16910, 18387, 58792, 18612, 49426, 923, 36153, 2419, 25326, 47108, 43080, 25929, 41162, 8679, 30999 +, 57134, 59375, 10896, 26327, 22003, 44438, 20890, 54758, 4847, 52057, 42070, 45294, 1245, 49115, 55504 +, 31560, 6025, 50243, 30353, 24637, 39669, 7628, 37142, 18440, 32955, 603, 37872, 35236, 18117, 46552 +, 42587, 15251, 45927, 29835, 17930, 7930, 14273, 38821, 2688, 19121, 30878, 21111, 4415, 8475, 10226 +, 36271, 16388, 52603, 26514, 23093, 17240, 42536, 30721, 30735, 37328, 40028, 7690, 15201, 15264, 25807 +, 1753, 57851, 17411, 47680, 4038, 35341, 31962, 18312, 50514, 11002, 37433, 57745, 8465, 18200, 6220 +, 18691, 54471, 22608, 11294, 57337, 45701, 4887, 16225, 52775, 11974, 53554, 32803, 19664, 8755, 24420 +, 45471, 46860, 58623, 2882, 34540, 2662, 14576, 42854, 57326, 41442, 30208, 34759, 39187, 38674, 29311 +, 21760, 33717, 134, 20720, 21364, 33823, 42774, 26251, 50049, 35549, 14577, 19955, 44704, 34241, 5062 +, 9124, 56064, 51922, 7748, 35299, 2814, 46762, 49875, 22020, 44088, 31317, 52228, 55199, 46857, 30902 +, 24510, 8617, 4620, 24644, 29337, 2336, 58467, 12111, 28587, 24868, 24012, 19516, 21175, 8717, 53757 +, 26237, 54193, 26173, 18159, 1941, 1472, 57325, 25055, 27699, 19345, 9143, 35369, 11574, 4342, 22226 +, 18828, 5204, 7195, 59800, 6200, 12884, 2136, 41020, 1348, 7075, 5888, 25360, 26591, 27064, 34077 +, 56700, 29653, 28271, 22874, 47813, 6564, 698, 21490, 31620, 28398, 40836, 17115, 3767, 28762, 57810 +, 2345, 47590, 39366, 45892, 47391, 45567, 58776, 49527, 26587, 124, 32955, 8827, 25485, 59546, 12243 +, 35914, 32599, 41897, 40537, 55473, 6062, 23454, 56171, 27552, 31426, 921, 8388, 48541, 41040, 37150 +, 22703, 19737, 1093, 2070, 5629, 48484, 47637, 4406, 14363, 50576, 4530, 23670, 35755, 6367, 23217 +, 47999, 18634, 55816, 6248, 59171, 27641, 12310, 22625, 164, 16214, 54051, 37438, 955, 18945, 18478 +, 14457, 41648, 14568, 15550, 20070, 20197, 40386, 7707, 955, 31102, 34635, 5486, 54772, 10391, 48205 +, 54341, 58390, 6839, 50157, 40990, 6011, 54150, 53300, 4988, 54315, 9514, 35392, 31753, 10469, 54337 +, 26583, 24927, 12337, 41151, 16829, 32408, 37701, 57216, 16467, 38656, 28318, 51103, 20494, 59442, 37846 +, 8700, 53784, 12588, 15539, 43941, 53578, 57902, 14444, 46878, 39243, 8759, 32744, 14635, 16864, 19566 +, 45324, 19799, 20845, 57661, 37303, 37674, 6421, 15004, 34890, 22889, 53660, 39560, 50344, 50507, 39003 +, 28190, 59207, 32787, 40778, 51098, 53080, 10708, 25353, 7524, 57586, 4596, 52635, 6682, 19231, 45851 +, 26248, 4555, 42003, 47093, 38568, 19306, 24768, 44990, 34310, 36010, 44231, 4322, 51923, 34575, 54829 +, 7278, 39117, 30388, 16417, 56247, 21487, 45849, 6955, 46840, 53374, 40893, 27788, 22361, 47575, 47019 +, 44565, 13824, 27926, 26568, 37269, 6494, 22226, 38389, 27836, 32888, 50752, 12067, 37210, 42675, 22994 +, 8392, 26305, 38463, 15132, 42722, 34710, 36619, 28571, 41665, 59811, 58297, 58910, 3951, 57011, 46486 +, 50970, 41576, 36662, 55248, 44496, 13931, 38095, 6722, 28673, 5931, 39610, 19425, 54351, 53172, 38452 +, 17345, 37916, 4757, 55809, 53049, 47479, 6871, 6020, 52402, 24889, 42184, 50700, 23799, 46135, 47711 +, 46637, 13458, 5639, 23299, 8706, 26487, 13583, 46801, 33209, 42256, 52733, 49171, 38033, 47084, 42343 +, 16485, 40781, 20260, 21242, 12942, 13309, 45073, 19814, 19329, 37475, 44703, 1513, 4527, 44854, 24001 +, 28590, 31492, 37459, 34229, 54791, 46165, 716, 44726, 32967, 10277, 3334, 2052, 59448, 41367, 25488 +, 18144, 57852, 6269, 38404, 55446, 19212, 28065, 16871, 15378, 23746, 54347, 81, 1612, 35226, 21287 +, 25613, 3817, 52779, 3072, 14398, 47571, 49237, 51467, 8649, 58556, 1744, 11984, 608, 37545, 53351 +, 26096, 55689, 27556, 8718, 10445, 59354, 27930, 14862, 16226, 19660, 38608, 46925, 56093, 40220, 22151 +, 17380, 42185, 2320, 10160, 45257, 16719, 34083, 10847, 8186, 42732, 9403, 46282, 54716, 46364, 179 +, 24420, 48812, 55868, 28328, 57530, 6313, 27682, 1812, 21175, 20260, 21472, 36136, 43537, 17565, 52708 +, 5689, 34946, 34894, 44361, 45106, 56503, 37432, 55541, 43702, 45618, 38273, 29458, 8253, 9342, 15822 +, 8432, 10114, 4634, 40653, 38442, 38517, 23318, 42476, 40329, 20846, 39089, 1802, 56982, 22626, 55719 +, 26042, 4667, 30665, 37288, 49029, 52123, 33792, 26461, 47664, 17494, 48432, 2290, 46952, 33037, 11632 +, 39126, 41469, 58098, 20113, 58474, 12892, 58630, 21793, 31720, 38959, 42639, 10809, 17113, 15973, 9788 +, 12833, 42015, 14455, 19850, 19304, 39836, 48326, 29448, 6298, 12342, 46942, 31082, 14632, 10247, 4119 +, 2616, 25725, 21940, 714, 45838, 20415, 49958, 44468, 18560, 21679, 59780, 1199, 8840, 16893, 53524 +, 18628, 6078, 35539, 33084, 2281, 31195, 12920, 26959, 643, 55570, 39301, 23938, 26652, 30286, 10537 +, 7123, 32902, 36262, 5416, 9969, 22101, 2183, 59927, 42921, 20743, 57958, 42701, 58294, 6799, 35947 +, 51818, 25427, 18377, 3709, 34863, 20658, 11257, 47784, 23969, 11900, 19706, 3271, 12190, 22711, 33557 +, 22727, 29834, 42811, 35342, 11602, 52780, 57443, 13785, 29060, 16716, 34528, 27018, 59418, 32822, 33817 +, 11717, 992, 35597, 30094, 41054, 10460, 27105, 52311, 34596, 51074, 4211, 54303, 54345, 52754, 53366 +, 4254, 51833, 59552, 47066, 27175, 11155, 39846, 970, 24940, 45258, 17687, 35821, 12277, 53457, 8643 +, 22446, 5174, 45988, 58043, 35268, 27042, 44856, 2373, 19353, 19452, 29800, 59916, 50107, 24145, 52670 +, 43473, 4752, 20856, 19378, 51818, 48031, 30533, 8016, 49002, 55473, 53275, 43041, 31294, 41904, 36498 +, 16290, 4350, 18024, 38630, 38746, 53292, 5672, 23602, 32018, 1377, 19406, 1818, 1293, 45866, 2315 +, 30316, 5691, 43419, 51172, 25069, 35237, 15555, 55602, 19606, 40909, 27428, 12881, 23950, 35074, 54785 +, 36800, 27716, 35487, 54824, 6346, 50585, 24469, 48370, 14187, 56487, 49747, 9946, 34657, 27393, 55812 +, 13324, 34061, 1503, 56744, 25233, 26573, 8333, 40788, 58527, 27939, 21698, 25955, 17172, 22000, 1030 +, 48309, 58801, 5098, 23797, 29977, 11445, 50734, 54446, 36167, 4922, 27285, 25915, 51220, 38294, 29660 +, 47032, 27971, 3721, 24887, 1067, 28954, 51460, 9400, 46094, 26340, 37340, 44144, 52295, 30864, 42497 +, 29677, 19174, 17650, 34776, 19323, 47627, 22573, 10057, 18426, 58740, 51331, 22063, 1007, 42551, 36710 +, 30667, 5935, 4681, 34388, 30823, 5748, 39694, 58635, 15148, 2141, 24975, 28840, 22637, 53623, 59705 +, 41486, 23300, 55231, 59136, 34428, 14554, 23116, 33353, 24611, 17894, 8446, 15943, 39957, 9453, 58494 +, 16667, 16473, 4430, 57700, 27213, 11605, 3448, 43260, 10240, 54949, 45401, 11568, 141, 44390, 5191 +, 36198, 25877, 4843, 31429, 25013, 39272, 22335, 24481, 48977, 46947, 42375, 57423, 39242, 22333, 6877 +, 14088, 15352, 59702, 54870, 49405, 26915, 6475, 52853, 10175, 53068, 24154, 31928, 4636, 648, 16319 +, 46179, 13198, 18548, 51022, 20980, 19913, 6646, 43315, 44395, 55624, 30262, 26770, 53047, 45856, 25455 +, 36276, 59945, 17160, 35978, 54815, 6565, 2894, 1291, 35770, 13069, 30711, 36277, 21350, 35347, 13277 +, 37669, 21526, 26475, 32569, 48900, 47455, 52482, 55547, 30771, 36877, 51171, 37385, 40000, 20570, 23242 +, 41807, 56847, 23187, 58967, 9177, 54354, 41884, 12071, 31997, 17655, 1493, 2708, 30284, 22843, 14407 +, 43561, 36864, 12285, 10036, 9433, 1186, 57492, 38267, 56733, 4615, 51497, 24256, 42000, 31497, 44826 +, 41594, 13304, 18025, 41133, 48624, 27203, 35488, 6860, 15626, 7485, 867, 53471, 46546, 31151, 52666 +, 953, 14712, 29530, 13239, 1101, 15315, 50777, 34945, 29935, 23862, 15912, 21432, 48118, 34264, 52929 +, 9296, 15859, 42585, 3674, 33344, 7561, 7229, 8832, 14422, 22855, 52670, 15289, 16327, 15568, 46441 +, 8993, 52873, 37505, 14876, 6112, 14958, 6543, 33241, 26255, 36478, 57103, 42167, 57910, 21573, 16432 +, 27191, 30870, 32291, 46129, 10896, 41987, 53690, 18125, 27172, 8112, 40980, 19842, 59754, 33659, 11762 +, 22547, 19005, 4635, 52, 10233, 47100, 51363, 16776, 20341, 17618, 29607, 53797, 59786, 3869, 15370 +, 16218, 7413, 46240, 24861, 53542, 57136, 6848, 23584, 51613, 34020, 31697, 8946, 30214, 7803, 42605 +, 18328, 30350, 37962, 22964, 6754, 48195, 10064, 58117, 41324, 6757, 52088, 47283, 554, 28226, 51152 +, 15925, 20796, 58565, 38517, 45657, 28459, 12006, 28857, 52044, 3619, 39230, 93, 12565, 45796, 7896 +, 31523, 4125, 14598, 9485, 3441, 21352, 34033, 49857, 55822, 51709, 56614, 47910, 38992, 33521, 52488 +, 6496, 25798, 13284, 41414, 4315, 35293, 9873, 52673, 4150, 1917, 56293, 19732, 2010, 45210, 41881 +, 46258, 53085, 46006, 856, 2571, 25799, 58561, 12956, 15656, 54383, 4665, 48622, 18645, 20009, 22143 +, 11133, 26505, 47941, 24417, 44271, 28609, 36062, 54145, 21282, 40212, 32414, 53927, 36297, 10777, 39138 +, 18178, 57035, 32223, 40536, 34244, 11146, 6335, 32805, 454, 58343, 3540, 5119, 46965, 58537, 1480 +, 9109, 9670, 4338, 33402, 10439, 48609, 2011, 46501, 42754, 23294, 3065, 51521, 17221, 15714, 2298 +, 32711, 10244, 35685, 41287, 50780, 46281, 52433, 33467, 19086, 29240, 8162, 58978, 34359, 55128, 57515 +, 12192, 40589, 43537, 16530, 13991, 53976, 5139, 52355, 16829, 24246, 15649, 56247, 15767, 9222, 11961 +, 54417, 18286, 22206, 6454, 59573, 49338, 52736, 28358, 59158, 11822, 57598, 7320, 47153, 8310, 2448 +, 44668, 20502, 19389, 28206, 13384, 33381, 58534, 18523, 2088, 51716, 19121, 54089, 47963, 11240, 39663 +, 36276, 5657, 57949, 34834, 12112, 57522, 24173, 4848, 2233, 23331, 53022, 59831, 7003, 40175, 44493 +, 9452, 1196, 41347, 28841, 29402, 54731, 38574, 4288, 13255, 17014, 56004, 8728, 11103, 20319, 19969 +, 50767, 56596, 25626, 25068, 31430, 14090, 22591, 31955, 55290, 1176, 31638, 48313, 37359, 38642, 4840 +, 21853, 24446, 6036, 3200, 29639, 11790, 57932, 44566, 16079, 47539, 37932, 48435, 32619, 49036, 8755 +, 52588, 16155, 41703, 54567, 41223, 49485, 8657, 40166, 21441, 3948, 41342, 29431, 28613, 18702, 44425 +, 9805, 16907, 45223, 52194, 56459, 51215, 3984, 30743, 35781, 56415, 54634, 13713, 44851, 27254, 39101 +, 29958, 19842, 55256, 11661, 14409, 36480, 1146, 59419, 52998, 58939, 39719, 34341, 4723, 8332, 29395 +, 49148, 54489, 22654, 10724, 46683, 19113, 1939, 27020, 49857, 14072, 23435, 20843, 4137, 44638, 48097 +, 43239, 14596, 7940, 14847, 2609, 58701, 27679, 3756, 34472, 20678, 39047, 14191, 31371, 43770, 58875 +, 766, 9271, 53365, 23420, 19995, 40048, 18885, 21934, 43420, 45094, 36006, 6856, 5938, 16495, 27846 +, 30387, 59734, 18795, 14679, 50934, 21404, 13381, 18613, 1512, 47853, 15643, 40560, 38397, 47014, 24330 +, 37272, 24132, 33601, 30637, 23904, 29948, 47038, 42790, 51882, 30458, 4236, 4240, 13666, 10174, 20736 +, 41513, 40562, 56822, 308, 31593, 24108, 58064, 44974, 42722, 59577, 9180, 58365, 16489, 47577, 21732 +, 17171, 24849, 45864, 50773, 31839, 9769, 57073, 18877, 52559, 25308, 49335, 56795, 29548, 3002, 43322 +, 26636, 20867, 236, 59811, 57527, 31829, 23919, 55591, 53156, 42993, 31520, 38688, 17711, 48009, 2617 +, 39443, 5181, 27466, 1659, 32306, 35657, 11428, 29379, 54534, 40339, 54687, 20222, 13487, 588, 23224 +, 33161, 3576, 20443, 33397, 39739, 17970, 41578, 40011, 13561, 11086, 59356, 21434, 49774, 17067, 9443 +, 52391, 32862, 50976, 56210, 34522, 59634, 31867, 22302, 5366, 2754, 2642, 36405, 22976, 52481, 36993 +, 22552, 25642, 16922, 42995, 35391, 33013, 965, 16969, 13024, 50878, 4408, 12381, 12312, 54182, 5800 +, 58108, 22926, 38663, 25436, 55488, 49537, 25071, 3707, 48191, 30437, 6461, 50833, 6842, 5789, 19666 +, 20188, 28341, 45308, 13462, 47688, 57051, 46475, 25005, 50373, 59500, 15884, 54781, 48233, 4548, 25315 +, 54033, 39008, 48241, 9048, 4445, 43729, 34937, 29516, 47437, 23129, 36305, 30250, 50314, 43147, 36040 +, 9981, 39687, 40733, 31641, 53149, 28422, 28693, 15977, 53427, 55418, 15477, 45663, 50199, 40062, 50212 +, 15514, 10447, 5572, 40108, 19496, 10017, 23837, 54433, 15885, 47626, 53914, 52190, 17877, 44229, 11690 +, 53917, 54210, 27729, 34650, 2203, 20879, 39424, 7248, 36856, 32852, 2666, 28685, 54867, 52865, 45099 +, 21431, 44732, 55546, 27004, 24840, 15042, 37021, 25029, 45828, 29259, 12656, 39742, 21449, 6885, 323 +, 9491, 802, 54533, 37221, 11804, 33089, 34452, 51229, 40337, 11308, 433, 19356, 16345, 31652, 12221 +, 1444, 53084, 33305, 33342, 20088, 34497, 48385, 33461, 59527, 10565, 2720, 48535, 26659, 522, 55420 +, 26983, 10013, 32574, 57868, 23586, 20730, 30957, 58038, 48311, 47647, 45698, 48744, 7003, 2043, 20397 +, 55576, 39839, 49833, 28882, 13182, 9921, 39731, 37919, 19734, 15610, 24836, 58807, 4145, 51495, 59329 +, 35917, 18478, 45694, 44843, 16347, 9281, 5574, 23656, 7319, 53885, 11303, 53018, 18982, 18306, 55061 +, 39379, 13883, 11253, 29212, 19117, 787, 15485, 58848, 38706, 35219, 14459, 3542, 34026, 54956, 31389 +, 9707, 7226, 49868, 55402, 52069, 42567, 4683, 57643, 42575, 12002, 51529, 53879, 41372, 10511, 48537 +, 12786, 26242, 38772, 24039, 31806, 57889, 24826, 47291, 33090, 39884, 58862, 23901, 19778, 9241, 55209 +, 51167, 18948, 2435, 17387, 50702, 54505, 36306, 55385, 28500, 18882, 43740, 56381, 49113, 25112, 43244 +, 37650, 37898, 9486, 16423, 38289, 17644, 50664, 39467, 41287, 23754, 55703, 16502, 24007, 15481, 25743 +, 19217, 43001, 21043, 58004, 36740, 48098, 52509, 49399, 19835, 57362, 8281, 3575, 53743, 57394, 5040 +, 36988, 35044, 19290, 22826, 27819, 57580, 40471, 18484, 13399, 21758, 42238, 9103, 38260, 42598, 24584 +, 40355, 1815, 43937, 1399, 59819, 57030, 25849, 28681, 46429, 45684, 26043, 54710, 25612, 19786, 28456 +, 30652, 33126, 3500, 26294, 55953, 7672, 226, 36424, 26156, 13626, 34534, 8394, 22729, 49147, 50992 +, 23665, 29502, 29159, 43955, 7253, 5331, 40985, 33102, 34012, 27414, 18787, 36407, 58476, 44399, 56193 +, 26932, 51403, 5672, 6784, 17697, 1625, 14456, 17924, 14401, 40612, 31550, 25287, 25359, 30631, 14434 +, 52703, 54296, 43937, 21863, 38251, 51190, 27194, 19236, 645, 37558, 23002, 19432, 13965, 21478, 40183 +, 46510, 48410, 31586, 52182, 55195, 25635, 30159, 46003, 43559, 20912, 26616, 51461, 46200, 28327, 22092 +, 634, 21030, 16389, 20923, 19245, 30992, 48466, 22791, 26581, 49111, 349, 49583, 44895, 50666, 47414 +, 25078, 37177, 12176, 33016, 5711, 43723, 58651, 12223, 29727, 18563, 33135, 56343, 10024, 55687, 1022 +, 8469, 56322, 22052, 24858, 53597, 41298, 32202, 42063, 4089, 35135, 7526, 40791, 1071, 52421, 31457 +, 48485, 53851, 44986, 661, 3219, 50698, 44385, 38223, 2921, 14112, 56786, 12408, 46807, 43162, 8096 +, 47829, 51631, 40770, 46233, 52841, 34367, 27531, 1396, 52783, 7973, 36531, 309, 48764, 37602, 29083 +, 56573, 26087, 22934, 41560, 3101, 26154, 8610, 47486, 40729, 47883, 37950, 37515, 291, 1109, 57029 +, 44739, 25290, 48661, 25509, 11523, 17854, 36229, 39055, 19250, 5364, 23380, 55782, 5673, 48496, 9736 +, 34756, 45069, 12176, 34043, 26629, 15277, 36549, 11591, 39115, 17278, 59474, 17065, 54793, 59766, 18174 +, 28174, 44505, 43464, 16835, 46367, 31339, 11042, 58948, 10394, 30292, 4312, 10126, 2426, 46337, 58622 +, 12163, 57446, 20044, 24339, 31489, 23025, 15968, 44390, 34617, 55083, 1668, 34091, 12148, 32813, 33857 +, 6674, 987, 54715, 26490, 54175, 17434, 57829, 5217, 52734, 44576, 11861, 33398, 54702, 50640, 19735 +, 29677, 2803, 53533, 49721, 3494, 1374, 12746, 19462, 45764, 47363, 14545, 47432, 21455, 3045, 20245 +, 31664, 46071, 21233, 2731, 12561, 51760, 56517, 46742, 33329, 49251, 7670, 45190, 22649, 2373, 35830 +, 18737, 8402, 14985, 12270, 58123, 18479, 13645, 47221, 14293, 59409, 10937, 5190, 46842, 8744, 8235 +, 43439, 40408, 30658, 41024, 19492, 19571, 32784, 16009, 6314, 6113, 5261, 13984, 27656, 4262, 52709 +, 3486, 22999, 1111, 18472, 35270, 35586, 13303, 25267, 59160, 3949, 24676, 10097, 9139, 47870, 18841 +, 53727, 31310, 35601, 24385, 48686, 31445, 43957, 21471, 23807, 26623, 3936, 5420, 40607, 31592, 9682 +, 9669, 11431, 32682, 47132, 6255, 44304, 59071, 55910, 9571, 58231, 59859, 10599, 44680, 8999, 58470 +, 39873, 2726, 6132, 51826, 3463, 54818, 23272, 47420, 52641, 47079, 50395, 32930, 52499, 31003, 40874 +, 38533, 40672, 28657, 47567, 4156, 34912, 31871, 3227, 7175, 17794, 1458, 7034, 28394, 22490, 52385 +, 3216, 2363, 31463, 9348, 54190, 34927, 40518, 53814, 58699, 9512, 40893, 49095, 18794, 9744, 56450 +, 59668, 48277, 13474, 4678, 12197, 17630, 15942, 44068, 20858, 23117, 38215, 58668, 30152, 6609, 21159 +, 22537, 46177, 23522, 30353, 31877, 54064, 5280, 48747, 47878, 40331, 58259, 5123, 29426, 53405, 51219 +, 25876, 29426, 15849, 39350, 34104, 28046, 33333, 50046, 48466, 54191, 13164, 26681, 29211, 19668, 9642 +, 50370, 18557, 55819, 50245, 48910, 27696, 20661, 30542, 16444, 44892, 10874, 51055, 50015, 40300, 44461 +, 17587, 42529, 13887, 33436, 58231, 47991, 1482, 31564, 14389, 26300, 2107, 27553, 52982, 7671, 23573 +, 2624, 34393, 42131, 34796, 24638, 31041, 2492, 21652, 37936, 55288, 6544, 48810, 46344, 32911, 5462 +, 7157, 50498, 47991, 21044, 23934, 22575, 45387, 1768, 30491, 59776, 28069, 8951, 3682, 57403, 16622 +, 3607, 27, 51015, 45738, 34823, 52006, 53132, 13668, 13658, 31068, 8956, 56554, 19878, 31652, 29465 +, 25340, 38809, 56316, 49684, 36205, 20250, 12259, 57944, 58371, 19102, 34073, 2792, 28053, 14107, 195 +, 44675, 17714, 222, 12043, 3453, 11398, 4049, 32937, 1418, 54059, 4005, 46726, 50613, 235, 18379 +, 56430, 1927, 33540, 52746, 51611, 46098, 49349, 40222, 44042, 24072, 35677, 18115, 26864, 3730, 32222 +, 27059, 24758, 49937, 3633, 13153, 29742, 15031, 17202, 2679, 52801, 47613, 43036, 39528, 14578, 19623 +, 34259, 11008, 21550, 7799, 40107, 49514, 30249, 29456, 6088, 14292, 53528, 41765, 8759, 56744, 21848 +, 40982, 23803, 22958, 7271, 27436, 36111, 37013, 18820, 53313, 16044, 11621, 17278, 59080, 27501, 31856 +, 18703, 1760, 42864, 16605, 45912, 59323, 6119, 16161, 28779, 48560, 6805, 58659, 30325, 15565, 55403 +, 28525, 56547, 55558, 51483, 40170, 22995, 27594, 17183, 18167, 57259, 9579, 6140, 14537, 45011, 33642 +, 22745, 3714, 35402, 41962, 56671, 57666, 41285, 39143, 13828, 10065, 27703, 20633, 45076, 34380, 12550 +, 16832, 2906, 9097, 12390, 54389, 49267, 11737, 58336, 42802, 6256, 31947, 52381, 12397, 22837, 37392 +, 46039, 45582, 17458, 57793, 27544, 50482, 55460, 8830, 29625, 45640, 55247, 57328, 42625, 40323, 31708 +, 55176, 33507, 10966, 40625, 22250, 41708, 29893, 33987, 40044, 49047, 40244, 48343, 17781, 28993, 11180 +, 55173, 15032, 56763, 48984, 12825, 659, 39466, 44637, 9489, 9091, 30277, 41088, 42771, 12903, 57764 +, 50831, 8079, 31271, 1798, 48704, 53521, 43506, 54949, 3861, 59902, 43997, 20457, 48245, 38130, 49450 +, 59426, 9655, 40834, 32541, 58639, 30011, 33200, 14457, 14649, 19042, 59900, 44926, 130, 42671, 57829 +, 57894, 33503, 42260, 5518, 11653, 7317, 35391, 55159, 2266, 39252, 55061, 22615, 36061, 19658, 745 +, 1863, 19084, 10401, 42697, 27977, 45392, 12709, 37530, 59850, 27358, 32924, 36102, 12284, 33054, 18774 +, 46466, 7301, 28629, 5078, 49171, 40282, 12395, 24562, 11793, 51014, 40167, 6854, 49981, 16228, 26512 +, 27079, 18092, 21949, 13832, 37141, 26278, 59224, 49850, 3808, 35426, 17208, 36732, 11529, 5845, 46139 +, 6655, 28663, 29792, 35284, 10093, 18963, 51918, 58841, 19877, 3711, 49855, 36396, 46917, 16188, 28977 +, 49781, 43267, 23421, 48082, 57099, 562, 14361, 32676, 50413, 54521, 44454, 43973, 7606, 32335, 26170 +, 53745, 15342, 31185, 59889, 50626, 17631, 55204, 18896, 16472, 15081, 22607, 42679, 51478, 45876, 58867 +, 20455, 35658, 42135, 43876, 23740, 15586, 20790, 14453, 24614, 47555, 8975, 45421, 31529, 16581, 17756 +, 34051, 46678, 33099, 41589, 46567, 77, 59220, 41771, 18974, 15692, 33204, 17933, 34723, 1034, 3810 +, 33590, 57841, 15820, 52077, 41717, 39560, 7664, 38860, 30366, 8630, 26415, 39341, 54051, 34296, 32274 +, 11808, 44700, 18952, 21259, 26289, 41871, 57688, 1861, 23642, 16662, 53905, 33198, 10948, 28628, 34233 +, 51110, 2218, 32074, 43282, 54296, 50144, 59194, 38312, 29004, 29560, 23294, 55419, 8901, 17346, 6068 +, 41175, 5506, 50768, 36479, 3117, 17057, 18350, 805, 18918, 18344, 53820, 49175, 51543, 41120, 17803 +, 25776, 32230, 20021, 34202, 51864, 50669, 24346, 51058, 5333, 29702, 20619, 4980, 1474, 5872, 22326 +, 7542, 23400, 4184, 58310, 59879, 7301, 51719, 54582, 44458, 46989, 12926, 38278, 36164, 4469, 19398 +, 30319, 6597, 27980, 26692, 40800, 19844, 53714, 41498, 10903, 59047, 11201, 7874, 4027, 49027, 13746 +, 2705, 56569, 37146, 43241, 31231, 13378, 26894, 59302, 7960, 11353, 22643, 57238, 25983, 35159, 38060 +, 45382, 5478, 44657, 49714, 32170, 1809, 9559, 25884, 19660, 56814, 1284, 7213, 41040, 41663, 56240 +, 54786, 20721, 29161, 8285, 3962, 36744, 58015, 30857, 36046, 5975, 18562, 35041, 3213, 44545, 10200 +, 41273, 6279, 15678, 2283, 55994, 24200, 40444, 41905, 50085, 104, 15071, 51369, 43669, 56111, 9384 +, 16261, 27249, 30105, 45422, 35534, 34068, 58518, 33549, 41277, 10916, 15876, 59839, 45957, 55442, 44384 +, 56157, 13067, 27016, 48187, 15350, 23010, 12388, 32147, 41267, 2473, 8603, 56338, 30194, 52273, 28801 +, 39578, 8534, 56050, 46036, 30309, 31585, 20104, 28827, 41486, 1381, 39744, 57363, 37572, 25701, 52805 +, 58308, 58211, 5872, 25324, 22750, 57575, 24686, 35138, 29722, 5953, 13963, 14677, 38643, 20509, 6950 +, 7444, 36440, 51837, 3495, 22476, 22146, 11432, 42580, 27325, 52918, 20313, 7069, 50281, 57885, 9123 +, 19438, 32545, 43686, 1663, 57870, 6436, 35590, 22556, 41575, 5312, 4862, 31890, 19989, 43505, 52400 +, 3292, 27302, 28840, 55129, 30797, 51316, 53627, 42229, 10248, 20952, 35147, 30561, 28022, 1781, 4798 +, 13497, 57571, 13695, 57183, 35586, 11565, 3619, 11176, 10474, 21546, 52840, 51688, 53437, 12830, 11545 +, 45837, 52474, 38847, 51029, 23955, 9644, 42345, 17582, 28225, 28945, 38534, 3373, 35858, 42908, 41506 +, 17008, 56405, 15429, 30703, 29940, 51016, 18621, 9912, 2192, 29095, 7810, 55033, 57135, 1247, 44215 +, 8680, 23436, 36689, 47528, 14465, 36996, 57172, 33162, 54578, 25398, 2107, 9464, 5123, 14317, 52373 +, 22981, 31325, 25130, 14762, 2029, 31423, 5778, 20650, 41335, 7971, 26097, 49145, 39356, 23232, 26745 +, 23571, 8264, 26533, 36612, 55792, 17351, 13608, 29317, 50513, 44538, 31067, 28973, 54002, 12542, 19642 +, 22727, 11875, 50968, 24210, 26637, 29349, 55633, 32416, 49999, 13320, 16739, 52448, 38817, 56095, 52032 +, 5562, 56018, 296, 8448, 8982, 32441, 25799, 58942, 38110, 52664, 43480, 9177, 57989, 13834, 58071 +, 17632, 36562, 9946, 8600, 37124, 36583, 37949, 32757, 45351, 4300, 46077, 38442, 33100, 1246, 10889 +, 25132, 43161, 6907, 1780, 51609, 52241, 34221, 17408, 51183, 12331, 10072, 11015, 57860, 8062, 24850 +, 55931, 2046, 37764, 42229, 10646, 14888, 55165, 24947, 23997, 16868, 29247, 46426, 55311, 2347, 47672 +, 6200, 3831, 30833, 49460, 5611, 22442, 41701, 16185, 16202, 9237, 4868, 2627, 56604, 39081, 47041 +, 57806, 35012, 49087, 11922, 53594, 36085, 3162, 48759, 1032, 27159, 5627, 6631, 13585, 938, 45330 +, 37610, 43491, 25513, 44795, 32951, 31124, 43590, 51004, 23661, 59792, 36593, 4882, 38771, 33198, 43963 +, 25812, 7356, 18975, 51251, 19279, 48921, 27336, 22441, 37680, 4720, 49601, 19660, 11351, 39538, 56950 +, 33033, 53500, 40441, 58546, 38296, 49744, 6023, 21886, 17101, 6036, 21678, 53694, 10918, 36802, 3244 +, 54881, 2614, 46953, 13857, 53866, 6232, 39130, 21202, 28673, 16811, 25923, 54626, 12823, 13626, 10517 +, 9773, 23012, 4017, 26567, 21558, 42313, 16311, 3933, 4199, 9764, 9970, 2230, 3459, 20888, 39032 +, 43055, 15770, 17998, 30008, 5979, 11864, 12592, 45109, 9419, 17618, 38272, 11694, 12244, 51095, 1672 +, 59113, 37221, 24684, 3131, 3788, 22595, 21796, 56451, 26528, 2348, 6216, 36498, 40930, 46027, 33739 +, 56314, 29082, 49509, 14312, 35443, 55488, 2529, 24387, 16949, 11948, 42005, 55222, 59994, 30602, 22669 +, 38018, 29715, 59890, 2703, 9198, 40030, 1650, 7347, 36482, 28178, 9695, 42698, 41029, 50625, 28725 +, 14768, 46939, 34159, 4277, 37603, 45954, 36117, 40132, 10342, 29418, 28432, 28699, 992, 4778, 59301 +, 23662, 42797, 5369, 59904, 21852, 50919, 39935, 23502, 58266, 52769, 28032, 44313, 35467, 9061, 34938 +, 40544, 181, 58229, 14703, 40810, 35833, 37010, 53279, 52317, 47352, 22698, 20750, 52403, 23690, 25528 +, 51705, 23704, 8325, 33426, 59961, 6529, 697, 16248, 30031, 58964, 9017, 58064, 43277, 44484, 43477 +, 54568, 25028, 43659, 29149, 16083, 821, 4982, 53093, 54101, 57300, 16797, 16799, 54402, 9201, 16841 +, 19930, 37258, 16898, 4608, 47036, 16859, 11137, 47733, 33107, 17521, 23049, 42124, 51937, 6327, 2960 +, 35414, 37247, 4340, 55425, 6396, 56775, 56247, 47731, 26221, 50348, 21383, 43018, 43499, 15785, 28571 +, 340, 12067, 42181, 53590, 53027, 5569, 10449, 4165, 53303, 43556, 21686, 52704, 2032, 49975, 35383 +, 4992, 25389, 12630, 45684, 57167, 55379, 42460, 29766, 19462, 8681, 56466, 40845, 28051, 39965, 32982 +, 32975, 16657, 21401, 15156, 10248, 14429, 57078, 20697, 54946, 50381, 40606, 16632, 19437, 18990, 6607 +, 54821, 335, 8348, 7451, 46019, 41867, 39182, 28479, 11633, 58644, 13512, 8099, 15841, 41564, 24416 +, 48823, 50891, 41074, 46577, 42399, 27674, 1006, 39477, 24723, 55952, 6210, 5329, 48936, 25648, 672 +, 31895, 20469, 1007, 16595, 4272, 47026, 58463, 43455, 51858, 46448, 42099, 5370, 54548, 57941, 23286 +, 55316, 23116, 50529, 12742, 9693, 32929, 40416, 47051, 12406, 5140, 19355, 18617, 46821, 8291, 44265 +, 47493, 16538, 41086, 48500, 33134, 45358, 11879, 7949, 28813, 3737, 54397, 10913, 45459, 25297, 45206 +, 45098, 56966, 8322, 35627, 9708, 54368, 8556, 50125, 41419, 57315, 31617, 775, 15932, 18438, 45418 +, 36549, 42284, 1957, 17635, 7136, 11443, 2993, 19015, 55744, 31807, 59104, 26493, 19072, 44564, 51791 +, 4278, 6014, 48757, 48952, 41641, 58465, 43320, 26550, 24942, 24740, 23865, 56559, 1867, 16149, 51350 +, 47285, 52698, 9986, 25594, 46685, 17122, 13389, 49678, 12490, 9133, 57837, 11594, 35627, 53261, 32510 +, 3770, 57539, 14876, 28879, 22844, 32870, 27344, 6164, 59420, 28639, 30904, 59637, 1550, 32771, 52138 +, 52900, 56409, 44836, 39238, 22003, 7873, 32713, 11745, 33903, 45203, 20878, 31741, 33149, 56505, 1354 +, 5660, 275, 35246, 20536, 5506, 58090, 53406, 32851, 4254, 29178, 37842, 11511, 5167, 39392, 20634 +, 57305, 8645, 17043, 18493, 24235, 15399, 26366, 56948, 27144, 270, 42151, 48022, 8363, 15301, 20880 +, 9717, 57313, 57507, 44963, 54201, 3014, 43053, 47608, 12217, 23660, 53138, 26411, 35171, 58306, 5803 +, 55805, 31963, 50800, 49201, 50457, 15036, 4600, 16823, 11984, 8096, 53445, 30488, 32470, 38160, 45789 +, 53350, 47878, 19454, 27210, 9193, 13655, 6576, 28599, 37615, 55145, 52259, 30754, 21556, 27430, 5412 +, 3711, 59587, 37375, 54512, 48788, 27832, 45900, 29740, 21008, 34236, 37836, 50805, 4724, 10307, 28966 +, 26865, 40009, 53196, 46319, 43571, 2389, 59975, 50147, 30988, 37590, 45292, 23247, 44696, 6848, 27029 +, 50108, 46912, 26617, 3836, 41424, 51757, 8020, 3676, 21498, 5380, 37912, 59334, 56186, 18989, 9641 +, 25152, 45854, 26003, 18348, 32174, 9574, 57089, 8501, 59722, 28078, 22443, 21366, 27677, 7140, 4567 +, 31059, 33600, 51479, 57676, 13788, 9255, 49433, 21809, 12931, 47283, 27189, 27195, 46618, 59727, 46184 +, 32611, 1231, 32039, 58614, 55931, 40565, 8189, 53021, 25418, 44263, 57451, 47861, 5629, 1480, 55001 +, 46548, 32539, 4954, 38027, 6567, 18742, 47282, 32353, 40551, 213, 19636, 44093, 27409, 42606, 20172 +, 49945, 15218, 21404, 58336, 13832, 53687, 38901, 58373, 46708, 4319, 42636, 20511, 28533, 24618, 21992 +, 59886, 11166, 30883, 4840, 25546, 13803, 23583, 12828, 22508, 40486, 49394, 42144, 931, 53155, 1103 +, 21104, 43100, 16321, 18860, 41437, 30153, 12547, 56690, 4879, 35608, 37362, 47515, 56119, 5895, 48485 +, 54463, 5781, 36004, 1699, 10622, 1550, 51854, 10557, 14378, 14362, 27395, 3772, 32858, 4679, 56927 +, 33961, 2135, 16380, 50282, 20995, 57817, 56788, 9894, 54507, 1667, 45502, 8221, 25534, 17974, 14116 +, 14020, 48789, 19898, 50024, 50488, 6872, 27926, 42342, 53781, 42304, 33056, 57528, 22429, 5915, 2207 +, 55708, 39876, 4342, 12088, 6511, 1689, 46257, 3299, 11584, 17117, 41318, 57086, 25338, 6852, 51412 +, 39455, 20872, 40202, 35705, 47248, 7042, 42577, 15174, 25737, 12710, 33831, 58793, 10238, 56260, 4708 +, 12446, 51968, 20937, 53140, 40409, 27448, 54830, 26666, 7099, 6414, 43783, 48417, 39852, 9122, 55269 +, 31265, 24929, 52494, 11467, 634, 16094, 18509, 19563, 31269, 20598, 32273, 41452, 19392, 18863, 37712 +, 452, 31309, 6032, 21389, 802, 46441, 25189, 55632, 49460, 8640, 2046, 33243, 57057, 18250, 18717 +, 28679, 49515, 43646, 57525, 37334, 20632, 13619, 55844, 40195, 21240, 52794, 48820, 2692, 12186, 7684 +, 40404, 12639, 38993, 22789, 10380, 16147, 45582, 11922, 11779, 35042, 20562, 50177, 44638, 53972, 8428 +, 3355, 22651, 57943, 23354, 56528, 35278, 43986, 10147, 7474, 534, 31388, 268, 49354, 34080, 48807 +, 57038, 50837, 1446, 12384, 49978, 48178, 28531, 35560, 100, 40311, 10603, 57015, 6840, 55241, 50987 +, 15268, 34948, 49990, 13212, 58302, 46518, 24842, 18641, 33017, 8668, 19175, 40757, 8936, 44881, 51190 +, 57743, 41920, 42027, 35541, 54304, 32005, 23720, 59187, 7565, 172, 39498, 54520, 57187, 46339, 49761 +, 24526, 37959, 1062, 14516, 27523, 35716, 37386, 52365, 54357, 10404, 1033, 49884, 51161, 46322, 34766 +, 42351, 20417, 53038, 730, 55959, 23694, 9087, 56031, 22881, 16653, 56203, 38732, 47525, 29743, 1423 +, 37287, 54269, 39382, 14701, 8786, 6906, 50417, 22524, 35623, 21127, 32928, 13009, 47363, 24090, 59331 +, 58481, 42793, 19748, 51519, 43524, 52059, 15213, 52611, 24442, 38095, 45616, 56998, 16827, 33142, 26741 +, 18250, 46781, 57362, 33984, 37834, 42500, 40890, 28251, 5025, 52866, 25730, 37953, 5875, 13094, 38395 +, 41558, 11575, 57541, 1306, 3095, 41065, 29718, 54660, 10028, 54160, 32755, 31997, 51158, 25934, 41491 +, 54251, 20536, 4624, 51614, 30873, 42458, 34114, 48115, 10709, 39139, 40981, 36440, 53445, 46856, 25886 +, 31840, 28414, 37461, 29381, 6073, 16908, 46798, 12143, 11569, 33179, 6303, 20676, 5176, 33814, 46611 +, 23019, 28065, 43499, 27643, 56031, 14372, 10101, 30146, 2488, 57162, 9285, 19821, 9954, 39082, 6678 +, 35840, 47275, 11444, 49654, 53008, 53869, 6562, 39807, 6012, 18131, 49338, 48668, 38808, 30866, 22482 +, 1771, 53885, 26899, 21622, 21528, 22931, 12347, 7981, 53077, 51187, 5143, 38714, 11008, 51450, 54149 +, 54038, 3642, 41424, 41835, 53296, 34432, 35704, 36211, 14239, 41717, 54342, 39929, 6737, 9502, 10795 +, 29219, 47625, 4680, 32470, 45600, 2560, 55401, 57947, 10541, 24830, 25486, 52037, 39897, 36494, 43487 +, 34046, 6885, 23481, 15470, 48720, 16778, 49902, 24424, 52989, 40494, 42493, 23683, 20423, 49230, 9538 +, 7571, 54801, 33515, 12251, 27272, 19115, 14812, 59025, 53414, 1705, 208, 18900, 53742, 16457, 55395 +, 37229, 26855, 2280, 37063, 18677, 27352, 53841, 8579, 51776, 23182, 25425, 10622, 23217, 22201, 59852 +, 9107, 29772, 31006, 42623, 18375, 58278, 38090, 9539, 33655, 31505, 11245, 10215, 50405, 4987, 26672 +, 22152, 18569, 53527, 784, 55632, 12204, 28136, 25825, 57136, 56265, 25359, 58913, 6887, 48576, 57466 +, 6739, 57684, 3590, 37745, 16659, 21966, 12375, 54749, 31505, 22383, 26254, 42750, 32598, 53012, 24090 +, 59271, 15164, 42659, 29150, 15949, 38291, 17707, 20437, 4116, 51195, 16702, 29475, 26460, 23589, 54403 +, 23927, 6681, 28439, 27517, 44426, 21450, 25835, 33154, 16200, 57341, 55537, 18806, 16443, 28135, 11818 +, 40533, 3758, 3335, 23192, 9261, 55636, 37835, 3320, 16073, 18303, 54515, 32776, 24130, 57327, 32717 +, 18534, 57606, 39398, 23325, 25124, 23825, 44776, 27311, 33331, 976, 24652, 28868, 56134, 17448, 33355 +, 7953, 34333, 13466, 11288, 33878, 22727, 43276, 11713, 26047, 59349, 6369, 56914, 8477, 30499, 54241 +, 41195, 25385, 51848, 20593, 48711, 53324, 20770, 9839, 20635, 54101, 47167, 21640, 59321, 43301, 15440 +, 32677, 27606, 49773, 46143, 15246, 23651, 45222, 58522, 11717, 11269, 57872, 18086, 44535, 6349, 24937 +, 15128, 23896, 50323, 43328, 44490, 15386, 36652, 41612, 25225, 33640, 35714, 12392, 31632, 11387, 32045 +, 47072, 20416, 59652, 13197, 42911, 14898, 13201, 28133, 13421, 24918, 15754, 47645, 19356, 289, 53994 +, 20645, 15418, 17891, 47320, 58746, 38733, 39058, 11751, 20345, 4283, 21743, 32411, 53027, 53375, 43799 +, 1425, 16799, 40567, 1077, 29996, 23479, 15975, 19549, 51612, 5748, 44467, 7367, 53393, 40175, 44008 +, 47388, 821, 59426, 41631, 24493, 34525, 56716, 3552, 22628, 53413, 44187, 44371, 25825, 13567, 14098 +, 45976, 14992, 7249, 26543, 16069, 37245, 26374, 8396, 56795, 17987, 14145, 17614, 1706, 7538, 34142 +, 45714, 31278, 11315, 21493, 49261, 35808, 32370, 22329, 15712, 54998, 15743, 59900, 15721, 17920, 13467 +, 6171, 3896, 4811, 13420, 6791, 20880, 50665, 33166, 5628, 23812, 27505, 19773, 17779, 29211, 3664 +, 51921, 14925, 11294, 39588, 12770, 556, 51748, 45140, 22885, 7461, 16490, 38628, 7361, 32211, 32900 +, 57180, 38382, 13148, 1991, 51802, 19940, 59223, 18820, 29458, 4851, 18984, 56963, 977, 13115, 2526 +, 40993, 41388, 53803, 52287, 20976, 6574, 52843, 12725, 28066, 52081, 20186, 44557, 7061, 3899, 53120 +, 39962, 1079, 7855, 53110, 39422, 36009, 49402, 38645, 31181, 55212, 43496, 50166, 52175, 20825, 3281 +, 31053, 1818, 21022, 24857, 54106, 41998, 7783, 23301, 31075, 12201, 15382, 51261, 56758, 58796, 31512 +, 26231, 38758, 32591, 34086, 8220, 12013, 46447, 57623, 27010, 17629, 52835, 46859, 44147, 21363, 7684 +, 47428, 28768, 45855, 44802, 29977, 39961, 26801, 37760, 39614, 57876, 49962, 54997, 25490, 23072, 30145 +, 57002, 25655, 8903, 5946, 59741, 53475, 17959, 46189, 51098, 44970, 40170, 20286, 31829, 24317, 18001 +, 15865, 48097, 46769, 1720, 32900, 16747, 18033, 59701, 30859, 57648, 33929, 57173, 28997, 59419, 56598 +, 59142, 32774, 22253, 44397, 38720, 58347, 37872, 33031, 44536, 5323, 54353, 1058, 25609, 2534, 25375 +, 43610, 54752, 13472, 30379, 56472, 46372, 23478, 14506, 22425, 54338, 48506, 56355, 51511, 17503, 32126 +, 48109, 52997, 41252, 46715, 37394, 19972, 45062, 15266, 29356, 5950, 20589, 61, 7008, 46198, 2596 +, 32383, 6160, 57348, 45855, 12892, 30172, 8580, 36370, 21030, 31005, 7060, 9536, 3712, 34924, 3391 +, 12191, 59385, 56388, 53443, 46100, 33782, 49768, 31162, 49049, 19124, 13464, 45990, 19185, 20472, 8541 +, 58133, 52855, 14701, 55481, 15063, 3945, 2006, 23643, 16668, 23036, 31000, 23728, 8925, 34713, 35004 +, 12316, 23256, 34390, 8705, 16699, 56842, 18839, 6467, 4357, 44240, 1943, 17821, 30231, 21129, 14646 +, 38772, 55614, 7501, 29825, 27448, 58916, 10123, 29454, 58911, 26791, 52490, 6264, 26871, 37767, 17329 +, 1876, 50084, 40585, 12618, 35141, 57284, 45812, 53980, 3752, 50169, 38221, 42047, 44343, 44804, 39528 +, 58989, 59928, 35143, 42842, 6105, 2591, 41759, 16228, 8397, 17022, 19371, 37239, 23286, 46243, 15007 +, 40615, 24471, 5091, 21200, 13441, 16584, 54837, 59253, 10564, 58589, 25775, 25137, 40636, 46470, 46293 +, 20165, 45459, 22573, 31660, 4653, 28679, 34251, 22764, 44907, 19000, 39787, 4279, 56239, 39425, 26874 +, 11246, 20041, 51345, 52689, 17593, 4786, 9273, 12430, 40391, 56190, 47371, 6166, 21327, 4360, 52636 +, 43973, 877, 14447, 6546, 32537, 19101, 35225, 43140, 41865, 56485, 2140, 58004, 37116, 58379, 37430 +, 40342, 45978, 33823, 31687, 38667, 27768, 12825, 47941, 40199, 53216, 20483, 3922, 35735, 18162, 44634 +, 4723, 2135, 45511, 55523, 8682, 54400, 50976, 20259, 37540, 32841, 53096, 16032, 7198, 6564, 50764 +, 20980, 46906, 36742, 54803, 18593, 51761, 58923, 7770, 16054, 15474, 37339, 36537, 19397, 49426, 54700 +, 4031, 30501, 33187, 25895, 26024, 18221, 20295, 17000, 38481, 34188, 26194, 7929, 50220, 33392, 14494 +, 17336, 54372, 1400, 30430, 25527, 56346, 22192, 802, 40468, 14598, 16277, 17807, 51136, 12026, 7233 +, 22188, 52409, 37735, 55375, 18304, 40111, 13597, 38600, 57112, 28430, 49140, 23306, 36359, 15712, 33050 +, 27205, 33049, 3774, 28606, 3479, 5653, 1304, 2023, 6455, 41772, 16622, 59084, 59580, 44110, 11110 +, 43165, 42650, 3520, 57252, 14377, 21824, 13716, 4326, 36776, 10828, 32756, 25916, 10486, 45468, 41629 +, 19888, 12673, 51030, 14, 17631, 54509, 5667, 18935, 32885, 48474, 708, 25859, 47559, 36640, 9969 +, 58669, 56157, 28971, 2189, 29762, 43348, 366, 43478, 47675, 37142, 30658, 56783, 39411, 17496, 42251 +, 21040, 37384, 31277, 12070, 37398, 25260, 42931, 19417, 20548, 15816, 7891, 57608, 18027, 55450, 34248 +, 27996, 30472, 6757, 33319, 32661, 12871, 16668, 33027, 56349, 4343, 46522, 27007, 37478, 25933, 20855 +, 56082, 23325, 58239, 27359, 35395, 11989, 28971, 54678, 31406, 49519, 46847, 39298, 47127, 4874, 11100 +, 57727, 9223, 41572, 40837, 42542, 14234, 53708, 59210, 23613, 26410, 39905, 46487, 53417, 17384, 12420 +, 50625, 13466, 35745, 48864, 17177, 47492, 854, 22500, 42171, 8612, 12020, 5370, 24262, 35499, 10244 +, 35363, 9579, 55819, 16935, 50416, 38362, 7521, 44124, 13924, 7487, 10534, 30182, 53974, 40304, 47566 +, 6395, 30929, 37384, 18492, 56145, 30913, 5985, 33351, 53413, 24508, 41964, 5433, 6230, 6226, 17285 +, 52826, 41589, 26864, 48646, 34877, 17280, 3360, 18750, 37756, 53636, 26237, 24643, 23818, 56564, 4947 +, 47736, 39311, 12228, 25120, 57803, 44725, 56033, 40140, 18077, 49447, 41000, 36393, 31232, 23582, 42619 +, 48517, 16409, 561, 15381, 41407, 11790, 32661, 21119, 6892, 46770, 14755, 33130, 11413, 38574, 6046 +, 52712, 26310, 45357, 41292, 51431, 19512, 26017, 23816, 36005, 20446, 13263, 53357, 56839, 44496, 16940 +, 15811, 9365, 33349, 52724, 24747, 51108, 40866, 33760, 12227, 47758, 20530, 26982, 57240, 8295, 41908 +, 3286, 1007, 8219, 24995, 42299, 36002, 44508, 44669, 36170, 20513, 5115, 49434, 13870, 38307, 10282 +, 7162, 30470, 19647, 16863, 59546, 20746, 7971, 40412, 54507, 56550, 4522, 15037, 23533, 1763, 59685 +, 5441, 41401, 692, 50012, 6397, 19344, 2366, 27257, 4013, 38537, 47770, 45480, 4323, 37992, 139 +, 14605, 21507, 30609, 10604, 38370, 6507, 31351, 22694, 46919, 25858, 19244, 51442, 17247, 42777, 29557 +, 16932, 24571, 10958, 53977, 50935, 53707, 13321, 53302, 20964, 53686, 8191, 45086, 15518, 12514, 59431 +, 15658, 3471, 20938, 22619, 14075, 59308, 5479, 21778, 22002, 52398, 23988, 41247, 20192, 41236, 376 +, 26101, 34520, 1299, 13412, 4849, 52235, 7119, 18170, 21889, 28084, 48208, 6432, 13170, 40079, 18946 +, 48953, 55737, 22417, 9891, 54708, 12844, 45552, 187, 34623, 43906, 28938, 58611, 1505, 25482, 16199 +, 1882, 27936, 27072, 39533, 41348, 31921, 8120, 48467, 26444, 30009, 52903, 51004, 12793, 42426, 31083 +, 31739, 31379, 3172, 30508, 41271, 34233, 43353, 3175, 10772, 54328, 47081, 16062, 52939, 48587, 41545 +, 45491, 26821, 9481, 48915, 42706, 27181, 20836, 50827, 15648, 23632, 57188, 44904, 14637, 9982, 27330 +, 22072, 41721, 58709, 25245, 12230, 16332, 59478, 31935, 55859, 46602, 26263, 42941, 2665, 55554, 7880 +, 20562, 17397, 11053, 6395, 6312, 53759, 33576, 3501, 44586, 25576, 27133, 41775, 10480, 18122, 28109 +, 37810, 40195, 9830, 12872, 41792, 58412, 5556, 17622, 6699, 1416, 4224, 9314, 44357, 6889, 4869 +, 28589, 27451, 22266, 39642, 33846, 4931, 33401, 43774, 8432, 54340, 9351, 35565, 36115, 19831, 53688 +, 4224, 33994, 10235, 50406, 23218, 52027, 25171, 28774, 9649, 31870, 30190, 50225, 41185, 50899, 33467 +, 22406, 19488, 37270, 21024, 35482, 47469, 25955, 45236, 31243, 34387, 39576, 40594, 9953, 52043, 36778 +, 39993, 32619, 10772, 26580, 59377, 33990, 18607, 24548, 2764, 4608, 32771, 9307, 31185, 50308, 36558 +, 4652, 12714, 32399, 41923, 10090, 7881, 29392, 36046, 53117, 635, 46785, 9045, 17582, 56738, 1088 +, 54360, 13083, 33707, 41484, 39663, 33085, 15474, 34622, 33985, 54590, 15582, 6756, 40249, 46768, 33416 +, 16808, 27772, 22482, 49207, 9695, 32573, 33440, 15439, 44971, 2910, 52427, 31756, 11955, 46361, 4847 +, 13044, 40721, 17930, 23103, 22205, 33946, 32540, 14031, 44920, 6526, 8621, 503, 49634, 25223, 23623 +, 59403, 42031, 51395, 21885, 7590, 37443, 30810, 41030, 29234, 15781, 20292, 21661, 23890, 32248, 8022 +, 28737, 21644, 25095, 23019, 21099, 47300, 33317, 53640, 37683, 18238, 36518, 22657, 18741, 2504, 47880 +, 18716, 1907, 29911, 10111, 145, 13853, 23906, 30955, 31235, 53141, 23089, 51528, 14802, 46979, 23776 +, 59177, 15716, 45420, 624, 15087, 42871, 47925, 48405, 36511, 1960, 6643, 13029, 24617, 1736, 51886 +, 12497, 20452, 53793, 18760, 30563, 53938, 32613, 54470, 24894, 40201, 23963, 24335, 31729, 15117, 11314 +, 55505, 14294, 3382, 17277, 14919, 18469, 148, 39196, 6874, 13012, 17508, 49869, 2393, 42126, 51605 +, 54279, 54623, 12057, 48073, 49736, 18973, 18363, 58701, 49795, 19609, 38902, 13758, 43944, 10631, 28875 +, 55258, 42488, 19522, 58640, 36117, 10793, 53462, 12618, 26341, 36688, 25630, 43849, 26558, 4375, 25975 +, 18163, 58655, 56951, 6573, 23080, 23039, 1898, 17795, 21740, 28045, 37405, 36995, 41803, 57701, 23978 +, 47030, 52960, 42819, 6552, 27952, 18936, 53697, 57766, 7906, 20038, 34455, 9888, 3888, 1013, 14264 +, 29863, 55528, 49271, 3166, 2101, 12351, 26205, 40351, 30146, 47946, 8396, 43903, 1293, 26551, 41605 +, 25271, 13582, 10917, 8090, 56486, 38869, 3379, 50184, 36636, 47637, 46574, 47443, 57526, 50462, 48456 +, 11790, 56678, 43984, 1061, 59844, 22438, 49764, 2402, 2789, 56262, 26700, 47538, 40166, 27993, 14089 +, 21771, 29616, 27671, 32688, 14059, 510, 47909, 17438, 27046, 897, 41427, 13620, 48340, 38953, 40435 +, 13148, 50743, 37113, 57133, 28156, 13309, 55923, 17920, 15711, 58712, 14183, 18763, 46250, 30701, 46756 +, 36692, 52472, 52725, 4363, 1512, 6784, 41225, 25773, 574, 8271, 26671, 42001, 21892, 51363, 20955 +, 2327, 4512, 48050, 15792, 1645, 52559, 5453, 33920, 10479, 57517, 32632, 1014, 16280, 55235, 31715 +, 39389, 31927, 539, 32114, 12642, 38403, 15250, 30220, 4177, 15824, 38491, 7200, 34177, 36735, 58563 +, 55132, 15414, 3075, 19535, 7558, 41072, 12094, 13012, 14992, 58925, 10529, 23977, 36292, 3161, 55564 +, 44359, 42550, 3843, 21251, 51016, 52837, 59654, 6266, 23057, 3831, 58442, 1549, 11031, 32620, 14636 +, 45947, 4104, 30051, 49022, 59991, 37609, 6447, 48437, 50621, 21439, 47363, 37502, 21768, 23655, 17016 +, 17332, 44366, 35918, 21175, 5617, 26935, 50365, 5272, 9553, 13422, 45455, 44348, 51323, 32839, 53320 +, 5960, 18786, 33776, 36011, 44160, 33768, 13620, 50607, 22205, 40594, 48399, 45920, 54448, 10167, 45927 +, 11464, 27500, 30294, 47383, 25027, 35911, 50670, 15392, 17535, 36575, 5167, 2991, 57275, 56490, 35830 +, 50595, 2450, 54616, 724, 38461, 15128, 34492, 28434, 5736, 33049, 45380, 54135, 55322, 16180, 40654 +, 41249, 3997, 44506, 11543, 27732, 9534, 23807, 18402, 1278, 41342, 31329, 42797, 44333, 28605, 39288 +, 56515, 55552, 41738, 27483, 56276, 56552, 42612, 7120, 1338, 48348, 40170, 23070, 18835, 11844, 39250 +, 59489, 53093, 43247, 43996, 40989, 47331, 29882, 41148, 42085, 7512, 22490, 13415, 50310, 43176, 18372 +, 29598, 39691, 13924, 47688, 7175, 10201, 20592, 26139, 17321, 21930, 50839, 33843, 21352, 46026, 45687 +, 603, 45515, 15133, 20202, 5863, 32474, 7534, 12097, 13622, 49619, 19610, 36112, 39386, 46272, 55640 +, 57758, 52222, 35332, 11683, 39910, 18859, 58236, 36855, 21350, 51909, 35137, 12189, 2105, 56490, 58215 +, 47792, 33445, 20082, 39277, 53647, 2298, 11751, 37533, 14395, 25373, 3505, 10357, 37838, 19243, 56629 +, 33478, 17002, 48851, 45162, 5037, 5114, 40373, 39625, 41969, 38075, 31534, 17106, 50264, 33639, 13596 +, 24831, 57784, 47041, 44914, 13413, 17041, 47212, 25165, 30926, 37959, 26890, 10783, 48317, 41080, 30027 +, 44946, 50911, 47029, 33798, 36073, 28418, 15264, 52799, 8043, 57233, 30874, 15929, 50691, 57491, 49569 +, 4288, 22322, 23705, 27681, 43588, 37118, 21074, 7152, 38635, 52001, 45112, 41878, 39136, 33429, 22958 +, 9163, 54727, 13869, 32544, 4877, 26295, 962, 20141, 55446, 9005, 53726, 2672, 1287, 44418, 163 +, 50856, 25058, 58838, 50913, 52739, 18778, 4383, 50166, 25931, 19371, 18519, 11043, 1249, 57655, 20824 +, 24207, 6819, 15551, 14429, 39363, 20429, 40724, 40326, 40570, 36170, 25683, 34297, 38842, 26970, 55067 +, 15358, 54178, 20125, 50548, 21443, 49216, 9326, 2179, 39382, 11609, 21550, 34253, 59004, 22799, 31909 +, 19828, 23358, 38728, 11732, 37787, 54443, 32161, 54863, 11121, 49083, 7385, 13157, 59732, 46228, 16479 +, 54799, 37938, 47010, 14924, 28486, 8453, 40493, 14164, 46984, 19875, 25774, 8534, 54129, 24778, 7685 +, 2390, 20959, 31044, 17470, 32691, 45183, 11913, 4852, 40047, 59387, 30287, 47432, 12544, 30020, 10012 +, 29023, 1171, 24302, 52385, 52448, 52788, 37191, 32941, 43305, 24175, 29168, 9079, 32710, 59649, 10209 +, 40395, 2039, 31168, 47791, 19509, 3859, 32975, 7775, 45063, 49374, 7162, 15351, 36806, 56058, 21723 +, 23171, 25081, 22894, 47473, 53819, 15342, 16614, 31010, 24635, 59919, 55185, 53804, 45350, 27895, 53453 +, 55559, 44643, 55493, 26728, 32434, 51354, 6939, 41761, 59129, 52003, 31135, 6291, 43706, 44294, 2349 +, 5429, 7465, 3783, 4675, 54938, 57602, 56370, 47904, 4964, 21005, 47823, 149, 14809, 33173, 28045 +, 8263, 5085, 49040, 40108, 31813, 21474, 7814, 15104, 3236, 6944, 7107, 10723, 49587, 50813, 55017 +, 28289, 32594, 2482, 8424, 37270, 33773, 42378, 33640, 58029, 47342, 54645, 45853, 47491, 45807, 55378 +, 51888, 30422, 463, 40928, 10530, 8628, 38755, 18344, 23733, 18343, 1640, 30840, 29066, 51228, 58006 +, 436, 55869, 6952, 39270, 4293, 44222, 13043, 23023, 54214, 47425, 10365, 25212, 33278, 34208, 11019 +, 5008, 2449, 41441, 5472, 19729, 28323, 50452, 58484, 23019, 14185, 53179, 24660, 21378, 58598, 52240 +, 55736, 59034, 24461, 2688, 38304, 5106, 23263, 27700, 28129, 17477, 15125, 14846, 42689, 24755, 49054 +, 30060, 29763, 27855, 11501, 11587, 47585, 16176, 2040, 22421, 39196, 16225, 15601, 40208, 37603, 14199 +, 32448, 9691, 49585, 33261, 12380, 27889, 38367, 35643, 55589, 6496, 53120, 47066, 21342, 12162, 11821 +, 46748, 42222, 41585, 14604, 30076, 53172, 2189, 46252, 55212, 962, 25448, 47790, 16563, 5656, 1745 +, 7114, 14456, 11437, 33051, 47717, 23817, 941, 26084, 59460, 32882, 8932, 28932, 19949, 6626, 17446 +, 8122, 53375, 59669, 49707, 7979, 29745, 19232, 46520, 15997, 50796, 47482, 17798, 38586, 40398, 23454 +, 40332, 23864, 14263, 28121, 33268, 38332, 51938, 34209, 4417, 27750, 43443, 49701, 33034, 39744, 56328 +, 50481, 47867, 49703, 26502, 13926, 34034, 56247, 9510, 56906, 48596, 307, 20740, 42746, 15245, 37490 +, 42553, 31929, 1355, 56816, 50, 10975, 35148, 28340, 45184, 15917, 32442, 4979, 5619, 5477, 44724 +, 1947, 32310, 8943, 28002, 58812, 22869, 2036, 31411, 8732, 58942, 56359, 9039, 56034, 39106, 636 +, 33525, 21659, 32566, 11232, 54827, 8968, 22207, 29975, 37309, 43743, 22245, 9751, 48722, 27864, 51580 +, 33446, 6163, 23890, 18741, 34165, 22702, 41611, 12553, 30465, 50343, 47847, 26825, 35734, 43881, 42283 +, 36370, 17406, 3942, 45288, 28638, 58769, 54257, 27197, 5096, 7918, 10940, 3693, 17669, 59663, 7909 +, 45602, 9461, 14072, 9492, 28203, 24589, 8547, 46166, 37142, 15364, 36509, 24989, 42189, 48595, 45223 +, 24472, 1317, 38981, 4766, 46606, 7620, 39887, 17215, 11169, 21336, 25133, 22110, 25029, 19154, 21773 +, 32939, 4756, 7586, 23363, 14249, 35789, 47953, 59148, 21955, 1447, 14512, 34816, 2789, 33054, 23411 +, 48012, 57526, 1081, 26993, 38645, 24039, 10965, 18532, 41254, 22135, 39868, 6387, 44245, 41250, 25541 +, 42370, 14189, 30298, 49956, 37552, 20899, 2098, 1857, 56399, 24053, 3305, 47263, 58870, 6094, 20317 +, 58633, 54106, 54196, 59714, 57451, 32841, 23753, 8417, 27725, 41359, 6904, 43946, 47746, 27501, 25196 +, 49640, 9871, 39385, 56290, 36179, 53289, 53541, 38277, 55147, 49940, 38683, 34804, 13555, 37553, 40898 +, 33873, 12538, 11356, 4421, 48605, 8807, 37262, 48710, 53576, 41339, 30070, 480, 25285, 54168, 4333 +, 50481, 20160, 50556, 6218, 16450, 26736, 59508, 9991, 41365, 31007, 36283, 20048, 42163, 49839, 33953 +, 23061, 64, 46492, 10769, 4485, 11449, 19576, 18099, 159, 49505, 59438, 6581, 26337, 24724, 37102 +, 30671, 51557, 57262, 21227, 57776, 13713, 24315, 33636, 56, 5681, 40995, 12692, 2081, 23158, 2531 +, 36035, 22571, 2595, 58879, 33340, 43432, 10328, 29268, 1531, 46839, 18773, 969, 29773, 21463, 2045 +, 6875, 28486, 53603, 40489, 49713, 27731, 30554, 50381, 37719, 30611, 32414, 18714, 43303, 34495, 18224 +, 22186, 46882, 40795, 1133, 45761, 14135, 44565, 32441, 43403, 46096, 55633, 38529, 23417, 25406, 59992 +, 25463, 8633, 28478, 55418, 49122, 54543, 59501, 19677, 21276, 37220, 26640, 53690, 32286, 46295, 4538 +, 50510, 44833, 51420, 31305, 22318, 13534, 45440, 6883, 45975, 5195, 29331, 41608, 43724, 29100, 43366 +, 20068, 54563, 28351, 24898, 26333, 17474, 55794, 2186, 13503, 17070, 39406, 16495, 47113, 48044, 39142 +, 51651, 38554, 23975, 19423, 9859, 46293, 32957, 31651, 29528, 55285, 13199, 58859, 36893, 33275, 27959 +, 56612, 29696, 58875, 24963, 54594, 1560, 18789, 26740, 3747, 32292, 43811, 19505, 25139, 7276, 7550 +, 4281, 58927, 22456, 4608, 54702, 8668, 50901, 27660, 16671, 56781, 22945, 29870, 31992, 36190, 39498 +, 36304, 32802, 9194, 11531, 34118, 40140, 13091, 52907, 6881, 53190, 1552, 27044, 49048, 26691, 34320 +, 32950, 7325, 9599, 55406, 11933, 40653, 4074, 39187, 8313, 57098, 12320, 7610, 26968, 44313, 20153 +, 42818, 20617, 52955, 52012, 32148, 3425, 8505, 21591, 56333, 15386, 51134, 34237, 18782, 40182, 928 +, 29454, 49484, 44605, 15405, 21242, 32891, 56058, 1669, 12078, 40724, 58767, 750, 48334, 2087, 45063 +, 8487, 44906, 42032, 37795, 13270, 14180, 17572, 21775, 12124, 13905, 13513, 3258, 48142, 8647, 19792 +, 25423, 38101, 45628, 46380, 53506, 6870, 19271, 25917, 8539, 7701, 6641, 7306, 8452, 31327, 9394 +, 53515, 16167, 30652, 35548, 30314, 43922, 26080, 47886, 42050, 14556, 38144, 55563, 54166, 2638, 4211 +, 13958, 4413, 18664, 35938, 50794, 48523, 42809, 10065, 14440, 51348, 17767, 57433, 35007, 26219, 5112 +, 44401, 56086, 57631, 51405, 7986, 27945, 35327, 34067, 52184, 53729, 24975, 6680, 25645, 19142, 9318 +, 29856, 9452, 50084, 24872, 45391, 40878, 13395, 28200, 50943, 4187, 55900, 45062, 37972, 30907, 47633 +, 19437, 51660, 43720, 17068, 43065, 51706, 21366, 54745, 2125, 13550, 48474, 27101, 20230, 14119, 22595 +, 5900, 20327, 32047, 55984, 21552, 17438, 13214, 11299, 45638, 40510, 15487, 41539, 25572, 29811, 12446 +, 13206, 49248, 40459, 33278, 6317, 23524, 24984, 27683, 18269, 3462, 17585, 43096, 6915, 14167, 33567 +, 29510, 56419, 53895, 1557, 28756, 51799, 55348, 41970, 3098, 40986, 22480, 54937, 58877, 24405, 24749 +, 47676, 37611, 50349, 28135, 10889, 33018, 28011, 12225, 37053, 22633, 52039, 54638, 5729, 58954, 45157 +, 15648, 4816, 17929, 45895, 42726, 46685, 37694, 38074, 28655, 40793, 55412, 27488, 35730, 54290, 51893 +, 36831, 18318, 5856, 27181, 46453, 53097, 199, 50816, 5322, 13605, 13449, 33714, 44595, 55530, 32668 +, 29753, 11179, 13837, 47682, 57074, 32915, 10719, 34769, 10989, 15726, 15562, 42753, 43214, 27644, 13395 +, 11459, 4476, 31713, 17315, 8009, 54518, 46764, 44560, 45335, 52087, 58165, 58784, 25801, 42761, 54315 +, 34821, 48866, 5494, 25010, 12900, 38920, 57925, 23619, 13689, 45266, 39345, 29251, 28020, 58912, 56896 +, 41415, 10371, 37724, 13129, 4039, 45733, 43999, 27155, 30293, 29334, 19242, 28459, 4471, 21395, 47572 +, 35138, 32569, 36438, 16984, 57579, 49338, 55904, 31857, 49309, 9594, 17123, 28654, 15197, 45143, 27566 +, 48445, 2911, 14290, 26169, 16040, 54681, 11902, 36391, 21836, 18548, 5726, 17431, 47007, 46549, 15178 +, 34579, 58039, 24099, 47369, 15023, 21679, 36707, 47279, 29888, 26016, 33225, 47011, 31022, 48423, 8507 +, 34941, 36868, 11418, 25583, 39390, 3810, 56616, 27644, 40201, 54804, 46192, 22279, 12235, 33199, 45180 +, 3766, 44130, 43219, 27865, 31499, 34594, 25896, 44558, 21874, 55784, 46926, 55099, 19148, 17949, 19874 +, 4007, 29242, 33095, 15425, 54825, 12485, 55587, 27793, 40129, 12140, 22597, 26322, 10772, 34833, 35873 +, 55952, 14951, 56356, 15524, 42816, 27855, 50118, 8713, 48766, 48344, 40849, 35692, 43444, 59997, 29993 +, 3318, 40356, 59235, 36413, 55781, 30412, 25250, 27720, 58205, 41732, 39861, 20803, 44406, 26985, 31988 +, 20279, 22937, 46939, 52987, 38461, 6107, 20843, 4932, 51172, 9609, 53276, 32022, 21653, 36720, 8371 +, 51647, 16391, 25080, 27234, 29156, 20861, 57647, 54407, 24934, 55852, 36139, 41147, 53007, 20545, 8132 +, 1347, 17176, 7421, 48286, 10164, 45883, 30746, 7359, 27167, 21918, 53320, 20443, 30292, 14973, 33516 +, 15016, 42972, 49907, 40096, 10207, 55415, 37309, 7854, 26174, 38595, 40058, 38665, 19742, 9418, 59210 +, 4226, 10765, 52739, 11648, 35404, 39255, 57531, 6150, 46614, 24698, 4420, 16286, 21493, 11065, 7611 +, 55009, 2433, 50584, 21268, 18881, 791, 16684, 56190, 44997, 42858, 11138, 1407, 21524, 30880, 10825 +, 57086, 35107, 21591, 26177, 46755, 33347, 41784, 20638, 15849, 4750, 21688, 20269, 21036, 43181, 7686 +, 28648, 14543, 10119, 19232, 35811, 29000, 56375, 28847, 1543, 41372, 48058, 49033, 42779, 9582, 19913 +, 53605, 43020, 31372, 51548, 45550, 54479, 24895, 27334, 51469, 40744, 32085, 49509, 37365, 53121, 9043 +, 45052, 58121, 23586, 31523, 53705, 59397, 36876, 50080, 4597, 14771, 31452, 52655, 3804, 14232, 38589 +, 69, 44189, 21609, 31442, 12089, 43511, 2273, 36984, 10846, 53743, 54080, 19283, 43252, 7797, 48756 +, 52295, 29201, 46878, 15881, 725, 40583, 51631, 13953, 30664, 56228, 28724, 38468, 48883, 32528, 29052 +, 3824, 32597, 13241, 25433, 40391, 25330, 45297, 42665, 38666, 56143, 12760, 9098, 51778, 32364, 16896 +, 40534, 24660, 22449, 3764, 16893, 59526, 44348, 44876, 13479, 51364, 17456, 18555, 6184, 42691, 51083 +, 35237, 46515, 33, 48478, 48301, 16776, 50161, 33598, 35793, 5179, 29741, 48553, 50630, 21519, 20918 +, 43878, 38405, 21930, 6327, 42170, 15175, 5854, 2870, 52, 55685, 54234, 17508, 14241, 418, 36552 +, 41676, 12007, 23067, 18061, 486, 11368, 34838, 26999, 44966, 46983, 8530, 51059, 11889, 35512, 48930 +, 9159, 19390, 27336, 31089, 2070, 9506, 46264, 7924, 48728, 22668, 39961, 42962, 40177, 54202, 19732 +, 16729, 35879, 31740, 16148, 53940, 8578, 27517, 5130, 11929, 48835, 52114, 56811, 39895, 40355, 32324 +, 28825, 49514, 51714, 32513, 20603, 53784, 18371, 43219, 38060, 7099, 5888, 18022, 26413, 22417, 48576 +, 46146, 15498, 24455, 54238, 7998, 54748, 2816, 35515, 36230, 51097, 24351, 4696, 47908, 40598, 45051 +, 20232, 45775, 34565, 48299, 18289, 31520, 18435, 36660, 14740, 56496, 20112, 56980, 50870, 46525, 55749 +, 39446, 32671, 47599, 40254, 3261, 55597, 11354, 42429, 31113, 47584, 33526, 31816, 52281, 57787, 12414 +, 37332, 54371, 58189, 11898, 42670, 52830, 19770, 1106, 5843, 34510, 33954, 25955, 7842, 1176, 12480 +, 3591, 16974, 21504, 51190, 57228, 24765, 46788, 8582, 7195, 54253, 32519, 17073, 2421, 24800, 14860 +, 51187, 38484, 9232, 25728, 26734, 28254, 18559, 46505, 29360, 24402, 57367, 39666, 26709, 5210, 40842 +, 39189, 8801, 34169, 37045, 36344, 31397, 1811, 59484, 16332, 45358, 30089, 25203, 2431, 32510, 26355 +, 53644, 49, 4839, 39228, 25777, 31574, 7482, 20688, 54431, 36843, 21442, 51798, 52861, 48151, 57008 +, 10056, 3693, 42162, 44225, 40738, 18506, 51974, 18901, 54342, 44658, 4259, 24431, 46213, 43043, 33293 +, 12568, 13039, 33342, 17408, 52267, 59119, 25334, 59749, 56160, 19765, 12944, 17602, 11563, 5806, 5754 +, 8572, 52214, 9447, 27086, 36439, 26537, 21944, 4765, 45439, 16286, 25776, 26050, 40717, 11989, 9093 +, 50362, 24558, 22132, 23704, 18318, 14399, 59175, 43652, 14149, 55335, 39769, 3445, 12938, 51332, 9251 +, 55044, 36256, 37817, 40843, 3342, 14256, 7380, 1638, 55374, 29171, 17924, 21150, 55222, 34993, 9491 +, 40667, 25355, 34049, 2800, 25411, 52367, 53551, 24587, 12371, 44052, 56274, 52140, 47498, 9212, 19825 +, 33101, 40608, 56081, 10919, 21451, 35776, 1527, 5184, 37414, 33253, 34355, 31691, 54403, 29577, 6684 +, 3895, 10245, 32040, 14296, 49397, 33803, 6664, 19300, 58390, 55387, 3353, 31017, 47528, 27203, 16581 +, 7353, 36656, 57190, 39786, 47575, 54993, 51914, 25455, 177, 29329, 58708, 34533, 1020, 29464, 40462 +, 44056, 9711, 27059, 52448, 359, 16456, 26252, 7023, 35757, 994, 38763, 15462, 32011, 26291, 19017 +, 48593, 33644, 55673, 45783, 49782, 19601, 40776, 41697, 45056, 17306, 11026, 20116, 28191, 48398, 25932 +, 8653, 8806, 35643, 35713, 1255, 36003, 28521, 3859, 19378, 40630, 4853, 58141, 32444, 13217, 784 +, 51461, 1810, 10780, 47135, 23945, 563, 43088, 41073, 42260, 4496, 58379, 29638, 24612, 26570, 54388 +, 26897, 11576, 3194, 38892, 47289, 40801, 51247, 52162, 44660, 10626, 32793, 25866, 45119, 5237, 39083 +, 22256, 33051, 40893, 33036, 56538, 41190, 9951, 39626, 22263, 52211, 44122, 56995, 58201, 45086, 23565 +, 52589, 11983, 35141, 32136, 50876, 58782, 12937, 42123, 27297, 33950, 29101, 90, 59816, 50573, 41679 +, 38899, 49181, 14730, 56144, 22217, 11268, 37334, 32169, 27246, 59597, 732, 47720, 56592, 58934, 32807 +, 56510, 51523, 21142, 8003, 11, 48370, 43138, 49301, 6846, 10435, 23251, 12299, 46877, 23067, 39224 +, 28556, 38318, 28405, 19639, 34462, 50623, 7259, 48148, 59144, 34506, 47745, 59876, 22226, 20690, 58810 +, 31385, 53552, 26686, 28880, 37907, 3049, 17250, 21045, 52350, 448, 7832, 15601, 12748, 54709, 15020 +, 51972, 59618, 29690, 56730, 19257, 4152, 23705, 2868, 28652, 22849, 37374, 52750, 59077, 35953, 13440 +, 34240, 7338, 43344, 926, 36218, 21251, 40327, 29821, 18649, 32678, 30269, 26481, 24631, 19369, 57543 +, 39652, 47694, 57161, 9342, 44424, 52770, 49847, 8129, 55638, 18499, 7330, 9365, 11249, 6407, 45318 +, 1041, 40647, 52656, 20737, 17925, 5227, 41989, 58253, 11400, 36990, 30931, 41669, 3471, 55562, 37391 +, 1014, 11566, 25085, 34527, 57261, 9509, 27297, 47108, 53990, 59288, 41959, 1320, 8653, 29561, 7727 +, 53971, 6954, 24727, 22979, 27692, 42652, 4558, 46033, 40905, 15958, 23023, 11836, 57628, 2846, 43751 +, 35019, 40213, 55317, 36456, 14740, 52578, 22317, 18390, 16038, 16307, 17678, 34350, 53979, 2683, 40263 +, 38058, 56654, 47217, 2785, 19633, 51261, 45438, 544, 13646, 2695, 16502, 36669, 50884, 50482, 15868 +, 34635, 25501, 56081, 6304, 38309, 47173, 35235, 626, 41915, 51273, 53285, 59593, 1975, 47264, 2276 +, 42238, 25323, 35282, 5808, 4460, 31268, 33421, 49898, 31812, 47068, 52594, 48314, 23737, 19830, 38797 +, 15957, 54465, 40650, 12038, 769, 18960, 35564, 12356, 55938, 17479, 3630, 49224, 53425, 41957, 12840 +, 55701, 548, 14515, 7336, 6356, 18976, 38604, 39777, 45226, 46768, 3197, 14172, 35082, 26935, 34002 +, 50231, 19244, 28467, 30882, 31283, 5589, 26194, 6847, 17945, 22132, 24326, 57927, 47708, 17751, 39885 +, 549, 49805, 40433, 15064, 33493, 23141, 34040, 12097, 39270, 55619, 58865, 42468, 9791, 10299, 45755 +, 43794, 531, 4999, 48613, 7765, 12634, 54202, 10311, 19481, 48500, 8795, 20160, 22779, 56504, 14263 +, 2664, 33405, 40420, 19449, 48469, 13913, 18942, 58862, 2362, 34565, 54481, 37579, 17033, 4272, 24231 +, 39140, 24418, 1114, 44139, 13032, 8879, 56774, 43586, 55542, 52607, 32086, 4337, 49119, 54866, 841 +, 3383, 33882, 34246, 20155, 29684, 59068, 10421, 48626, 57930, 12783, 59543, 28763, 26715, 16576, 9387 +, 50946, 55716, 33806, 28412, 16208, 46838, 13643, 12982, 30424, 9185, 41941, 38863, 13522, 31061, 33729 +, 50716, 10796, 43963, 1314, 30951, 13647, 36734, 41372, 38626, 11016, 30508, 38169, 39779, 33575, 31098 +, 49167, 24521, 26814, 22973, 29285, 19374, 46163, 42928, 32356, 52939, 52113, 50650, 31802, 41987, 21711 +, 41883, 9055, 32507, 25847, 10370, 3458, 39494, 47104, 21183, 54472, 34473, 51691, 8994, 14252, 25266 +, 40092, 39771, 26139, 43258, 39096, 31776, 2633, 25259, 14704, 11341, 18199, 43169, 1991, 50001, 25156 +, 23702, 8237, 34212, 32561, 34084, 20934, 12372, 49930, 44390, 33555, 44403, 18863, 1598, 29749, 33116 +, 3216, 9841, 49239, 5707, 53099, 28336, 37483, 32084, 53595, 52187, 43426, 48146, 35356, 45417, 14500 +, 36864, 45472, 22737, 47428, 18033, 56821, 8362, 30405, 23103, 29105, 3960, 7506, 47968, 41910, 37255 +, 57436, 45126, 23448, 46676, 50833, 52900, 15012, 28316, 24984, 44959, 56855, 8410, 9458, 8563, 30180 +, 310, 45428, 15652, 23047, 32856, 33685, 56220, 17571, 4091, 19323, 46676, 44403, 3182, 34644, 2666 +, 16789, 8433, 47792, 16590, 55109, 14978, 9490, 46473, 19646, 34474, 7784, 16502, 19237, 53594, 1417 +, 49417, 53904, 46845, 5069, 53303, 56054, 15106, 49523, 13625, 19197, 45199, 301, 39953, 24733, 11297 +, 42619, 17874, 19730, 6763, 34464, 51191, 21741, 20306, 14016, 17740, 54781, 21801, 34242, 50370, 51747 +, 12011, 39787, 45652, 58857, 44856, 38955, 31263, 36314, 4831, 44888, 31864, 26382, 21541, 11817, 27467 +, 32838, 30788, 45341, 28921, 37551, 56158, 20112, 35645, 16464, 34129, 53385, 47597, 32282, 3979, 37967 +, 24029, 15990, 17754, 46033, 51199, 38962, 1341, 22462, 15277, 42524, 43702, 47141, 45258, 5243, 35310 +, 12725, 38082, 6098, 34418, 7003, 20001, 30576, 3467, 55646, 47041, 37596, 49031, 34638, 46230, 53010 +, 48958, 46612, 45353, 6712, 32645, 36552, 22027, 10338, 59015, 37304, 52862, 42717, 797, 38120, 24313 +, 36107, 50845, 2395, 18557, 25264, 45750, 38558, 32192, 25569, 10557, 55585, 39518, 59588, 30224, 25748 +, 28951, 55534, 12360, 14304, 2246, 21358, 27208, 24273, 31696, 2575, 37929, 911, 45293, 38726, 15383 +, 9606, 51185, 42581, 48353, 9742, 44197, 10455, 48301, 16389, 36024, 58858, 11975, 15542, 34798, 18551 +, 17643, 40101, 14085, 6355, 30757, 52683, 27713, 57966, 16957, 35762, 541, 54886, 13025, 22186, 9965 +, 28408, 8144, 1150, 10989, 32849, 10893, 55186, 43304, 35546, 47928, 55681, 10756, 59903, 47575, 21906 +, 54806, 5218, 38360, 45243, 11574, 9117, 37926, 15639, 43435, 31235, 27753, 20329, 2474, 40778, 42515 +, 12439, 9187, 27012, 13589, 56528, 59861, 834, 28067, 43166, 12732, 15995, 15199, 59840, 52250, 2774 +, 21747, 23408, 7993, 107, 8651, 55919, 45576, 46577, 11558, 29012, 54165, 15664, 49341, 56639, 56442 +, 8208, 9078, 41981, 35220, 59019, 38510, 11434, 36206, 6577, 30952, 48938, 58924, 46151, 48779, 27526 +, 48925, 46878, 50934, 33270, 46985, 59585, 29189, 8913, 22514, 17100, 37925, 16679, 32764, 3618, 13318 +, 5558, 11827, 58748, 47540, 23399, 57768, 2402, 34833, 33974, 45331, 42137, 59264, 44255, 28288, 48043 +, 11781, 53566, 11273, 39067, 26836, 34610, 15004, 32378, 43524, 37518, 25830, 21449, 30550, 34946, 1420 +, 20220, 40504, 49599, 18969, 4396, 12998, 53089, 6798, 24184, 3415, 28481, 6321, 2679, 12736, 10962 +, 27075, 869, 4528, 38348, 16288, 7716, 12959, 31292, 40094, 56483, 8811, 42276, 54284, 15713, 17222 +, 55704, 35933, 34079, 45303, 31254, 38475, 34654, 24343, 21626, 35190, 4110, 50107, 17863, 6790, 39196 +, 28825, 10217, 16417, 33353, 24917, 32706, 41070, 37876, 3998, 57516, 10711, 49161, 39793, 41348, 4874 +, 33367, 37052, 17160, 7446, 58708, 48414, 22274, 33362, 49110, 43900, 44904, 29572, 10359, 2767, 12714 +, 25907, 31593, 22931, 42325, 41298, 47849, 51383, 58720, 2077, 31733, 56237, 49141, 20895, 12382, 30489 +, 2121, 45749, 43893, 55633, 29548, 42601, 20400, 51822, 52315, 45862, 12074, 37219, 15434, 58785, 39987 +, 28149, 24693, 47932, 27432, 43370, 29230, 51633, 34753, 27951, 30063, 42838, 540, 19204, 3733, 12922 +, 26045, 42207, 35023, 9938, 37840, 4571, 28892, 34592, 32745, 57559, 20454, 21171, 34779, 35889, 19957 +, 51118, 40390, 21002, 15402, 44174, 40724, 44632, 12160, 51829, 12583, 42223, 34667, 49475, 37779, 14753 +, 2397, 3824, 56960, 37421, 50114, 11152, 18344, 19006, 45745, 51090, 16566, 42551, 48613, 27697, 54792 +, 44922, 55167, 35182, 5924, 10569, 55709, 46648, 31553, 7869, 38477, 20489, 50092, 49497, 9964, 4223 +, 4250, 12362, 8047, 37562, 26135, 58161, 25066, 44479, 53520, 47163, 11921, 46438, 29715, 36887, 50487 +, 24507, 21809, 22006, 36042, 4086, 32575, 8103, 27086, 40480, 15972, 41916, 969, 42416, 31413, 10934 +, 46639, 35663, 59648, 31038, 49577, 25783, 5551, 14643, 46614, 59071, 1807, 34888, 21861, 7874, 11775 +, 48700, 32381, 9936, 10706, 44775, 14022, 19633, 52878, 41109, 114, 45202, 23025, 1083, 27618, 30790 +, 48369, 14257, 42805, 48017, 21647, 32382, 13800, 27199, 23377, 36767, 26270, 25184, 11655, 24484, 33058 +, 59782, 13184, 41792, 46070, 243, 2919, 93, 19876, 32150, 17554, 56342, 17352, 16931, 57426, 21323 +, 47721, 22147, 11932, 30526, 10165, 33580, 39260, 317, 779, 2637, 37084, 3401, 4174, 25091, 27885 +, 13584, 1225, 17422, 55376, 47296, 17665, 34648, 23741, 13893, 6798, 41295, 10236, 502, 58226, 44014 +, 21825, 22299, 6161, 33758, 29177, 16326, 7338, 8437, 16644, 44469, 11074, 30080, 47870, 51600, 31524 +, 52108, 5185, 32749, 45882, 561, 56397, 3547, 11561, 20138, 53792, 54711, 37785, 4028, 55214, 36011 +, 24394, 17039, 58310, 30556, 27149, 3839, 23234, 10839, 12276, 39878, 55308, 59703, 46311, 43179, 51303 +, 54187, 11639, 56488, 3288, 57521, 33402, 59686, 1068, 44963, 56176, 31212, 39675, 33962, 35241, 11241 +, 46325, 59635, 28280, 20988, 6543, 31782, 24827, 29778, 42621, 37104, 46008, 37930, 13159, 32319, 57461 +, 4462, 2858, 9100, 951, 6147, 6621, 10705, 42185, 44041, 32020, 38361, 15253, 48047, 12323, 26846 +, 59288, 35001, 2834, 27569, 55989, 9377, 35703, 20816, 15507, 18324, 34272, 1516, 56254, 47431, 10187 +, 53715, 28246, 13046, 2815, 29197, 19193, 9436, 16254, 37730, 29829, 48274, 16091, 45083, 36322, 4767 +, 48281, 35610, 39768, 51115, 39531, 12109, 36845, 15234, 9277, 52352, 33559, 43550, 53868, 6165, 7333 +, 40408, 59881, 35579, 29806, 39048, 41128, 48999, 24837, 57382, 26729, 54666, 22009, 19172, 16101, 58331 +, 23939, 4383, 10293, 40059, 55498, 49825, 52168, 8695, 41411, 1446, 1048, 51322, 21348, 31268, 57488 +, 28681, 48028, 33721, 40613, 17834, 12769, 21741, 43185, 13958, 19124, 46266, 8625, 17485, 5439, 24726 +, 15816, 5730, 29109, 26109, 45790, 960, 52286, 14310, 9655, 10050, 52108, 47055, 37724, 49808, 18324 +, 35212, 18490, 42704, 45285, 35455, 539, 34407, 57196, 43724, 48365, 52672, 29991, 56990, 10157, 35430 +, 58069, 2325, 17512, 3530, 4787, 39654, 4490, 57073, 53965, 14146, 43475, 22425, 37553, 21200, 12234 +, 32229, 32764, 7076, 14934, 18050, 42531, 15473, 28809, 39727, 59197, 17174, 8752, 29188, 50517, 18909 +, 40970, 24938, 21235, 58483, 28468, 26022, 38137, 32959, 59447, 8454, 23457, 19275, 30880, 1010, 16827 +, 19466, 33240, 49591, 26542, 48174, 43993, 9073, 39999, 12802, 25152, 39196, 6329, 33904, 44737, 33198 +, 29166, 25707, 58136, 26753, 542, 26604, 52775, 15032, 35915, 28574, 23486, 35724, 24201, 30718, 36735 +, 41028, 50184, 46327, 30620, 16726, 10853, 50965, 2151, 50852, 40120, 27304, 6400, 46449, 37560, 27489 +, 55999, 6726, 29549, 54135, 33479, 30091, 57091, 2606, 45123, 33007, 7533, 44962, 8731, 31734, 15680 +, 21818, 12763, 42217, 44497, 19735, 58943, 31702, 10700, 37447, 58906, 50820, 41103, 5307, 13621, 18663 +, 32796, 9620, 1742, 38697, 40107, 11573, 8789, 37199, 50532, 30264, 10206, 34417, 51578, 55289, 6151 +, 43611, 53460, 55266, 25828, 37957, 15001, 1123, 9660, 2054, 38570, 8566, 29226, 19673, 50225, 42848 +, 38337, 59374, 28820, 16431, 38071, 8928, 28004, 23212, 46127, 18536, 53477, 32685, 52953, 21407, 4326 +, 35457, 5018, 57786, 7075, 30846, 35744, 58429, 31970, 21756, 483, 46892, 30322, 6061, 6566, 56900 +, 25261, 21255, 56274, 54082, 37686, 10697, 39362, 42042, 33910, 1841, 36931, 3739, 34526, 6236, 25146 +, 15204, 18045, 30165, 12991, 25121, 37363, 25087, 23550, 45685, 46843, 385, 32578, 53517, 6446, 39144 +, 50417, 31708, 399, 23043, 2142, 14437, 33741, 41504, 32831, 44003, 43345, 9762, 47742, 54223, 15999 +, 49240, 9427, 34044, 55757, 58770, 35517, 33121, 23857, 59067, 55158, 10700, 35804, 27736, 40570, 42251 +, 6880, 30987, 50311, 43631, 30383, 52453, 34420, 40476, 10309, 7252, 831, 30006, 17014, 24925, 24229 +, 9365, 14165, 10008, 19762, 46275, 8779, 55279, 55748, 32636, 30699, 50906, 19689, 6503, 18643, 259 +, 25106, 1875, 7598, 51769, 45507, 14333, 44222, 56279, 54809, 30883, 39883, 31992, 889, 33250, 56917 +, 1470, 42615, 11083, 11479, 38729, 57358, 56610, 10361, 29458, 5598, 17412, 20364, 1639, 267, 39007 +, 1898, 25374, 40883, 45849, 17143, 2742, 182, 37718, 35373, 31344, 8601, 15257, 3336, 45843, 48507 +, 254, 23665, 7474, 47689, 35144, 46204, 21399, 8106, 32917, 50857, 13705, 50329, 11221, 15344, 50596 +, 26581, 53595, 15970, 7464, 15796, 9466, 46558, 15978, 23536, 21931, 23674, 8489, 37188, 3363, 54332 +, 2047, 39969, 17998, 9522, 27658, 29494, 55726, 25409, 13953, 28643, 52618, 4010, 55324, 40191, 19354 +, 45920, 6772, 49301, 38243, 50588, 5097, 47709, 37146, 57428, 11245, 35430, 21102, 56086, 48970, 817 +, 50419, 51018, 40786, 44769, 540, 44796, 14263, 32618, 10205, 4568, 37613, 39175, 8578, 32937, 19367 +, 27933, 18857, 2491, 53586, 33452, 53080, 35036, 57513, 6578, 32464, 45110, 18360, 29918, 41197, 7331 +, 30736, 31616, 58349, 11522, 52737, 35241, 56319, 43352, 7859, 42876, 47921, 45472, 58404, 56499, 54761 +, 54123, 784, 13618, 56614, 54371, 23423, 26046, 29407, 20936, 32625, 38223, 6047, 27337, 8141, 47244 +, 34668, 15229, 55212, 9369, 26752, 47949, 20962, 59423, 7653, 28821, 18651, 55574, 50645, 53407, 52074 +, 45406, 47530, 29210, 35377, 44145, 59933, 58800, 10191, 5692, 56088, 19168, 43915, 2135, 46506, 28409 +, 25731, 57526, 43638, 57295, 43248, 46742, 45244, 4210, 22517, 29250, 9384, 17521, 24824, 29, 10928 +, 53250, 21788, 58459, 22461, 57165, 42604, 22394, 32317, 29147, 28087, 28405, 24668, 48354, 6893, 47526 +, 16763, 32624, 45052, 36754, 29920, 4652, 23496, 51516, 8863, 46014, 20766, 18247, 3535, 21943, 18276 +, 14463, 15193, 40064, 49274, 14006, 13581, 8230, 36401, 45898, 37378, 40840, 50656, 38398, 29194, 57549 +, 25924, 22310, 6525, 10976, 59064, 12797, 15629, 58912, 40666, 844, 21278, 1432, 19091, 24813, 59727 +, 13719, 15629, 51273, 30136, 4903, 5279, 43717, 49486, 18032, 5968, 26864, 58872, 56624, 41614, 4419 +, 30525, 7538, 3081, 37050, 54866, 38497, 49848, 46847, 37409, 30514, 47691, 58688, 8298, 43134, 59853 +, 44378, 56854, 51834, 35651, 26990, 33090, 40930, 47059, 22576, 35315, 53027, 25792, 34187, 26003, 7406 +, 14958, 56528, 14944, 54391, 9931, 9810, 32888, 36131, 33010, 46650, 42997, 20701, 45338, 27647, 3836 +, 21543, 12025, 37042, 13378, 24028, 4032, 46468, 41311, 27443, 45396, 16626, 56823, 11188, 27165, 59178 +, 18594, 18476, 32059, 9890, 12867, 41990, 56052, 22108, 54473, 29062, 8758, 37470, 26116, 30448, 41469 +, 29952, 51991, 29847, 6994, 41721, 53875, 47378, 4541, 11538, 51173, 49937, 28164, 47996, 1125, 55330 +, 47175, 56071, 13806, 19234, 42313, 3025, 37576, 14718, 25133, 32049, 43780, 33891, 45871, 9896, 4339 +, 3692, 16200, 32683, 33539, 59546, 14404, 3767, 23276, 18946, 15305, 14450, 45235, 19822, 38798, 22713 +, 15152, 2325, 55136, 5310, 57911, 37450, 8335, 11839, 52168, 33469, 20240, 12300, 43712, 6111, 58549 +, 24404, 46156, 14749, 57087, 19695, 50648, 47843, 59814, 13924, 6789, 15120, 4726, 28377, 34942, 19877 +, 51090, 26446, 58554, 46226, 8108, 56466, 28, 16443, 8305, 52196, 26264, 4898, 40849, 46329, 11009 +, 39398, 10733, 57165, 54147, 7820, 53213, 21147, 55663, 53027, 35072, 38805, 44499, 16150, 43534, 55793 +, 12379, 34624, 58591, 10934, 57202, 6699, 43752, 57231, 59495, 28409, 25779, 2111, 33307, 6628, 48440 +, 20669, 46026, 35525, 17834, 16526, 43345, 47399, 37673, 15361, 16779, 49097, 30518, 37630, 41600, 14052 +, 9776, 53979, 25028, 8367, 4913, 22230, 51419, 25017, 55813, 50914, 53427, 57945, 29377, 26734, 4573 +, 17818, 47403, 26952, 29695, 41590, 19830, 13041, 28989, 33855, 4754, 22120, 59305, 11624, 59751, 40905 +, 25676, 9527, 34884, 27056, 54246, 16150, 25638, 45665, 41167, 21452, 36579, 10946, 55749, 5957, 37681 +, 36674, 127, 1436, 3626, 29822, 43026, 59808, 19215, 48368, 33664, 321, 10488, 32969, 11945, 46591 +, 50226, 13973, 32470, 1462, 41029, 26717, 53964, 43020, 12382, 35132, 4472, 25314, 22430, 36573, 7623 +, 111, 13247, 44102, 1548, 16874, 50276, 20926, 53034, 9492, 9294, 3050, 46165, 56135, 12371, 58111 +, 19078, 2597, 48436, 27901, 4060, 5818, 54618, 58024, 48838, 43352, 9508, 29662, 45018, 31939, 6235 +, 28993, 8402, 19482, 13095, 46302, 12708, 3372, 7229, 5743, 49216, 52875, 8793, 35381, 25362, 21165 +, 9844, 44441, 114, 34633, 12342, 4174, 40451, 43312, 2199, 29289, 3016, 48059, 58951, 48035, 56350 +, 41538, 17028, 4753, 1020, 6476, 51055, 13729, 46200, 34636, 55824, 11768, 27512, 40969, 23501, 52874 +, 38486, 33346, 13667, 38601, 44331, 26009, 42775, 24782, 45673, 21326, 30423, 48690, 45738, 5726, 13077 +, 42088, 47264, 6457, 46841, 48284, 12933, 14249, 38365, 35485, 48885, 10541, 47253, 52749, 51511, 10755 +, 21976, 29997, 20453, 35643, 8598, 4784, 38005, 27726, 5918, 30, 25404, 36341, 48720, 11142, 42067 +, 1797, 53231, 29331, 8255, 40072, 53967, 57540, 54321, 8685, 33026, 19559, 19226, 56631, 12308, 10737 +, 43738, 10636, 17087, 4191, 46280, 25685, 45327, 637, 29763, 51245, 667, 55168, 3938, 25740, 6310 +, 46005, 27537, 59541, 51688, 12144, 15966, 45656, 9685, 10287, 30693, 19063, 6198, 49919, 52046, 54859 +, 37009, 35785, 5495, 54096, 39976, 28127, 19781, 1656, 5116, 25897, 29253, 5784, 21065, 33192, 7876 +, 27375, 19197, 35413, 26917, 47238, 23910, 42883, 9246, 9947, 29522, 39939, 29010, 12073, 29858, 57408 +, 6932, 6867, 33193, 48779, 963, 49522, 53259, 57097, 51178, 58375, 22994, 20431, 40511, 20411, 29975 +, 48387, 47786, 25525, 153, 51055, 12763, 24063, 10290, 22009, 34010, 16165, 1948, 39372, 28238, 8158 +, 36780, 11522, 15026, 46326, 36653, 52341, 35848, 29912, 25790, 3378, 4640, 25136, 161, 45151, 45547 +, 30137, 9891, 9686, 55662, 10044, 741, 44777, 10459, 47384, 6786, 44469, 3549, 45086, 193, 8139 +, 29596, 13325, 56013, 44622, 59651, 9018, 13316, 11851, 15283, 15458, 15229, 19923, 40595, 15391, 41426 +, 2494, 45528, 51317, 12180, 17542, 1361, 49274, 2319, 11820, 36658, 45457, 32641, 16559, 6895, 9186 +, 1050, 36491, 22512, 33415, 57466, 58515, 42433, 10782, 10367, 57716, 26240, 25596, 17639, 43187, 17339 +, 35418, 45682, 2867, 26735, 34214, 56761, 4449, 23488, 59080, 52621, 36498, 20889, 25263, 53057, 27784 +, 10801, 30459, 40628, 9665, 3874, 38094, 8181, 22660, 25228, 54900, 56728, 27820, 56848, 50720, 11008 +, 14188, 26138, 33042, 17055, 52873, 7256, 50169, 57322, 30745, 49249, 49944, 7243, 46491, 51559, 36653 +, 50627, 2360, 43464, 31255, 12026, 23691, 9349, 56559, 46351, 34577, 51459, 19431, 2398, 24659, 10151 +, 49758, 38847, 36289, 22800, 32255, 5515, 30056, 22424, 2837, 37153, 48025, 29133, 20749, 34516, 20692 +, 57402, 25144, 59405, 17218, 32751, 47783, 40909, 42101, 44342, 3612, 53030, 12153, 23044, 31780, 36812 +, 33195, 21538, 52012, 45837, 20690, 24267, 51352, 27099, 46691, 54189, 4252, 34716, 59675, 25001, 45585 +, 56719, 58755, 47081, 56124, 15974, 19832, 20259, 56883, 38285, 40953, 496, 31316, 29458, 23540, 39448 +, 42623, 33087, 37339, 34635, 18924, 58029, 58902, 10276, 25128, 21945, 40818, 5733, 56661, 16845, 30734 +, 42246, 13564, 29490, 5679, 46041, 45464, 25512, 6300, 18699, 3797, 23606, 19195, 11465, 53064, 19087 +, 27266, 35687, 52175, 4605, 10322, 47451, 2634, 45576, 34080, 4115, 7521, 14898, 9848, 40535, 8095 +, 16934, 59133, 21659, 46424, 4813, 44052, 8240, 30325, 50353, 26940, 10474, 13959, 22487, 58292, 43375 +, 41575, 25558, 19063, 10102, 30163, 5737, 33905, 9149, 27666, 7985, 49616, 11539, 59235, 35816, 52074 +, 7330, 52751, 27560, 5342, 39175, 32373, 49394, 23768, 39050, 39747, 50708, 49524, 30058, 13195, 24168 +, 13434, 31122, 49726, 8849, 17576, 56241, 50938, 51482, 41743, 18604, 59467, 7711, 6496, 58703, 43528 +, 58570, 42385, 36279, 26130, 47727, 51806, 34855, 37122, 15574, 13905, 16869, 42634, 39782, 23280, 32182 +, 3950, 13066, 3304, 30029, 58267, 20881, 2622, 49205, 48715, 20717, 44162, 48182, 28429, 50658, 23237 +, 11957, 49228, 5623, 24588, 51711, 53350, 16394, 26566, 30472, 8321, 16824, 23694, 27307, 56606, 46974 +, 35841, 36908, 36392, 15498, 6937, 34659, 36379, 45912, 23864, 25094, 6629, 44378, 49628, 35058, 35036 +, 12866, 23367, 617, 18489, 47955, 52328, 11839, 40702, 55246, 18664, 25375, 12070, 42358, 52682, 45028 +, 5684, 4876, 21937, 42076, 20374, 5226, 53087, 33105, 51138, 53303, 34551, 57768, 37682, 24179, 9178 +, 12718, 37045, 32546, 13335, 31886, 20501, 42015, 20078, 37555, 37262, 38742, 2930, 25684, 57452, 31965 +, 10713, 39488, 36841, 9002, 57916, 57215, 14228, 51003, 30320, 41719, 44306, 4871, 15839, 21988, 29050 +, 25017, 11059, 42448, 33915, 24394, 50686, 54417, 42762, 10764, 8324, 20024, 25858, 11255, 22060, 59662 +, 43220, 32773, 39150, 56413, 18127, 37066, 53628, 32356, 4421, 300, 14075, 48728, 5171, 29914, 47068 +, 10573, 31283, 58127, 29373, 5199, 58874, 20060, 35968, 41636, 7176, 44292, 38012, 9387, 55547, 72 +, 9049, 15119, 9198, 48200, 11532, 27325, 1618, 41512, 59681, 6040, 41812, 50108, 31120, 23335, 20022 +, 18188, 10261, 27658, 52668, 39634, 32857, 51542, 36046, 8825, 33178, 43223, 53117, 11190, 28962, 25017 +, 11262, 38011, 40136, 56812, 2563, 28021, 24138, 4182, 45885, 171, 10222, 27698, 50280, 17694, 27385 +, 46654, 35882, 37646, 14312, 28550, 17281, 47169, 20092, 29679, 32346, 29622, 12902, 25464, 40812, 18216 +, 50481, 28427, 56228, 6969, 25239, 58791, 34990, 25729, 39325, 20876, 25901, 25899, 24926, 52533, 43593 +, 28663, 39187, 55828, 6310, 29852, 24378, 59943, 53373, 20823, 29622, 25720, 26797, 18877, 27536, 7610 +, 37093, 18017, 12389, 33321, 24986, 13980, 8465, 36329, 39710, 47790, 33557, 5611, 13690, 34835, 58144 +, 33635, 3498, 13683, 29463, 9808, 19887, 30194, 9751, 49613, 51017, 15726, 51685, 54166, 34603, 19221 +, 38128, 11696, 37238, 50517, 21370, 38576, 4498, 6187, 14905, 44208, 53977, 24814, 26171, 44019, 59649 +, 667, 17655, 3148, 50702, 23470, 12956, 10590, 53664, 59060, 36555, 21033, 51138, 28240, 15200, 25741 +, 47461, 53328, 13789, 1051, 20198, 11511, 39627, 24696, 17698, 30885, 45256, 48028, 55699, 47779, 32047 +, 55349, 48446, 26054, 58497, 15500, 25877, 47805, 26090, 19541, 23217, 38997, 16927, 14355, 7237, 32127 +, 16448, 54698, 1807, 6590, 55749, 22005, 18101, 11729, 23053, 35800, 42614, 44661, 23828, 38313, 8792 +, 32227, 10014, 33590, 34634, 44863, 49091, 511, 32669, 51533, 20052, 32238, 30531, 13331, 22946, 37768 +, 45458, 39394, 8819, 23618, 45984, 4568, 21975, 4086, 52649, 21381, 16238, 35263, 6042, 16418, 49929 +, 51187, 48645, 59943, 24777, 23279, 21159, 13868, 23790, 53828, 5402, 20195, 2418, 35933, 33526, 25364 +, 13701, 55337, 4759, 58872, 55307, 27095, 3441, 17282, 7533, 32442, 38663, 23771, 7706, 21058, 16541 +, 33987, 12245, 5187, 10282, 37022, 4818, 31441, 50891, 4961, 1621, 32645, 1508, 4040, 8578, 11386 +, 29404, 58631, 6723, 10515, 57504, 2030, 13963, 37297, 55665, 21496, 9739, 34328, 21620, 53797, 31738 +, 38161, 27784, 43983, 19700, 38067, 57358, 24519, 9508, 48249, 29480, 11130, 20894, 7340, 51522, 5824 +, 18726, 57278, 4455, 25450, 7794, 38311, 3832, 58109, 51960, 59497, 19605, 1700, 10178, 17577, 55497 +, 41916, 32091, 59634, 2252, 51791, 37701, 59610, 52662, 23561, 24211, 22142, 11043, 21457, 5834, 2565 +, 27281, 24561, 59844, 8088, 50011, 43990, 22752, 30195, 42099, 14712, 6045, 38056, 52764, 52575, 55634 +, 24614, 34491, 4077, 24248, 13095, 55868, 38301, 12705, 48531, 1862, 13268, 47025, 12906, 34725, 52860 +, 51823, 38358, 17421, 51667, 46447, 43784, 35657, 45551, 50331, 54108, 263, 56376, 32165, 53028, 25303 +, 4151, 17642, 36147, 8228, 18242, 49242, 40448, 56543, 38300, 28979, 34757, 51568, 52357, 47663, 26294 +, 45217, 15839, 4652, 38990, 7506, 27451, 59126, 19516, 13002, 49457, 49976, 49618, 22186, 58493, 42646 +, 47489, 2644, 36640, 23636, 47224, 54882, 12879, 27673, 51425, 27531, 33004, 26182, 19099, 25361, 50198 +, 21745, 46930, 42389, 2750, 25920, 49895, 30201, 25046, 45763, 19556, 50856, 12092, 9174, 13042, 10585 +, 51820, 36883, 49582, 4812, 520, 36806, 59694, 49751, 4479, 27471, 17282, 37484, 30005, 12733, 39197 +, 56555, 34479, 26128, 38944, 13581, 28400, 5192, 43782, 29799, 27307, 39690, 20655, 39399, 48864, 10049 +, 26337, 17036, 46932, 15919, 21848, 23804, 52725, 57894, 13555, 33557, 1717, 7189, 47393, 8075, 56275 +, 26590, 4630, 7106, 29070, 19927, 20687, 57471, 25119, 40821, 27270, 52426, 20512, 24277, 8178, 9376 +, 34326, 34515, 2765, 57610, 50434, 965, 21415, 19511, 35212, 11322, 53068, 36929, 54864, 40461, 45004 +, 27491, 43404, 25987, 34597, 12474, 45914, 55284, 46297, 11033, 36105, 49919, 39811, 32969, 14196, 24341 +, 18698, 24874, 58856, 21463, 58837, 25642, 58780, 56604, 21506, 33992, 44278, 14574, 10922, 39142, 31388 +, 32278, 42985, 51144, 58265, 17582, 39970, 44179, 49218, 26268, 31564, 25324, 16187, 47728, 34645, 6736 +, 12069, 53343, 7962, 47278, 51158, 6799, 49272, 49939, 39755, 10778, 23931, 24034, 1705, 34853, 39528 +, 9445, 43484, 22514, 589, 18101, 40096, 40559, 2281, 29315, 43179, 10197, 30991, 35719, 57925, 5636 +, 42455, 46347, 58980, 26769, 33625, 26490, 9921, 22897, 16429, 49676, 10028, 40361, 13710, 11733, 51566 +, 53239, 21178, 35050, 15753, 21767, 53152, 32201, 38678, 31785, 1516, 58210, 18334, 8859, 33929, 52612 +, 14496, 52736, 38959, 49828, 19505, 48936, 16318, 29426, 48185, 32748, 19103, 58213, 49461, 9165, 9946 +, 41027, 2404, 31124, 52430, 54509, 29243, 45582, 26711, 44274, 53719, 4579, 42484, 48405, 13439, 16413 +, 41017, 27935, 9149, 19976, 54115, 5006, 45264, 10433, 10785, 33450, 19533, 6240, 31663, 8994, 15405 +, 41610, 26374, 54162, 49086, 18804, 48671, 54682, 40738, 15382, 38956, 10809, 56314, 21440, 59214, 9753 +, 14205, 40232, 14040, 59706, 36560, 8155, 41064, 21825, 54940, 51849, 31627, 50826, 58089, 3290, 59820 +, 13495, 21252, 2546, 7657, 46691, 21350, 32680, 41373, 2088, 24415, 20329, 12897, 20729, 18121, 12112 +, 30482, 32326, 28696, 44522, 8384, 5256, 29029, 49448, 3433, 23969, 41298, 35060, 14795, 15739, 14703 +, 50968, 29234, 35955, 53514, 13243, 22646, 51217, 22276, 4019, 53305, 46691, 700, 42555, 7420, 18821 +, 31019, 14254, 27499, 36067, 35128, 35883, 41323, 4157, 25332, 21109, 4478, 42982, 56169, 55626, 58721 +, 10872, 46594, 4308, 23180, 16460, 17551, 45826, 7677, 16179, 26198, 37335, 2870, 26898, 56242, 46642 +, 45720, 27261, 37248, 49571, 3328, 12376, 25455, 21003, 16533, 27139, 42112, 57364, 10121, 14634, 52990 +, 8842, 1858, 39584, 13150, 25038, 32396, 7054, 47217, 40074, 23233, 13415, 53761, 2456, 40313, 50003 +, 49098, 2385, 53616, 26347, 51957, 56944, 15075, 53764, 54299, 7961, 20903, 12764, 5325, 31024, 3750 +, 58315, 39866, 5608, 14251, 29369, 6999, 46647, 36423, 54216, 3073, 36008, 43983, 33186, 38464, 24296 +, 23189, 27563, 3034, 16805, 30262, 31343, 50101, 45337, 25107, 20753, 53298, 46010, 33517, 34975, 53386 +, 37267, 33290, 9604, 19227, 23893, 38973, 26226, 46893, 51748, 20442, 49966, 27757, 4425, 59505, 6221 +, 5074, 22694, 10136, 44460, 15852, 40398, 52155, 42305, 2088, 17262, 3058, 31738, 39624, 12927, 6714 +, 9362, 50194, 16356, 18966, 45774, 40250, 57940, 12000, 27143, 26040, 8795, 53461, 53797, 49572, 52966 +, 19, 30998, 52013, 46507, 15458, 7865, 3258, 7613, 26522, 5346, 1227, 29581, 13436, 17203, 18860 +, 20150, 2917, 45407, 36507, 21884, 31181, 53109, 56176, 43181, 20252, 22216, 28328, 50065, 52366, 17901 +, 43032, 28737, 48899, 11397, 15244, 40710, 55614, 18502, 24675, 22136, 200, 2255, 28069, 49989, 55810 +, 46930, 10139, 58728, 32337, 22998, 20612, 39870, 52459, 53140, 59403, 49063, 15356, 27732, 39129, 7722 +, 45633, 22161, 36459, 10884, 9910, 28056, 51594, 5524, 22910, 16270, 27660, 23111, 54877, 55730, 13100 +, 50687, 19012, 59591, 49415, 27701, 58942, 46379, 7571, 27753, 39519, 43326, 16817, 31228, 11058, 55946 +, 15302, 33043, 54459, 28114, 43928, 4369, 56170, 11874, 9893, 19080, 4496, 13905, 18543, 59373, 9635 +, 7995, 50061, 4999, 43939, 39476, 32700, 19233, 25856, 16623, 46986, 41727, 59950, 3803, 12955, 47360 +, 59749, 28258, 20404, 54208, 56372, 40684, 34929, 28894, 52558, 44822, 24326, 33407, 58728, 42870, 32780 +, 44715, 27217, 22841, 26067, 11156, 38670, 35119, 30389, 40878, 28095, 17376, 22605, 4397, 57531, 11913 +, 51757, 57281, 40171, 48513, 27841, 12895, 5549, 39123, 18141, 58108, 23945, 42467, 31515, 59025, 1689 +, 40647, 20093, 28907, 39841, 46160, 40063, 18511, 57631, 46805, 35741, 25726, 4181, 34698, 30123, 38064 +, 46611, 58233, 35345, 3134, 46746, 39539, 16029, 52296, 18662, 10522, 26756, 18959, 52990, 34623, 54337 +, 54679, 15270, 50782, 59938, 31463, 13294, 40002, 26326, 10925, 3159, 2067, 36652, 43692, 36766, 43127 +, 21756, 23377, 41360, 57102, 26512, 4459, 12993, 18893, 56755, 8007, 5768, 59863, 26966, 58758, 34486 +, 57655, 29789, 26108, 48437, 6080, 33924, 1731, 46082, 250, 49009, 25593, 2318, 2013, 9285, 15436 +, 45140, 31041, 15165, 26501, 4495, 41677, 7312, 17488, 36923, 4067, 25495, 42691, 40282, 28814, 17801 +, 51120, 2821, 23942, 53580, 51259, 30022, 27504, 29342, 52456, 27755, 54703, 18049, 6425, 56716, 27334 +, 21861, 41857, 58376, 37026, 44710, 2871, 55056, 52022, 56712, 8331, 32441, 58559, 51022, 12723, 27373 +, 45175, 40195, 6547, 9117, 33775, 34158, 39140, 1280, 3500, 7948, 29035, 58204, 25998, 11812, 31272 +, 29684, 33673, 13129, 28060, 47051, 34191, 7284, 42107, 26213, 3996, 50438, 35006, 2555, 17812, 24081 +, 6281, 2987, 4276, 12828, 48457, 38052, 23338, 27597, 15684, 26838, 11897, 21071, 1394, 37895, 32883 +, 32667, 7580, 42908, 22148, 11992, 29959, 56340, 19276, 48419, 58905, 59624, 15209, 10264, 2180, 33022 +, 34345, 44813, 12361, 38622, 33993, 818, 53026, 57331, 4767, 8710, 521, 16665, 29781, 38268, 54560 +, 39016, 10935, 38492, 21924, 9435, 50485, 51883, 42127, 46113, 16654, 41033, 45738, 31864, 27649, 24270 +, 41238, 1994, 9083, 53599, 16968, 43076, 54418, 9994, 40407, 35537, 55056, 40928, 52202, 1189, 19196 +, 23115, 40205, 6483, 1607, 2129, 52271, 28444, 30365, 34398, 50910, 47019, 51783, 36648, 18883, 19432 +, 918, 121, 57779, 46353, 30073, 14747, 29429, 843, 1094, 46188, 36380, 32502, 3468, 28583, 33692 +, 59017, 28050, 13897, 41852, 6009, 52379, 10475, 10806, 22744, 44874, 1716, 9763, 13009, 38364, 28647 +, 8794, 15634, 5120, 42925, 38339, 35193, 57672, 7768, 36036, 35118, 30308, 48769, 43973, 10128, 53704 +, 17665, 45497, 21754, 7914, 27350, 27763, 293, 37825, 38569, 23037, 59051, 16637, 32801, 48413, 31353 +, 37800, 33559, 46987, 19272, 16484, 25326, 30818, 50508, 9446, 6854, 25627, 16106, 31975, 9600, 2587 +, 25679, 3617, 48084, 47433, 11531, 15434, 51549, 11825, 29612, 6470, 11214, 5015, 23108, 20367, 53428 +, 54461, 58167, 26987, 17801, 53792, 43471, 19479, 24610, 10332, 5278, 7816, 35959, 57736, 39792, 21911 +, 323, 5471, 1880, 48408, 29257, 13411, 40194, 20806, 1588, 9806, 3628, 12803, 51174, 3088, 9522 +, 44602, 57550, 7690, 47942, 51703, 37834, 7765, 47534, 2444, 18097, 52812, 10260, 30408, 50549, 50052 +, 28671, 27224, 31876, 30551, 15632, 1133, 20315, 55827, 58291, 21903, 41985, 1919, 11058, 33159, 5008 +, 20581, 54114, 38910, 4623, 18408, 6965, 42457, 2525, 54499, 21253, 20623, 23664, 31513, 27383, 50565 +, 57918, 32407, 17789, 29794, 2958, 9774, 7279, 59625, 5601, 5570, 57881, 23938, 43841, 8939, 57098 +, 25201, 5872, 27564, 40463, 46847, 45972, 47428, 5656, 48497, 18280, 26909, 45472, 18296, 34775, 49208 +, 8861, 32693, 21615, 3002, 38839, 925, 12776, 46118, 551, 54729, 28040, 58432, 18668, 48233, 43723 +, 52118, 13435, 49596, 19682, 30250, 12795, 42006, 54031, 54804, 6855, 48663, 21713, 52328, 6959, 56488 +, 41536, 15820, 5533, 39503, 55174, 44372, 40428, 7951, 6842, 40979, 39032, 34882, 39411, 57700, 23116 +, 23135, 49818, 12903, 49083, 45852, 19505, 1878, 27858, 13536, 56682, 34714, 2199, 54748, 3394, 9158 +, 27588, 21282, 1330, 33122, 785, 32857, 53846, 41213, 17160, 689, 22193, 56192, 35571, 37956, 53893 +, 35039, 1091, 20063, 47942, 50174, 42268, 43800, 28405, 10126, 57336, 1439, 21192, 35888, 32539, 938 +, 21398, 128, 22220, 22729, 9602, 59357, 31938, 3448, 40571, 49098, 40489, 39116, 45290, 52413, 17072 +, 39183, 27452, 54516, 35599, 51747, 21042, 17867, 35547, 25799, 4345, 9235, 27239, 1890, 45123, 36130 +, 2828, 6522, 36258, 1401, 5603, 22212, 758, 37541, 2013, 17681, 26639, 42502, 56797, 11929, 11267 +, 50222, 27465, 38720, 21090, 39416, 6819, 42132, 57283, 18718, 7932, 1628, 27953, 11523, 39870, 49429 +, 47653, 42699, 55951, 264, 20452, 37906, 22476, 21210, 15447, 24489, 38892, 18438, 43344, 12041, 6719 +, 54611, 38615, 34184, 9683, 59705, 13600, 16502, 41838, 47235, 11572, 26122, 25216, 15878, 37645, 5086 +, 5307, 1650, 24137, 1258, 1914, 44589, 39164, 24391, 5800, 30963, 25232, 21044, 49401, 8576, 33085 +, 56120, 39540, 11701, 6657, 49223, 11406, 56609, 42078, 29596, 20197, 53650, 55718, 45413, 9528, 9715 +, 26851, 14835, 11366, 50989, 52445, 49632, 35578, 7961, 50375, 17730, 15276, 15608, 15126, 4677, 536 +, 24564, 37150, 40076, 12617, 20159, 5652, 24023, 16768, 47730, 29972, 36965, 17732, 2042, 58730, 27261 +, 11758, 25582, 18448, 59476, 52923, 47246, 49108, 4853, 31559, 39484, 58936, 46836, 31444, 14062, 27865 +, 31980, 38626, 5015, 48409, 51243, 1526, 54061, 51619, 18295, 18143, 21591, 31612, 35875, 59985, 6695 +, 39488, 11743, 8629, 34289, 47571, 1552, 21535, 36680, 6405, 53094, 52516, 5341, 39930, 23960, 55756 +, 44148, 32292, 34382, 49163, 20701, 1978, 50690, 51114, 53597, 45337, 45609, 51540, 53301, 21485, 51525 +, 36348, 37325, 39621, 44977, 11614, 27192, 22881, 9501, 40224, 5639, 2596, 32740, 47332, 18878, 56700 +, 43088, 3026, 28993, 53823, 28542, 26046, 55801, 55584, 53513, 49398, 17273, 39122, 17290, 46926, 36959 +, 45167, 23275, 14285, 24788, 44604, 2251, 28333, 7486, 11753, 44909, 13125, 14349, 17650, 457, 9579 +, 50702, 19898, 48958, 56047, 13721, 17500, 22094, 9522, 49436, 51959, 35272, 6709, 31081, 28914, 29987 +, 8041, 14081, 53262, 58678, 15222, 14219, 929, 19907, 21705, 12682, 4816, 11182, 3383, 58818, 47991 +, 49315, 49521, 7889, 38273, 45568, 57962, 32125, 44014, 43836, 21561, 35973, 55460, 4622, 7055, 24374 +, 34609, 51448, 14808, 4224, 26478, 6382, 18443, 27407, 26289, 16500, 16442, 7457, 4034, 56177, 6276 +, 28377, 45492, 55797, 36267, 23765, 41365, 10581, 55890, 1732, 54418, 17451, 37705, 49878, 58425, 21112 +, 50605, 33035, 12560, 5413, 13611, 39038, 11795, 8406, 42798, 14436, 1258, 59240, 58245, 5292, 55417 +, 4521, 10021, 40910, 36670, 46288, 4675, 18036, 33222, 36918, 56120, 27640, 54369, 33825, 53870, 29147 +], _), + +statistics, +statistics_jit. \ No newline at end of file diff --git a/JIT/examples/nsieve.pl b/JIT/examples/nsieve.pl new file mode 100644 index 000000000..b2f9a8331 --- /dev/null +++ b/JIT/examples/nsieve.pl @@ -0,0 +1,89 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% +% This is a slightly-modified version of the exising nsieve implementation +% differing only in the mechanism used to mimic array creation and +% access. This version [when compared to existing version]: +% +% * Makes only modest demands of the global stack, so should execute using +% default values, at least up to a load of N = 9. However, its heap +% memory demands make it prone to thrashing [existing version is more +% stable as long as a sufficiently large stack size is specified] +% +% * Execution times are on par at up to N = 6, then diverge quite +% dramatically [e.g. at N = 8 this version is roughly twice as fast as +% existing version] +% +% Contributed by Anthony Borla +% Modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- initialization(main). + +main :- + unix( argv([H|_]) ), number_atom(N,H), + + N1 is 10000 << N, + N2 is 10000 << (N - 1), + N3 is 10000 << (N - 2), + + calcAndshowSieve(N1), + calcAndshowSieve(N2), + calcAndshowSieve(N3), + + statistics, + statistics_jit. + +% ------------------------------- % + +calcAndshowSieve(N) :- + make_array(N, 1), + nsieve(2, N, 0, R), + format('Primes up to~t~w~21|~t~w~30|~n', [N, R]). + +% ------------------------------- % + +nsieve(ASize, ASize, R, R) :- !. +nsieve(N, ASize, A, R) :- + ( + is_slot(N) -> + clear_sieve(N, N, ASize), A1 is A + 1 + ; + A1 is A + ), + N1 is N + 1, !, + nsieve(N1, ASize, A1, R). + +% ------------- % + +clear_sieve(N, M, ASize) :- + N1 is N + M, clear_sieve_(N1, M, ASize). + +% ------------- % + +clear_sieve_(N, _, ASize) :- ASize < N, !. + +clear_sieve_(N, M, ASize) :- + clear_slot(N), + N1 is N + M, !, clear_sieve_(N1, M, ASize). + +% ------------------------------- % + +make_array(N, V) :- fill_array(N, V). + +% ------------- % + +fill_array(0, _) :- !. +fill_array(N, V) :- bb_put(N, V), N1 is N - 1, !, fill_array(N1, V). + +% ------------- % + +set_slot(N) :- bb_put(N, 1). +clear_slot(N) :- bb_put(N, 0). +is_slot(N) :- bb_get(N, 1). + +% ------------------------------- % + diff --git a/JIT/examples/nsieve_bits.pl b/JIT/examples/nsieve_bits.pl new file mode 100644 index 000000000..e7da9514d --- /dev/null +++ b/JIT/examples/nsieve_bits.pl @@ -0,0 +1,109 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% +% This is a modified version of the orignal 'nsieve.swiprolog' +% submission. Whilst that particular implementation made quite heavy +% demands of the global stack [owing to the creation of a very large +% array], the current version: +% +% * Requires an array approximately 1/32 the size since each array slot +% stores 32 encoded values [as opposed to a single value] +% +% * As expected, utilises bit twiddling for encoding / decoding values +% +% In short, while memory use is curbed, runtime suffers [a trading of +% speed for a saving in space as they say]. At a value of N = 9 runtime +% *should* be within the timeout period, but probably not by much +% +% Contributed by Anthony Borla +% Modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- initialization(main). + +main :- + unix( argv([H|_]) ), number_atom(N,H), + + N1 is 10000 << N, + N2 is 10000 << (N - 1), + N3 is 10000 << (N - 2), + + calcAndshowSieve(N1), + calcAndshowSieve(N2), + calcAndshowSieve(N3), + + statistics, + statistics_jit. + +% ------------------------------- % + +calcAndshowSieve(N) :- + make_array(ns, N, 0xffffffff, Array), + nsieve(2, Array, N, 0, R), + format('Primes up to~t~w~21|~t~w~30|~n', [N, R]). + +% ------------------------------- % + +nsieve(ASize, _, ASize, R, R) :- !. + +nsieve(N, Array, ASize, A, R) :- + ( + is_arg(N, Array) -> + clear_sieve(N, N, Array, ASize), A1 is A + 1 + ; + A1 is A + ), + N1 is N + 1, !, + nsieve(N1, Array, ASize, A1, R). + +% ------------- % + +clear_sieve(N, M, Array, ASize) :- + N1 is N + M, clear_sieve_(N1, M, Array, ASize). + +% ------------- % + +clear_sieve_(N, _, _, ASize) :- ASize < N, !. + +clear_sieve_(N, M, Array, ASize) :- + clear_arg(N, Array), + N1 is N + M, !, clear_sieve_(N1, M, Array, ASize). + +% ------------------------------- % + +array_slots(N, Slots) :- Slots is ((N + 15) >> 4) + 1. + +% ------------- % + +make_array(Name, N, V, Array) :- + array_slots(N, Slots), + functor(Array, Name, Slots), + fill_array(Slots, V, Array). + +% ------------- % + +fill_array(0, _, _) :- !. + +fill_array(N, V, Array) :- + setarg(N, Array, V), N1 is N - 1, !, + fill_array(N1, V, Array). + +% ------------- % + +clear_arg(N, Array) :- + Idx is (N >> 4) + 1, Value is (1 << (N /\ 15)), + arg(Idx, Array, OldValue), + Complement is \ Value, + NewValue is OldValue /\ Complement, + setarg(Idx, Array, NewValue). + +is_arg(N, Array) :- + Idx is (N >> 4) + 1, Value is 1 << (N /\ 15), + arg(Idx, Array, OldValue), + CurrentValue is OldValue /\ Value, + CurrentValue =\= 0. + +% ------------------------------- % diff --git a/JIT/examples/partial_sum.pl b/JIT/examples/partial_sum.pl new file mode 100644 index 000000000..ee6d3c5ba --- /dev/null +++ b/JIT/examples/partial_sum.pl @@ -0,0 +1,66 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% +% Based on D language implementation by David Fladebo +% Contributed by Anthony Borla +% Modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- initialization(main). + +main :- + unix( argv([H|_]) ), number_atom(N,H), + compute_sums(N, SUMS), + print_sums(SUMS), + + statistics, + statistics_jit. + +% ------------------------------- % + +compute_sums(N, SUMS) :- + SUMS0 = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + compute_sums_(1.0, N, 1.0, SUMS0, SUMS). + +% ------------- % + +compute_sums_(D, N, _, SUMS, SUMS) :- D > N, !. + +compute_sums_(D, N, ALT, SUMS0, SUMS) :- + SUMS0 = [A1, A2, A3, A4, A5, A6, A7, A8, A9], + + D2 is D * D, D3 is D2 * D, DS is sin(D), DC is cos(D), + + A1N is A1 + (2 / 3.0) ** (D - 1.0), + A2N is A2 + 1 / sqrt(D), + A3N is A3 + 1 / (D * (D + 1)), + A4N is A4 + 1 / (D3 * DS * DS), + A5N is A5 + 1 / (D3 * DC * DC), + A6N is A6 + 1 / D, + A7N is A7 + 1 / (D2), + A8N is A8 + ALT / D, + A9N is A9 + ALT / (2 * D - 1), + + SUMS1 = [A1N, A2N, A3N, A4N, A5N, A6N, A7N, A8N, A9N], + DN is D + 1.0, ALTN is -ALT, !, + compute_sums_(DN, N, ALTN, SUMS1, SUMS). + +% ------------------------------- % + +print_sums(SUMS) :- + SUMS = [A1, A2, A3, A4, A5, A6, A7, A8, A9], + + format('~9f\t~w\n', [A1, '(2/3)^k']), + format('~9f\t~w\n', [A2, 'k^-0.5']), + format('~9f\t~w\n', [A3, '1/k(k+1)']), + format('~9f\t~w\n', [A4, 'Flint Hills']), + format('~9f\t~w\n', [A5, 'Cookson Hills']), + format('~9f\t~w\n', [A6, 'Harmonic']), + format('~9f\t~w\n', [A7, 'Riemann Zeta']), + format('~9f\t~w\n', [A8, 'Alternating Harmonic']), + format('~9f\t~w\n', [A9, 'Gregory']). + +% ------------------------------- % diff --git a/JIT/examples/pidigits.pl b/JIT/examples/pidigits.pl new file mode 100644 index 000000000..f501e7a74 --- /dev/null +++ b/JIT/examples/pidigits.pl @@ -0,0 +1,57 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% Contributed by Anthony Borla +% Modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- initialization(main). + +main :- + transform_level(3), + unix( argv([H|_]) ), number_atom(N,H), + pidigits(N), + + statistics, + statistics_jit. + +% ------------------------------- % + +pidigits(N) :- pidigits_(1, [1, 0, 0, 1], N, 0, 0). + +% ------------- % + +pidigits_(K, Z, N, Row, Col) :- + (N > 0 -> + next(Z, Y), safe(Z, Y, IsSafe), + (IsSafe -> + prod(Z, Y, RL), N1 is N - 1, + (Col =:= 10 -> + Cf is 1, Rf is 10 + Row, format('\t:~w\n~w', [Rf, Y]) + ; + Cf is 1 + Col, Rf is Row, format('~w', [Y])), + !, pidigits_(K, RL, N1, Rf, Cf) + ; + cons(Z, K, RL), K1 is K + 1, + !, pidigits_(K1, RL, N, Row, Col)) + ; + NS is 10 - Col, tab(NS), RC is Row + Col, format('\t:~w\n', [RC])). + +% ------------- % + +next([Q, R, S, T], RV) :- RV is (3 * Q + R) // (3 * S + T). + +safe([Q, R, S, T], N, RV) :- + V is ((4 * Q + R) // (4 * S + T)), (V =:= N -> RV = true ; RV = fail). + +comp([Q1, R1, S1, T1], [Q2, R2, S2, T2], [QO, RO, SO, TO]) :- + QO is Q1 * Q2 + R1 * S2, RO is Q1 * R2 + R1 * T2, + SO is S1 * Q2 + T1 * S2, TO is S1 * R2 + T1 * T2. + +prod(Z, N, RL) :- A2 is -10 * N, comp([10, A2, 0, 1], Z, RL). + +cons(Z, K, RL) :- A2 is 4 * K + 2, A4 is 2 * K + 1, comp(Z, [K, A2, 0, A4], RL). + +% ------------------------------- % diff --git a/JIT/examples/query.pl b/JIT/examples/query.pl new file mode 100644 index 000000000..1581fb54e --- /dev/null +++ b/JIT/examples/query.pl @@ -0,0 +1,87 @@ +% generated: 17 November 1989 +% option(s): SOURCE_TRANSFORM_1 +% +% query +% +% David H. D. Warren +% +% query population and area database to find coun- +% tries of approximately equal population density + +q:- statistics(runtime,[S|_]), + query, + statistics(runtime,[S1|_]), Y is S1-S, + write('time : '), write(Y), nl, + true. + +test :- query. + +query :- query(_), fail. +query. + +query([C1,D1,C2,D2]) :- + density(C1,D1), + density(C2,D2), + D1 > D2, + T1 is 20*D1, + T2 is 21*D2, + T1 < T2. + +density(C,D) :- + pop(C,P), + area(C,A), + D is (P*100)//A. + +% populations in 100000's +pop(china, 8250). +pop(india, 5863). +pop(ussr, 2521). +pop(usa, 2119). +pop(indonesia, 1276). +pop(japan, 1097). +pop(brazil, 1042). +pop(bangladesh, 750). +pop(pakistan, 682). +pop(w_germany, 620). +pop(nigeria, 613). +pop(mexico, 581). +pop(uk, 559). +pop(italy, 554). +pop(france, 525). +pop(philippines, 415). +pop(thailand, 410). +pop(turkey, 383). +pop(egypt, 364). +pop(spain, 352). +pop(poland, 337). +pop(s_korea, 335). +pop(iran, 320). +pop(ethiopia, 272). +pop(argentina, 251). + +% areas in 1000's of square miles +area(china, 3380). +area(india, 1139). +area(ussr, 8708). +area(usa, 3609). +area(indonesia, 570). +area(japan, 148). +area(brazil, 3288). +area(bangladesh, 55). +area(pakistan, 311). +area(w_germany, 96). +area(nigeria, 373). +area(mexico, 764). +area(uk, 86). +area(italy, 116). +area(france, 213). +area(philippines, 90). +area(thailand, 200). +area(turkey, 296). +area(egypt, 386). +area(spain, 190). +area(poland, 121). +area(s_korea, 37). +area(iran, 628). +area(ethiopia, 350). +area(argentina, 1080). diff --git a/JIT/examples/recursive.pl b/JIT/examples/recursive.pl new file mode 100644 index 000000000..faaa965cd --- /dev/null +++ b/JIT/examples/recursive.pl @@ -0,0 +1,71 @@ +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% SWI-Prolog contributed by Anthony Borla, Christoph Bauer +% converted to YAP by Isaac Gouy + + +:- initialization(main). + +ack(0, N, Val) :- Val is N + 1, !. +ack(M, 0, Val) :- M1 is M - 1, ack(M1, 1, Val), !. +ack(M, N, Val) :- + M1 is M - 1, N1 is N - 1, + ack(M, N1, Val1), ack(M1, Val1, Val). + + +fib(0, 1) :- !. +fib(1, 1) :- !. +fib(N, Val) :- + N > 1, + N1 is N-1, + N2 is N1-1, + fib(N2, Val2), + fib(N1, Val1), + Val is Val1 + Val2. + +fib_float(1.0, 1.0) :- !. +fib_float(0.0, 1.0) :- !. +fib_float(N, Val) :- + N > 1, + N1 is N-1, + N2 is N1-1, + fib_float(N2, Val2), + fib_float(N1, Val1), + Val is Val1 + Val2. + + +tak(X, Y, Z, R) :- + Y < X, + X1 is X-1, + Y1 is Y-1, + Z1 is Z-1, + tak(X1, Y, Z, A), + tak(Y1, Z, X, B), + tak(Z1, X, Y, C), + tak(A, B, C, R), !. + +tak(_, _, Z, Z). + + +main :- + unix( argv([H|_]) ), number_atom(A,H), + B is A-1, + C is 27.0 + A, + write('Ack(3,'), write(A), write('): '), + ack(3, A, Val),!, + write(Val), nl, + write('Fib('), write(C), write('): '), fib_float(C,V), format('~1f', V), nl, !, + X is 3*B, + Y is 2*B, + Z is B, + write('Tak('), write(X), write(','), write(Y), write(','), write(Z), write('): '), + tak(X,Y,Z,R), + write(R), nl, + write('Fib(3): '), fib(3,V1), write(V1), nl, + write('Tak(3.0,2.0,1.0): '), + tak(3.0,2.0,1.0,FR), + format('~1f', FR), nl, + + statistics, + statistics_jit. + diff --git a/JIT/examples/spectral_norm.pl b/JIT/examples/spectral_norm.pl new file mode 100644 index 000000000..44f93da76 --- /dev/null +++ b/JIT/examples/spectral_norm.pl @@ -0,0 +1,126 @@ +% ---------------------------------------------------------------------- +% The Computer Language Benchmarks Game +% http://shootout.alioth.debian.org/ +% Contributed by anon +% Modified to run with YAP by Glendon Holst +% ---------------------------------------------------------------------- + +:- yap_flag(unknown,error). + +:- initialization(main). + +main :- + unix( argv([H|_]) ), number_atom(N,H), + approximate(N, R), + format("~9f~n", [R]), + + statistics, + statistics_jit. + +% ------------------------------- % + +approximate(N, R) :- + make_array(app_u, N, 1.0, U), make_array(app_v, N, 0.0, V), + + approx_(10, N, U, V), + + vbv_loop(N, U, V, VbV), vv_loop(N, V, V, Vv), + + Vi is VbV / Vv, R is sqrt(Vi). + +approx_(I, N, U, V) :- + I > 0, + mulAtAv(N, U, V), + mulAtAv(N, V, U), + I1 is I - 1, approx_(I1, N, U, V). +approx_(0, _, _, _). + +% ------------- % + +vbv_loop(N, U, V, VbV) :- vbv_loop_(N, U, V, 0.0, VbV). + +vbv_loop_(0, _, _, VAcc, VAcc) :- !. + +vbv_loop_(N, U, V, VAcc, VbV) :- + arg(N, U, UValue), arg(N, V, VValue), + VAcc1 is VAcc + UValue * VValue, + N1 is N - 1, !, vbv_loop_(N1, U, V, VAcc1, VbV). + +% ------------- % + +vv_loop(N, U, V, Vv) :- vv_loop_(N, U, V, 0.0, Vv). + +vv_loop_(0, _, _, VAcc, VAcc) :- !. + +vv_loop_(N, U, V, VAcc, Vv) :- + arg(N, V, VValue), + VAcc1 is VAcc + VValue * VValue, + N1 is N - 1, !, vv_loop_(N1, U, V, VAcc1, Vv). + +% ------------------------------- % + +a(I, J, AResult) :- + Ia is I - 1.0, Ja is J - 1.0, + AResult is 1.0 / ((Ia + Ja) * (Ia + Ja + 1.0) / 2.0 + Ia + 1.0). + +% ------------------------------- % + +mulAv(N, V, Av) :- mulAv_(N, N, N, V, Av). + +% ------------- % + +mulAv_(0, _, _, _, _) :- !. + +mulAv_(I, J, N, V, Av) :- + setarg(I, Av, 0.0), + mulAvJ_(I, J, N, V, Av), + I1 is I - 1, !, mulAv_(I1, J, N, V, Av). + +mulAvJ_(_, 0, _, _, _) :- !. + +mulAvJ_(I, J, N, V, Av) :- + arg(I, Av, AvValue), arg(J, V, VValue), a(I, J, AResult), + AvNew is AvValue + AResult * VValue, + setarg(I, Av, AvNew), + J1 is J - 1, !, mulAvJ_(I, J1, N, V, Av). + +% ------------------------------- % + +mulAtV(N, V, Atv) :- mulAtV_(N, N, N, V, Atv). + +% ------------- % + +mulAtV_(0, _, _, _, _) :- !. + +mulAtV_(I, J, N, V, Atv) :- + setarg(I, Atv, 0.0), + mulAtVJ_(I, J, N, V, Atv), + I1 is I - 1, !, mulAtV_(I1, J, N, V, Atv). + +mulAtVJ_(_, 0, _, _, _) :- !. + +mulAtVJ_(I, J, N, V, Atv) :- + arg(I, Atv, AtvValue), arg(J, V, VValue), a(J, I, AResult), + AtvNew is AtvValue + AResult * VValue, + setarg(I, Atv, AtvNew), + J1 is J - 1, !, mulAtVJ_(I, J1, N, V, Atv). + +% ------------------------------- % + +mulAtAv(N, V, AtAv) :- + make_array(mul_u, N, 0.0, U), + mulAv(N, V, U), mulAtV(N, U, AtAv). + +% ------------------------------- % + +make_array(Name, N, V, Array) :- functor(Array, Name, N), fill_array(N, V, Array). + +% ------------- % + +fill_array(0, _, _) :- !. + +fill_array(N, V, Array) :- + setarg(N, Array, V), N1 is N - 1, !, + fill_array(N1, V, Array). + +% ------------------------------- % diff --git a/JIT/examples/tak.pl b/JIT/examples/tak.pl new file mode 100644 index 000000000..58d673ee2 --- /dev/null +++ b/JIT/examples/tak.pl @@ -0,0 +1,24 @@ +:- initialization(main). + +tak(X,Y,Z,A) :- X =< Y, + Z = A. + +tak(X,Y,Z,A) :- X > Y, + X1 is X - 1, + tak(X1,Y,Z,A1), + Y1 is Y - 1, + tak(Y1,Z,X,A2), + Z1 is Z - 1, + tak(Z1,X,Y,A3), + tak(A1,A2,A3,A). + +main :- + unix( argv([H|_]) ), + number_atom(N,H), + R1 is N >> 3, + R2 is N / 2, + N2 is R2 - R1, + N3 is N - N2, + tak(N,N2,N3,_), + statistics, + statistics_jit. diff --git a/JIT/examples/zebra.pl b/JIT/examples/zebra.pl new file mode 100644 index 000000000..63a817964 --- /dev/null +++ b/JIT/examples/zebra.pl @@ -0,0 +1,54 @@ +:- initialization(main). + +houses([house(_, _, _, _, _), + house(_, _, _, _, _), + house(_, _, _, _, _), + house(_, _, _, _, _), + house(_, _, _, _, _)]). + + +right_of(A, B, [B, A | _]). + +right_of(A, B, [_ | Y]) :- + right_of(A, B, Y). + + +next_to(A, B, [A, B | _]). + +next_to(A, B, [B, A | _]). + +next_to(A, B, [_ | Y]) :- + next_to(A, B, Y). + + +my_member(X, [X|_]). + +my_member(X, [_|Y]) :- + my_member(X, Y). + + +print_houses([]). + +print_houses([A|B]) :- + write(A), nl, + print_houses(B). + +main:- + houses(Houses), + my_member(house(red, english, _, _, _), Houses), + my_member(house(_, spanish, dog, _, _), Houses), + my_member(house(green, _, _, coffee, _), Houses), + my_member(house(_, ukrainian, _, tea, _), Houses), + right_of(house(green,_,_,_,_), house(ivory,_,_,_,_), Houses), + my_member(house(_, _, snails, _, winstons), Houses), + my_member(house(yellow, _, _, _, kools), Houses), + Houses = [_, _, house(_, _, _, milk, _), _,_], + Houses = [house(_, norwegian, _, _, _)|_], + next_to(house(_,_,_,_,chesterfields), house(_,_,fox,_,_), Houses), + next_to(house(_,_,_,_,kools), house(_,_,horse,_,_), Houses), + my_member(house(_, _, _, orange_juice, lucky_strikes), Houses), + my_member(house(_, japanese, _, _, parliaments), Houses), + next_to(house(_,norwegian,_,_,_), house(blue,_,_,_,_), Houses), + my_member(house(_, _, zebra, _, _), Houses), + my_member(house(_, _, _, water, _), Houses), + statistics. diff --git a/JIT/jit_analysispreds.c b/JIT/jit_analysispreds.c new file mode 100644 index 000000000..278727921 --- /dev/null +++ b/JIT/jit_analysispreds.c @@ -0,0 +1,614 @@ +/************************************************************************* +* * +* Extension for YAP Prolog * +* * +* Copyright G.S.Oliveira, A.F.Silva and Universidade Estadual de Maringá * +* * +* Yap Prolog was developed at NCCUP - Universidade do Porto * +* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * +* * +************************************************************************** +* * +* File: jit_analysispreds.c * +* comments: JIT Compiler Analysis predicates * +* * +* Last rev: 2013-10-18 * +*************************************************************************/ + +#include "jit_predicates.hh" +#include + +#define N_ANALYSIS_PASSES 33 + +// Disable one (passed by argument) LLVM analysis pass +static Int p_disable_analysis_pass(USES_REGS1 ) ; + +// Enable one (passed by argument) LLVM analysis pass +static Int p_analysis_pass( USES_REGS1 ); + +// Enable one (passed by argument) LLVM analysis pass +static Int p_enable_analysis_pass( USES_REGS1 ); + +// Enable a list (passed by argument) of LLVM analysis passes +static Int p_analysis_passes( USES_REGS1 ); + +// Enable all available LLVM analysis passes +static Int p_enable_all_analysis_passes( USES_REGS1 ); + +// Disable all available LLVM analysis passes +static Int p_disable_all_analysis_passes( USES_REGS1 ); + +// Enable LLVM statistics +static Int p_enable_stats( USES_REGS1 ); + +// Enable elapsed time of each LLVM's task +static Int p_enable_time_passes( USES_REGS1 ); + +// Checks generated modules are correct (before optimize it). Use only if you suspect that any module has been generated incorrectly. +static Int p_enable_module_correctness( USES_REGS1 ); + +// Same as 'p_enable_module_correctness', but accepts one argument, which defines when modules are checked. +// Valid values are those defined by 'enumPointToVerifiy' on 'amidefs.h' +static Int p_enable_module_correctness1( USES_REGS1 ); + +// Same as 'p_enable_module_correctness' with ARG1 = NOPOINT +static Int p_verify_module_nopoint( USES_REGS1 ); + +// Same as 'p_enable_module_correctness' with ARG1 = BEFORE +static Int p_verify_module_before( USES_REGS1 ); + +// Same as 'p_enable_module_correctness' with ARG1 = AFTER +static Int p_verify_module_after( USES_REGS1 ); + +// Same as 'p_enable_module_correctness' with ARG1 = BOTH +static Int p_verify_module_both( USES_REGS1 ); + +// Disable LLVM statistics +static Int p_disable_stats( USES_REGS1 ); + +// Disable elapsed time of each LLVM's task +static Int p_disable_time_passes( USES_REGS1 ) ); + +// Don't check generated modules are correct +static Int p_disable_module_correctness( USES_REGS1 ) + +// Set output file where analysis results are emitted. 'stderr' and 'stdout' are valid values +static Int p_analysis_output_file( USES_REGS1 ) ; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wimplicit-function-declaration" + +static Int +p_disable_analysis_pass( USES_REGS1 ) +{ + // First: stores what analysis pass should be disabled + + Term t = Deref(ARG1); + enumAnalysisPasses f; + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + Int v = IntOfTerm(t); + if (v < 0 || v >= N_ANALYSIS_PASSES) { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + f = (enumAnalysisPasses)v; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char) + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + if (strcmp(str, "ALL") == 0) { + // atom is 'all' -- this will disable all passes + if (ExpEnv.analysis_struc.act_an) free(ExpEnv.analysis_struc.act_an); + ExpEnv.analysis_struc.act_an = NULL; + ExpEnv.analysis_struc.n = 0; + return TRUE; + } + + // Detects one pass according to 'str' -- store it + if (strcmp(str, "AAEVAL") == 0) f = e_createAAEvalPass; + else if (strcmp(str, "ALIASANALYSISCOUNTER") == 0 || strcmp(str, "COUNTAA") == 0) f = e_createAliasAnalysisCounterPass; + else if (strcmp(str, "BASICALIASANALYSIS") == 0 || strcmp(str, "BASICAA") == 0) f = e_createBasicAliasAnalysisPass; + else if (strcmp(str, "CFGONLYPRINTER") == 0 || strcmp(str, "DOTCFGONLY") == 0) f = e_createCFGOnlyPrinterPass; + else if (strcmp(str, "CFGPRINTER") == 0 || strcmp(str, "DOTCFG") == 0) f = e_createCFGPrinterPass; + else if (strcmp(str, "DBGINFOPRINTER") == 0 || strcmp(str, "PRINTDBGINFO") == 0) f = e_createDbgInfoPrinterPass; + else if (strcmp(str, "DOMONLYPRINTER") == 0 || strcmp(str, "DOTDOMONLY") == 0) f = e_createDomOnlyPrinterPass; + else if (strcmp(str, "DOMPRINTER") == 0 || strcmp(str, "DOTDOM") == 0) f = e_createDomPrinterPass; + else if (strcmp(str, "GLOBALSMODREF") == 0 || strcmp(str, "GLOBALSMODREFAA") == 0) f = e_createGlobalsModRefPass; + else if (strcmp(str, "INSTCOUNT") == 0) f = e_createInstCountPass; + else if (strcmp(str, "IVUSERS") == 0) f = e_createIVUsersPass; + else if (strcmp(str, "LAZYVALUEINFO") == 0) f = e_createLazyValueInfoPass; + else if (strcmp(str, "LIBCALLALIASANALYSIS") == 0 || strcmp(str, "LIBCALLAA") == 0) f = e_createLibCallAliasAnalysisPass; + else if (strcmp(str, "LINT") == 0) f = e_createLintPass; + else if (strcmp(str, "LOOPDEPENDENCEANALYSIS") == 0 || strcmp(str, "LDA") == 0) f = e_createLoopDependenceAnalysisPass; + else if (strcmp(str, "MEMDEPPRINTER") == 0 || strcmp(str, "MEMDEP") == 0) f = e_createMemDepPrinter; + else if (strcmp(str, "MODULEDEBUGINFOPRINTER") == 0 || strcmp(str, "MODULEDEBUGINFO") == 0) f = e_createModuleDebugInfoPrinterPass; + else if (strcmp(str, "NOAA") == 0) f = e_createNoAAPass; + else if (strcmp(str, "NOPATHPROFILEINFO") == 0 || strcmp(str, "NOPATHPROFILE") == 0) f = e_createNoPathProfileInfoPass; + else if (strcmp(str, "NOPROFILEINFO") == 0 || strcmp(str, "NOPROFILE") == 0) f = e_createNoProfileInfoPass; + else if (strcmp(str, "OBJCARCALIASANALYSIS") == 0 || strcmp(str, "OBJCARCAA") == 0) f = e_createObjCARCAliasAnalysisPass; + else if (strcmp(str, "PATHPROFILELOADER") == 0) f = e_createPathProfileLoaderPass; + else if (strcmp(str, "PATHPROFILEVERIFIER") == 0) f = e_createPathProfileVerifierPass; + else if (strcmp(str, "POSTDOMONLYPRINTER") == 0 || strcmp(str, "DOTPOSTDOMONLY") == 0) f = e_createPostDomOnlyPrinterPass; + else if (strcmp(str, "POSTDOMPRINTER") == 0 || strcmp(str, "DOTPOSTDOM") == 0) f = e_createPostDomPrinterPass; + else if (strcmp(str, "PROFILEESTIMATOR") == 0) f = e_createProfileEstimatorPass; + else if (strcmp(str, "PROFILELOADER") == 0) f = e_createProfileLoaderPass; + else if (strcmp(str, "PROFILEVERIFIER") == 0) f = e_createProfileVerifierPass; + else if (strcmp(str, "REGIONINFO") == 0) f = e_createRegionInfoPass; + else if (strcmp(str, "REGIONONLYPRINTER") == 0 || strcmp(str, "DOTREGIONSONLY") == 0) f = e_createRegionOnlyPrinterPass; + else if (strcmp(str, "REGIONPRINTER") == 0 || strcmp(str, "DOTREGIONS") == 0) f = e_createRegionPrinterPass; + else if (strcmp(str, "SCALAREVOLUTIONALIASANALYSIS") == 0 || strcmp(str, "SCEVAA") == 0) f = e_createScalarEvolutionAliasAnalysisPass; + else if (strcmp(str, "TYPEBASEDALIASANALYSIS") == 0 || strcmp(str, "TBAA") == 0) f = e_createTypeBasedAliasAnalysisPass; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Analysis pass"); + return FALSE; + } + + // Second: creates a new list with all analysis on 'ExpEnv.analysis_struc.act_an' but that analysis stored on first step + enumAnalysisPasses *tmplist = NULL; + COUNT tmpn = 0; + int i = 0; + while (i < ExpEnv.analysis_struc.n) { + if (ExpEnv.analysis_struc.act_an[i] != f) { + tmpn += 1; + tmplist = (enumAnalysisPasses*)realloc(tmplist, tmpn*sizeof(enumAnalysisPasses)); + tmplist[tmpn-1] = ExpEnv.analysis_struc.act_an[i]; + } + i += 1; + } + + // Third: makes 'ExpEnv.analysis_struc.act_an' to point to new list created on second step + free(ExpEnv.analysis_struc.act_an); + ExpEnv.analysis_struc.n = tmpn; + ExpEnv.analysis_struc.act_an = tmplist; + return TRUE; +} + +static Int +p_analysis_pass( USES_REGS1 ) +{ + // First: disables analysis pass (if be active) + p_disable_analysis_pass(); + + // Second: valids argument and inserts new analysis pass + // valid values for ARG1 are 'integer' and 'atom' + Term t = Deref(ARG1); + Int v; + if (IsIntTerm(t)) { + // ARG1 is integer + v = IntOfTerm(t); + if (v < 0 || v >= N_ANALYSIS_PASSES) { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + // creates a new slot in 'ExpEnv.analysis_struc.act_an' and appends the pass in it + ExpEnv.analysis_struc.n += 1; + ExpEnv.analysis_struc.act_an = (enumAnalysisPasses*) + realloc(ExpEnv.analysis_struc.act_an, ExpEnv.analysis_struc.n * sizeof(enumAnalysisPasses)); + ExpEnv.analysis_struc.act_an[ExpEnv.analysis_struc.n-1] = (enumAnalysisPasses)v; + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects one pass according to 'str' + if (strcmp(str, "AAEVAL") == 0) v = e_createAAEvalPass; + else if (strcmp(str, "ALIASANALYSISCOUNTER") == 0 || strcmp(str, "COUNTAA") == 0) v = e_createAliasAnalysisCounterPass; + else if (strcmp(str, "BASICALIASANALYSIS") == 0 || strcmp(str, "BASICAA") == 0) v = e_createBasicAliasAnalysisPass; + else if (strcmp(str, "CFGONLYPRINTER") == 0 || strcmp(str, "DOTCFGONLY") == 0) v = e_createCFGOnlyPrinterPass; + else if (strcmp(str, "CFGPRINTER") == 0 || strcmp(str, "DOTCFG") == 0) v = e_createCFGPrinterPass; + else if (strcmp(str, "DBGINFOPRINTER") == 0 || strcmp(str, "PRINTDBGINFO") == 0) v = e_createDbgInfoPrinterPass; + else if (strcmp(str, "DOMONLYPRINTER") == 0 || strcmp(str, "DOTDOMONLY") == 0) v = e_createDomOnlyPrinterPass; + else if (strcmp(str, "DOMPRINTER") == 0 || strcmp(str, "DOTDOM") == 0) v = e_createDomPrinterPass; + else if (strcmp(str, "GLOBALSMODREF") == 0 || strcmp(str, "GLOBALSMODREFAA") == 0) v = e_createGlobalsModRefPass; + else if (strcmp(str, "INSTCOUNT") == 0) v = e_createInstCountPass; + else if (strcmp(str, "IVUSERS") == 0) v = e_createIVUsersPass; + else if (strcmp(str, "LAZYVALUEINFO") == 0) v = e_createLazyValueInfoPass; + else if (strcmp(str, "LIBCALLALIASANALYSIS") == 0 || strcmp(str, "LIBCALLAA") == 0) v = e_createLibCallAliasAnalysisPass; + else if (strcmp(str, "LINT") == 0) v = e_createLintPass; + else if (strcmp(str, "LOOPDEPENDENCEANALYSIS") == 0 || strcmp(str, "LDA") == 0) v = e_createLoopDependenceAnalysisPass; + else if (strcmp(str, "MEMDEPPRINTER") == 0 || strcmp(str, "MEMDEP") == 0) v = e_createMemDepPrinter; + else if (strcmp(str, "MODULEDEBUGINFOPRINTER") == 0 || strcmp(str, "MODULEDEBUGINFO") == 0) v = e_createModuleDebugInfoPrinterPass; + else if (strcmp(str, "NOAA") == 0) v = e_createNoAAPass; + else if (strcmp(str, "NOPATHPROFILEINFO") == 0 || strcmp(str, "NOPATHPROFILE") == 0) v = e_createNoPathProfileInfoPass; + else if (strcmp(str, "NOPROFILEINFO") == 0 || strcmp(str, "NOPROFILE") == 0) v = e_createNoProfileInfoPass; + else if (strcmp(str, "OBJCARCALIASANALYSIS") == 0 || strcmp(str, "OBJCARCAA") == 0) v = e_createObjCARCAliasAnalysisPass; + else if (strcmp(str, "PATHPROFILELOADER") == 0) v = e_createPathProfileLoaderPass; + else if (strcmp(str, "PATHPROFILEVERIFIER") == 0) v = e_createPathProfileVerifierPass; + else if (strcmp(str, "POSTDOMONLYPRINTER") == 0 || strcmp(str, "DOTPOSTDOMONLY") == 0) v = e_createPostDomOnlyPrinterPass; + else if (strcmp(str, "POSTDOMPRINTER") == 0 || strcmp(str, "DOTPOSTDOM") == 0) v = e_createPostDomPrinterPass; + else if (strcmp(str, "PROFILEESTIMATOR") == 0) v = e_createProfileEstimatorPass; + else if (strcmp(str, "PROFILELOADER") == 0) v = e_createProfileLoaderPass; + else if (strcmp(str, "PROFILEVERIFIER") == 0) v = e_createProfileVerifierPass; + else if (strcmp(str, "REGIONINFO") == 0) v = e_createRegionInfoPass; + else if (strcmp(str, "REGIONONLYPRINTER") == 0 || strcmp(str, "DOTREGIONSONLY") == 0) v = e_createRegionOnlyPrinterPass; + else if (strcmp(str, "REGIONPRINTER") == 0 || strcmp(str, "DOTREGIONS") == 0) v = e_createRegionPrinterPass; + else if (strcmp(str, "SCALAREVOLUTIONALIASANALYSIS") == 0 || strcmp(str, "SCEVAA") == 0) v = e_createScalarEvolutionAliasAnalysisPass; + else if (strcmp(str, "TYPEBASEDALIASANALYSIS") == 0 || strcmp(str, "TBAA") == 0) v = e_createTypeBasedAliasAnalysisPass; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + // creates a new slot in 'ExpEnv.analysis_struc.act_an' and appends the pass in it + ExpEnv.analysis_struc.n += 1; + ExpEnv.analysis_struc.act_an = (enumAnalysisPasses*) + realloc(ExpEnv.analysis_struc.act_an, ExpEnv.analysis_struc.n * sizeof(enumAnalysisPasses)); + ExpEnv.analysis_struc.act_an[ExpEnv.analysis_struc.n-1] = v; + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Analysis pass"); + return FALSE; + } +} + +static Int +p_enable_analysis_pass( USES_REGS1 ) +{ + return p_analysis_pass(); +} + +static Int +p_analysis_passes( USES_REGS1 ) +{ + int i = 0, j = 0; + char *tmp; + // valid values for ARG1 are 'atom' and 'list (pair)' + Term t = Deref(ARG1); + if (IsAtomTerm(t)) { + // ARG1 is atom + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // If ARG1 is atom, 'all' is the only valid value + if (strcmp(str, "ALL") == 0) { + // First: disables all analysis passes + free(ExpEnv.analysis_struc.act_an); + ExpEnv.analysis_struc.act_an = NULL; + ExpEnv.analysis_struc.n = 0; + + // Second, insert all analysis passes on 'ExpEnv.analysis_struc.act_an' + int i; + for (i = 0; i < N_ANALYSIS_PASSES; i++) { + ExpEnv.analysis_struc.n += 1; + ExpEnv.analysis_struc.act_an = (enumAnalysisPasses*)realloc(ExpEnv.analysis_struc.act_an, ExpEnv.analysis_struc.n * sizeof(enumAnalysisPasses)); + ExpEnv.analysis_struc.act_an[ExpEnv.analysis_struc.n-1] = i; + } + return TRUE; + } + // value passed by argument is out of known range (ARG1 differs of 'all') + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + else if (IsPairTerm(t)) { + // ARG1 is list + // First: disables all analysis passes + if (ExpEnv.analysis_struc.act_an) free(ExpEnv.analysis_struc.act_an); + ExpEnv.analysis_struc.act_an = NULL; + ExpEnv.analysis_struc.n = 0; + + // Second: scrolls over the list treating each element individually + Term u = HeadOfTermCell(t); // get head of list 't' + u = Deref(u); + while (1) { + Int v; + enumAnalysisPasses w; + + // valid values for head are 'integer' and 'atom' (the list can contain both) + if (IsIntTerm(u)) { + // head is integer + v = IntOfTerm(u); + if (v < 0 || v >= N_ANALYSIS_PASSES) { + // head's value is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + + // insert analysis pass defined by 'head' on 'ExpEnv.analysis_struc.act_an' + ExpEnv.analysis_struc.n += 1; + ExpEnv.analysis_struc.act_an = (enumAnalysisPasses*)realloc(ExpEnv.analysis_struc.act_an, ExpEnv.analysis_struc.n * sizeof(enumAnalysisPasses)); + ExpEnv.analysis_struc.act_an[ExpEnv.analysis_struc.n-1] = (enumAnalysisPasses)v; + } + else if (IsAtomTerm(u)) { + // head is atom + int i = 0, j = 0; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects one pass according to 'str' + if (strcmp(str, "AAEVAL") == 0) w = e_createAAEvalPass; + else if (strcmp(str, "ALIASANALYSISCOUNTER") == 0 || strcmp(str, "COUNTAA") == 0) w = e_createAliasAnalysisCounterPass; + else if (strcmp(str, "BASICALIASANALYSIS") == 0 || strcmp(str, "BASICAA") == 0) w = e_createBasicAliasAnalysisPass; + else if (strcmp(str, "CFGONLYPRINTER") == 0 || strcmp(str, "DOTCFGONLY") == 0) w = e_createCFGOnlyPrinterPass; + else if (strcmp(str, "CFGPRINTER") == 0 || strcmp(str, "DOTCFG") == 0) w = e_createCFGPrinterPass; + else if (strcmp(str, "DBGINFOPRINTER") == 0 || strcmp(str, "PRINTDBGINFO") == 0) w = e_createDbgInfoPrinterPass; + else if (strcmp(str, "DOMONLYPRINTER") == 0 || strcmp(str, "DOTDOMONLY") == 0) w = e_createDomOnlyPrinterPass; + else if (strcmp(str, "DOMPRINTER") == 0 || strcmp(str, "DOTDOM") == 0) w = e_createDomPrinterPass; + else if (strcmp(str, "GLOBALSMODREF") == 0 || strcmp(str, "GLOBALSMODREFAA") == 0) w = e_createGlobalsModRefPass; + else if (strcmp(str, "INSTCOUNT") == 0) w = e_createInstCountPass; + else if (strcmp(str, "IVUSERS") == 0) w = e_createIVUsersPass; + else if (strcmp(str, "LAZYVALUEINFO") == 0) w = e_createLazyValueInfoPass; + else if (strcmp(str, "LIBCALLALIASANALYSIS") == 0 || strcmp(str, "LIBCALLAA") == 0) w = e_createLibCallAliasAnalysisPass; + else if (strcmp(str, "LINT") == 0) w = e_createLintPass; + else if (strcmp(str, "LOOPDEPENDENCEANALYSIS") == 0 || strcmp(str, "LDA") == 0) w = e_createLoopDependenceAnalysisPass; + else if (strcmp(str, "MEMDEPPRINTER") == 0 || strcmp(str, "MEMDEP") == 0) w = e_createMemDepPrinter; + else if (strcmp(str, "MODULEDEBUGINFOPRINTER") == 0 || strcmp(str, "MODULEDEBUGINFO") == 0) w = e_createModuleDebugInfoPrinterPass; + else if (strcmp(str, "NOAA") == 0) w = e_createNoAAPass; + else if (strcmp(str, "NOPATHPROFILEINFO") == 0 || strcmp(str, "NOPATHPROFILE") == 0) w = e_createNoPathProfileInfoPass; + else if (strcmp(str, "NOPROFILEINFO") == 0 || strcmp(str, "NOPROFILE") == 0) w = e_createNoProfileInfoPass; + else if (strcmp(str, "OBJCARCALIASANALYSIS") == 0 || strcmp(str, "OBJCARCAA") == 0) w = e_createObjCARCAliasAnalysisPass; + else if (strcmp(str, "PATHPROFILELOADER") == 0) w = e_createPathProfileLoaderPass; + else if (strcmp(str, "PATHPROFILEVERIFIER") == 0) w = e_createPathProfileVerifierPass; + else if (strcmp(str, "POSTDOMONLYPRINTER") == 0 || strcmp(str, "DOTPOSTDOMONLY") == 0) w = e_createPostDomOnlyPrinterPass; + else if (strcmp(str, "POSTDOMPRINTER") == 0 || strcmp(str, "DOTPOSTDOM") == 0) w = e_createPostDomPrinterPass; + else if (strcmp(str, "PROFILEESTIMATOR") == 0) w = e_createProfileEstimatorPass; + else if (strcmp(str, "PROFILELOADER") == 0) w = e_createProfileLoaderPass; + else if (strcmp(str, "PROFILEVERIFIER") == 0) w = e_createProfileVerifierPass; + else if (strcmp(str, "REGIONINFO") == 0) w = e_createRegionInfoPass; + else if (strcmp(str, "REGIONONLYPRINTER") == 0 || strcmp(str, "DOTREGIONSONLY") == 0) w = e_createRegionOnlyPrinterPass; + else if (strcmp(str, "REGIONPRINTER") == 0 || strcmp(str, "DOTREGIONS") == 0) w = e_createRegionPrinterPass; + else if (strcmp(str, "SCALAREVOLUTIONALIASANALYSIS") == 0 || strcmp(str, "SCEVAA") == 0) w = e_createScalarEvolutionAliasAnalysisPass; + else if (strcmp(str, "TYPEBASEDALIASANALYSIS") == 0 || strcmp(str, "TBAA") == 0) w = e_createTypeBasedAliasAnalysisPass; + else { + // head's value is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + + // insert analysis pass defined by 'head' on 'ExpEnv.analysis_struc.act_an' + ExpEnv.analysis_struc.n += 1; + ExpEnv.analysis_struc.act_an = (enumAnalysisPasses*)realloc(ExpEnv.analysis_struc.act_an, ExpEnv.analysis_struc.n * sizeof(enumAnalysisPasses)); + ExpEnv.analysis_struc.act_an[ExpEnv.analysis_struc.n-1] = w; + } + else { + // head's value is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Analysis pass"); + return FALSE; + } + + // here, 'u' is the current head of list (just been treated) and 't' is our list itself + t = TailOfTermCell(t); // 't' is now our list without 'u' (tail of 't') + t = Deref(t); + if (IsAtomTerm(t)) break; // if 't' is an empty list (which is treated as atom by Prolog), we finish the loop + u = HeadOfTermCell(t); // else, 'u' is now next head which will be treated + u = Deref(u); + } + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Analysis pass"); + return FALSE; + } +} + +static Int +p_enable_all_analysis_passes( USES_REGS1 ) +{ + // Same as 'analysis_passes(all)' + // First, disable all analysis passes + if (ExpEnv.analysis_struc.act_an) free(ExpEnv.analysis_struc.act_an); + ExpEnv.analysis_struc.act_an = NULL; + ExpEnv.analysis_struc.n = 0; + // Second, insert all analysis passes + int i; + for (i = 0; i < N_ANALYSIS_PASSES; i++) { + ExpEnv.analysis_struc.n += 1; + ExpEnv.analysis_struc.act_an = (enumAnalysisPasses*) + realloc(ExpEnv.analysis_struc.act_an, ExpEnv.analysis_struc.n * sizeof(enumAnalysisPasses)); + ExpEnv.analysis_struc.act_an[ExpEnv.analysis_struc.n-1] = (enumAnalysisPasses)i; + } + return TRUE; +} + +static Int +p_disable_all_analysis_passes( USES_REGS1 ) +{ + // Just empty 'ExpEnv.analysis_struc.act_an' + if (ExpEnv.analysis_struc.act_an) free(ExpEnv.analysis_struc.act_an); + ExpEnv.analysis_struc.act_an = NULL; + ExpEnv.analysis_struc.n = 0; + return TRUE; +} + +static Int +p_enable_stats( USES_REGS1 ) +{ + ExpEnv.analysis_struc.stats_enabled = 1; + return TRUE; +} + +static Int +p_enable_time_passes( USES_REGS1 ) +{ + ExpEnv.analysis_struc.time_pass_enabled = 1; + return TRUE; +} + +static Int +p_enable_module_correctness( USES_REGS1 ) +{ + ExpEnv.analysis_struc.pointtoverifymodule = AFTER; + return TRUE; +} + +static Int +p_enable_module_correctness1( USES_REGS1 ) +{ + Term t = Deref(ARG1); + char *tmp; + // valid value for ARG1 is just 'atom' + if (IsAtomTerm(t)) { + // 'ARG1' is atom + int i = 0, j = 0; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects one pass according to 'str' + if (strcmp(str, "NOPOINT") == 0) ExpEnv.analysis_struc.pointtoverifymodule = NOPOINT; + else if (strcmp(str, "BEFORE") == 0) ExpEnv.analysis_struc.pointtoverifymodule = BEFORE; + else if (strcmp(str, "AFTER") == 0) ExpEnv.analysis_struc.pointtoverifymodule = AFTER; + else if (strcmp(str, "BOTH") == 0) ExpEnv.analysis_struc.pointtoverifymodule = BOTH; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + return TRUE; + } + else { + // ARG1 is not an atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Analysis pass"); + return FALSE; + } +} + +static Int +p_verify_module_nopoint( USES_REGS1 ) +{ + // Same as 'enable_module_correctness(nopoint)' + ExpEnv.analysis_struc.pointtoverifymodule = NOPOINT; + return TRUE; +} + +static Int +p_verify_module_before( USES_REGS1 ) +{ + // Same as 'enable_module_correctness(before)' + ExpEnv.analysis_struc.pointtoverifymodule = BEFORE; + return TRUE; +} + +static Int +p_verify_module_after( USES_REGS1 ) +{ + // Same as 'enable_module_correctness(after)' + ExpEnv.analysis_struc.pointtoverifymodule = AFTER; + return TRUE; +} + +static Int +p_verify_module_both( USES_REGS1 ) +{ + // Same as 'enable_module_correctness(both)' + ExpEnv.analysis_struc.pointtoverifymodule = BOTH; + return TRUE; +} + +static Int +p_disable_stats( USES_REGS1 ) +{ + ExpEnv.analysis_struc.stats_enabled = 0; + return TRUE; +} + +static Int +p_disable_time_passes( USES_REGS1 ) +{ + ExpEnv.analysis_struc.time_pass_enabled = 0; + return TRUE; +} + +static Int +p_disable_module_correctness( USES_REGS1 ) +{ + ExpEnv.analysis_struc.pointtoverifymodule = NOPOINT; + return TRUE; +} + +static Int +p_analysis_output_file( USES_REGS1 ) +{ + Term t = Deref(ARG1); + char *tmp; + // valid value for ARG1 is just 'atom' + if (IsAtomTerm(t)) { + // 'ARG1' is atom + int i = 0, j = 0; + + // allocates memory to 'ExpEnv.analysis_struc.outfile' + ExpEnv.analysis_struc.outfile = (CELL)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + + // gets string from atom and stores it on 'str' and 'tmpstr' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + char *tmpstr = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + strcpy(tmpstr, str); + + // here, both 'str' and 'tmpstr' contain the file name... I need to verify if this name is 'stdout' or 'stderr', so... + // makes upper characters of 'tmpstr' (for comparison) and... + UPPER_ENTRY(tmpstr); + // verify if tmpstr is 'stdout' or 'stderr'. Note here that 'tmpstr' is the same of 'str', but capitalized + if (strcmp(tmpstr, "STDOUT") == 0 || strcmp(tmpstr, "STDERR") == 0) + strcpy(((char*)ExpEnv.analysis_struc.outfile), tmpstr); + else + // if not 'stdout' or 'stderr', 'ExpEnv.analysis_struc.outfile' will be the real string of ARG1, ie., 'str' + strcpy(((char*)ExpEnv.analysis_struc.outfile), str); + return TRUE; + } + else { + // ARG1 is not an atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Analysis pass"); + return FALSE; + } +} + +#pragma GCC diagnostic pop + +void +Yap_InitJitAnalysisPreds(void) +{ + Yap_InitCPred("disable_analysis_pass", 1, p_disable_analysis_pass, SafePredFlag); + Yap_InitCPred("analysis_pass", 1, p_analysis_pass, SafePredFlag); + Yap_InitCPred("enable_analysis_pass", 1, p_enable_analysis_pass, SafePredFlag); + Yap_InitCPred("analysis_passes", 1, p_analysis_passes, SafePredFlag); + Yap_InitCPred("enable_all_analysis_passes", 0, p_enable_all_analysis_passes, SafePredFlag); + Yap_InitCPred("disable_all_analysis_passes", 0, p_disable_all_analysis_passes, SafePredFlag); + Yap_InitCPred("enable_stats", 0, p_enable_stats, SafePredFlag); + Yap_InitCPred("enable_time_passes", 0, p_enable_time_passes, SafePredFlag); + Yap_InitCPred("enable_module_correctness", 0, p_enable_module_correctness, SafePredFlag); + Yap_InitCPred("enable_module_correctness", 1, p_enable_module_correctness1, SafePredFlag); + Yap_InitCPred("verify_module_nopoint", 0, p_verify_module_nopoint, SafePredFlag); + Yap_InitCPred("verify_module_before", 0, p_verify_module_before, SafePredFlag); + Yap_InitCPred("verify_module_after", 0, p_verify_module_after, SafePredFlag); + Yap_InitCPred("verify_module_both", 0, p_verify_module_both, SafePredFlag); + Yap_InitCPred("disable_stats", 0, p_disable_stats, SafePredFlag); + Yap_InitCPred("disable_time_passes", 0, p_disable_time_passes, SafePredFlag); + Yap_InitCPred("disable_module_correctness", 0, p_disable_module_correctness, SafePredFlag); + Yap_InitCPred("analysis_output_file", 1, p_analysis_output_file, SafePredFlag); +} diff --git a/JIT/jit_codegenpreds.c b/JIT/jit_codegenpreds.c new file mode 100644 index 000000000..d9c719f20 --- /dev/null +++ b/JIT/jit_codegenpreds.c @@ -0,0 +1,567 @@ +/************************************************************************* +* * +* Extension for YAP Prolog * +* * +* Copyright G.S.Oliveira, A.F.Silva and Universidade Estadual de Maringá * +* * +* Yap Prolog was developed at NCCUP - Universidade do Porto * +* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * +* * +************************************************************************** +* * +* File: jit_codegenpreds.c * +* comments: JIT Compiler Codegen Options predicates * +* * +* Last rev: 2013-10-18 * +*************************************************************************/ + +#include "jit_predicates.hh" + +/* Predicates for LLVM Target Options configuration */ +static Int p_enable_framepointer_elimination( USES_REGS1 ); +static Int p_more_precise_fp_mad_option( USES_REGS1 ); +static Int p_excess_fp_precision( USES_REGS1 ); +static Int p_safe_fp_math( USES_REGS1 ); +static Int p_rounding_mode_not_changed( USES_REGS1 ); +static Int p_no_use_soft_float( USES_REGS1 ); +static Int p_disable_jit_exception_handling( USES_REGS1 ); +static Int p_disable_jit_emit_debug_info( USES_REGS1 ); +static Int p_disable_jit_emit_debug_info_to_disk( USES_REGS1 ); +static Int p_no_guaranteed_tail_call_opt( USES_REGS1 ); +static Int p_enable_tail_calls( USES_REGS1 ); +static Int p_disable_fast_isel( USES_REGS1 ); +static Int p_disable_framepointer_elimination( USES_REGS1 ); +static Int p_less_precise_fp_mad_option( USES_REGS1 ); +static Int p_no_excess_fp_precision( USES_REGS1 ); +static Int p_unsafe_fp_math( USES_REGS1 ); +static Int p_rounding_mode_dynamically_changed( USES_REGS1 ); +static Int p_use_soft_float( USES_REGS1 ); +static Int p_enable_jit_exception_handling( USES_REGS1 ); +static Int p_enable_jit_emit_debug_info( USES_REGS1 ); +static Int p_enable_jit_emit_debug_info_to_disk( USES_REGS1 ); +static Int p_guaranteed_tail_call_opt( USES_REGS1 ); +static Int p_disable_tail_calls( USES_REGS1 ); +static Int p_enable_fast_isel( USES_REGS1 ); +static Int p_fp_abitype( USES_REGS1 ); +static Int p_default_fp_abitype( USES_REGS1 ); + +// LLVM Execution Engine level +static Int p_engine_opt_level( USES_REGS1 ); +static Int p_reset_engine_opt_level( USES_REGS1 ); + +// LLVM Execution Engine reloc model +static Int p_relocmodel( USES_REGS1 ); +static Int p_reset_relocmodel( USES_REGS1 ); + +// LLVM Execution Engine code model +static Int p_codemodel( USES_REGS1 ); +static Int p_reset_codemodel( USES_REGS1 ); + +// Enable MC JIT (experimental) +static Int p_enable_mcjit( USES_REGS1 ); + +// Disable MC JIT (experimental) +static Int p_disable_mcjit( USES_REGS1 ); + +// LLVM Register Allocator (not implemented -- for some reason, LLVM crashes when I use it on 'JIT_Compiler.cpp') +static Int p_register_allocator( USES_REGS1 ); +static Int p_reset_register_allocator( USES_REGS1 ); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wimplicit-function-declaration" + +static Int +p_enable_framepointer_elimination( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.noframepointerelim = FALSE; + return TRUE; +} + +static Int +p_more_precise_fp_mad_option( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.lessprecisefpmadoption = FALSE; + return TRUE; +} + +static Int +p_excess_fp_precision( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.noexcessfpprecision = FALSE; + return TRUE; +} + +static Int +p_safe_fp_math( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.unsafefpmath = FALSE; + return TRUE; +} + +static Int +p_rounding_mode_not_changed( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.honorsigndependentroundingfpmathoption = FALSE; + return TRUE; +} + +static Int +p_no_use_soft_float( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.usesoftfloat = FALSE; + return TRUE; +} + +static Int +p_disable_jit_exception_handling( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.jitexceptionhandling = FALSE; + return TRUE; +} + +static Int +p_disable_jit_emit_debug_info( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfo = FALSE; + return TRUE; +} + +static Int +p_disable_jit_emit_debug_info_to_disk( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfotodisk = FALSE; + return TRUE; +} + +static Int +p_no_guaranteed_tail_call_opt( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.guaranteedtailcallopt = FALSE; + return TRUE; +} + +static Int +p_enable_tail_calls( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.disabletailcalls = FALSE; + return TRUE; +} + +static Int +p_disable_fast_isel( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.fastisel = FALSE; + return TRUE; +} + +static Int +p_disable_framepointer_elimination( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.noframepointerelim = TRUE; + return TRUE; +} + +static Int +p_less_precise_fp_mad_option( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.lessprecisefpmadoption = TRUE; + return TRUE; +} + +static Int +p_no_excess_fp_precision( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.noexcessfpprecision = TRUE; + return TRUE; +} + +static Int +p_unsafe_fp_math( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.unsafefpmath = TRUE; + return TRUE; +} + +static Int +p_rounding_mode_dynamically_changed( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.honorsigndependentroundingfpmathoption = TRUE; + return TRUE; +} + +static Int +p_use_soft_float( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.usesoftfloat = TRUE; + return TRUE; +} + +static Int +p_enable_jit_exception_handling( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.jitexceptionhandling = TRUE; + return TRUE; +} + +static Int +p_enable_jit_emit_debug_info( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfo = TRUE; + return TRUE; +} + +static Int +p_enable_jit_emit_debug_info_to_disk( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfotodisk = TRUE; + return TRUE; +} + +static Int +p_guaranteed_tail_call_opt( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.guaranteedtailcallopt = TRUE; + return TRUE; +} + +static Int +p_disable_tail_calls( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.disabletailcalls = TRUE; + return TRUE; +} + +static Int +p_enable_fast_isel( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.fastisel = TRUE; + return TRUE; +} + +static Int +p_fp_abitype( USES_REGS1 ) +{ + Term t = Deref(ARG1); + Int v; + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + v = IntOfTerm(t); + if (v < 0 || v > 2) { + // value passed by argument is out of known range (0 = default; 1 = soft; 2 = hard) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_targetopt.floatabitype = v; // setting 'float abi type' + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects float abi type chosen by user + if (strcmp(str, "DEFAULT") == 0) v = 0; + else if (strcmp(str, "SOFT") == 0) v = 1; + else if (strcmp(str, "HARD") == 0) v = 2; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_targetopt.floatabitype = v; // setting 'float abi type' + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"fp_abitype"); + return FALSE; + } +} + +static Int +p_default_fp_abitype( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_targetopt.floatabitype = 0; + return TRUE; +} + +static Int +p_engine_opt_level( USES_REGS1 ) +{ + Term t = Deref(ARG1); + Int v; + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + v = IntOfTerm(t); + if (v < 0 || v > 3) { + // value passed by argument is out of known range (0 = none; 1 = less; 2 = default; 3 = aggressive) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_enginebuilder.engineoptlevel = v; // setting 'engine opt level' + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects engine opt level chosen by user + if (strcmp(str, "NONE") == 0) v = 0; + else if (strcmp(str, "LESS") == 0) v = 1; + else if (strcmp(str, "DEFAULT") == 0) v = 2; + else if (strcmp(str, "AGGRESSIVE") == 0) v = 3; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_enginebuilder.engineoptlevel = v; // setting 'engine opt level' + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"engine_opt_level"); + return FALSE; + } +} + +static Int +p_reset_engine_opt_level( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_enginebuilder.engineoptlevel = 3; + return TRUE; +} + +static Int +p_relocmodel( USES_REGS1 ) +{ + Term t = Deref(ARG1); + Int v; + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + v = IntOfTerm(t); + if (v < 0 || v > 3) { + // value passed by argument is out of known range (0 = default; 1 = static; 2 = PIC; 3 = DynamicNoPIC) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_enginebuilder.relocmodel = v; // setting 'reloc model' + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects reloc model chosen by user + if (strcmp(str, "DEFAULT") == 0) v = 0; + else if (strcmp(str, "STATIC") == 0) v = 1; + else if (strcmp(str, "PIC") == 0) v = 2; + else if (strcmp(str, "DYNAMICNOPIC") == 0) v = 3; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_enginebuilder.relocmodel = v; // setting 'reloc model' + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"relocmodel"); + return FALSE; + } +} + +static Int +p_reset_relocmodel( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_enginebuilder.relocmodel = 0; + return TRUE; +} + +static Int +p_codemodel( USES_REGS1 ) +{ + Term t = Deref(ARG1); + Int v; + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + v = IntOfTerm(t); + if (v < 0 || v > 5) { + // value passed by argument is out of known range (0 = default; 1 = JITDefault; 2 = small; 3 = kernel; 4 = medium; 5 = large) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_enginebuilder.codemodel = v; // setting 'code model' + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects code chosen by user + if (strcmp(str, "DEFAULT") == 0) v = 0; + else if (strcmp(str, "JITDEFAULT") == 0) v = 1; + else if (strcmp(str, "SMALL") == 0) v = 2; + else if (strcmp(str, "KERNEL") == 0) v = 3; + else if (strcmp(str, "MEDIUM") == 0) v = 4; + else if (strcmp(str, "LARGE") == 0) v = 5; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_enginebuilder.codemodel = v; // setting 'code model' + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"codemodel"); + return FALSE; + } +} + +static Int +p_reset_codemodel( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_enginebuilder.codemodel = 1; + return TRUE; +} + +static Int +p_enable_mcjit( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_enginebuilder.usemcjit = 1; + return TRUE; +} + +static Int +p_disable_mcjit( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_enginebuilder.usemcjit = 0; + return TRUE; +} + +static Int +p_register_allocator( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + Int v = IntOfTerm(t); + if (v < 0 || v > 3) { + // value passed by argument is out of known range (0 = basic; 1 = fast; 2 = greedy; 3 = PBQP) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_enginebuilder.regallocator = (enumRegAllocator)v; // setting 'register allocator' + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + enumRegAllocator v; + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects register allocator chosen by user + if (strcmp(str, "BASIC") == 0) v = REG_ALLOC_BASIC; + else if (strcmp(str, "FAST") == 0) v = REG_ALLOC_FAST; + else if (strcmp(str, "GREEDY") == 0) v = REG_ALLOC_GREEDY; + else if (strcmp(str, "PBQP") == 0) v = REG_ALLOC_PBQP; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.codegen_struc.struc_enginebuilder.regallocator = v; // setting 'register allocator' + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"register_allocator"); + return FALSE; + } +} + +static Int +p_reset_register_allocator( USES_REGS1 ) +{ + ExpEnv.codegen_struc.struc_enginebuilder.regallocator = REG_ALLOC_GREEDY; + return TRUE; +} + +#pragma GCC diagnostic pop + +void +Yap_InitJitCodegenPreds(void) +{ + Yap_InitCPred("enable_framepointer_elimination", 0, p_enable_framepointer_elimination, SafePredFlag); + Yap_InitCPred("more_precise_fp_mad_option", 0, p_more_precise_fp_mad_option, SafePredFlag); + Yap_InitCPred("excess_fp_precision", 0, p_excess_fp_precision, SafePredFlag); + Yap_InitCPred("safe_fp_math", 0, p_safe_fp_math, SafePredFlag); + Yap_InitCPred("rounding_mode_not_changed", 0, p_rounding_mode_not_changed, SafePredFlag); + Yap_InitCPred("no_use_soft_float", 0, p_no_use_soft_float, SafePredFlag); + Yap_InitCPred("disable_jit_exception_handling", 0, p_disable_jit_exception_handling, SafePredFlag); + Yap_InitCPred("disable_jit_emit_debug_info", 0, p_disable_jit_emit_debug_info, SafePredFlag); + Yap_InitCPred("disable_jit_emit_debug_info_to_disk", 0, p_disable_jit_emit_debug_info_to_disk, SafePredFlag); + Yap_InitCPred("no_guaranteed_tail_call_opt", 0, p_no_guaranteed_tail_call_opt, SafePredFlag); + Yap_InitCPred("enable_tail_calls", 0, p_enable_tail_calls, SafePredFlag); + Yap_InitCPred("disable_fast_isel", 0, p_disable_fast_isel, SafePredFlag); + Yap_InitCPred("disable_framepointer_elimination", 0, p_disable_framepointer_elimination, SafePredFlag); + Yap_InitCPred("less_precise_fp_mad_option", 0, p_less_precise_fp_mad_option, SafePredFlag); + Yap_InitCPred("no_excess_fp_precision", 0, p_no_excess_fp_precision, SafePredFlag); + Yap_InitCPred("unsafe_fp_math", 0, p_unsafe_fp_math, SafePredFlag); + Yap_InitCPred("rounding_mode_dynamically_changed", 0, p_rounding_mode_dynamically_changed, SafePredFlag); + Yap_InitCPred("use_soft_float", 0, p_use_soft_float, SafePredFlag); + Yap_InitCPred("enable_jit_exception_handling", 0, p_enable_jit_exception_handling, SafePredFlag); + Yap_InitCPred("enable_jit_emit_debug_info", 0, p_enable_jit_emit_debug_info, SafePredFlag); + Yap_InitCPred("enable_jit_emit_debug_info_to_disk", 0, p_enable_jit_emit_debug_info_to_disk, SafePredFlag); + Yap_InitCPred("guaranteed_tail_call_opt", 0, p_guaranteed_tail_call_opt, SafePredFlag); + Yap_InitCPred("disable_tail_calls", 0, p_disable_tail_calls, SafePredFlag); + Yap_InitCPred("enable_fast_isel", 0, p_enable_fast_isel, SafePredFlag); + Yap_InitCPred("fp_abitype", 1, p_fp_abitype, SafePredFlag); + Yap_InitCPred("default_fp_abitype", 0, p_default_fp_abitype, SafePredFlag); + Yap_InitCPred("engine_opt_level", 1, p_engine_opt_level, SafePredFlag); + Yap_InitCPred("reset_engine_opt_level", 0, p_reset_engine_opt_level, SafePredFlag); + Yap_InitCPred("relocmodel", 1, p_relocmodel, SafePredFlag); + Yap_InitCPred("reset_relocmodel", 0, p_reset_relocmodel, SafePredFlag); + Yap_InitCPred("codemodel", 1, p_codemodel, SafePredFlag); + Yap_InitCPred("reset_codemodel", 0, p_reset_codemodel, SafePredFlag); + Yap_InitCPred("enable_mcjit", 0, p_enable_mcjit, SafePredFlag); + Yap_InitCPred("disable_mcjit", 0, p_disable_mcjit, SafePredFlag); + Yap_InitCPred("register_allocator", 1, p_register_allocator, SafePredFlag); + Yap_InitCPred("reset_register_allocator", 0, p_reset_register_allocator, SafePredFlag); +} diff --git a/JIT/jit_configpreds.c b/JIT/jit_configpreds.c new file mode 100644 index 000000000..926d33518 --- /dev/null +++ b/JIT/jit_configpreds.c @@ -0,0 +1,730 @@ +/************************************************************************* +* * +* Extension for YAP Prolog * +* * +* Copyright G.S.Oliveira, A.F.Silva and Universidade Estadual de Maringá * +* * +* Yap Prolog was developed at NCCUP - Universidade do Porto * +* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * +* * +************************************************************************** +* * +* File: jit_configpreds.c * +* comments: JIT Compiler Configuration predicates * +* * +* Last rev: 2013-10-18 * +*************************************************************************/ + +#include "jit_predicates.hh" +#include + +// Enable any (passed by argument) execution mode +static Int p_execution_mode( USES_REGS1 ); + +// Enable 'just interpreted' mode. +static Int p_interpreted_mode( USES_REGS1 ); + +// Enable 'smart jit' mode. +static Int p_smartjit_mode( USES_REGS1 ); + +// Enable 'continuous compilation' mode. +static Int p_continuouscompilation_mode( USES_REGS1 ); + +// Enable 'just compiled' mode. +static Int p_justcompiled_mode( USES_REGS1 ); + +// Enable one (passed by argument) of all available frequency types: counter or time. Frequency bound is default. +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_frequencyty1( USES_REGS1 ); + +// Enable one (1st argument) of all available frequency types: counter and time. Frequency bound is 2nd argument +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_frequencyty2( USES_REGS1 ); + +// Enable frequency bound +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_frequency_bound( USES_REGS1 ); + +// Enable value for starting profiling +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_profiling_start_point( USES_REGS1 ); + +// Choose type of clause that can be main on traces +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_main_clause_ty( USES_REGS1 ); + +// Choose amount of compilation threads +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_compilation_threads( USES_REGS1 ); + +// Enable recompilation +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_enable_recompilation( USES_REGS1 ); + +// Disable recompilation +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_disable_recompilation( USES_REGS1 ); + +// Just code interpretation. Don't compile +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_only_profiled_interpreter( USES_REGS1 ); + +// Disable 'p_only_profiled_interpreter' +// Just for 'smart jit' or 'continuous compilation' mode +static Int p_noonly_profiled_interpreter( USES_REGS1 ); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wimplicit-function-declaration" + +static Int +p_execution_mode( USES_REGS1 ) +{ + enumExecModes mode; + // valid values for ARG1 are 'integer' and 'atom' + Term t = Deref(ARG1); + if (IsIntTerm(t)) { + // ARG1 is integer + Int v = IntOfTerm(t); + if (v < 0 || v > 3) { + // value passed by argument is out of known range (valid values are: 0 -- interpreted; 1 -- smart jit; 2 -- continuous compilation; 3 -- just compiled) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + // storing mode + mode = (enumExecModes)v; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting mode according to 'str' + if (strcmp(str, "INTERPRETED") == 0) mode = JUST_INTERPRETED; + else if (strcmp(str, "SMARTJIT") == 0) mode = SMART_JIT; + else if (strcmp(str, "CONTINUOUSCOMPILATION") == 0) mode = CONTINUOUS_COMPILATION; + else if (strcmp(str, "JUSTCOMPILED") == 0) mode = JUST_COMPILED; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Execution mode"); + return FALSE; + } + + // setting execution mode + ExpEnv.config_struc.execution_mode = mode; + + /* setting execution mode parameters */ + switch (mode) { + case JUST_INTERPRETED: + { + if (Yap_ExecutionMode == INTERPRETED) { + // execution mode only can be 'JUST_INTERPRETED' if 'Yap_ExecutionMode == INTERPRETED' (passing -J0 on command line) + // 'JUST_INTERPRETED' does not use these parameters + ExpEnv.config_struc.frequency_type = NO_FREQ; + ExpEnv.config_struc.frequency_bound = 0.0; + ExpEnv.config_struc.profiling_startp = 0.0; + ExpEnv.config_struc.mainclause_ty = UNUSED; + ExpEnv.config_struc.compilation_threads = 0; +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) + fprintf(stderr," YAP Execution mode changed to INTERPRETED!!\n"); +#endif + } + else { + // 'Yap_ExecutionMode' is not compatible + Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"INTERPRETED"); + return FALSE; + } + } + break; + case SMART_JIT: + { + if (Yap_ExecutionMode == MIXED_MODE) { + // execution mode only can be 'SMART_JIT' if 'Yap_ExecutionMode == MIXED_MODE' (passing -J1 on command line) + ExpEnv.config_struc.frequency_type = COUNTER; + ExpEnv.config_struc.frequency_bound = 1024.0; + ExpEnv.config_struc.profiling_startp = 0.72; + ExpEnv.config_struc.mainclause_ty = HOT_AND_CALLEE; + ExpEnv.config_struc.compilation_threads = 0; +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) + fprintf(stderr," YAP Execution mode changed to SMART JIT!!\n"); +#endif + } + else { + // 'Yap_ExecutionMode' is not compatible + Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"SMART JIT"); + return FALSE; + } + } + break; + case CONTINUOUS_COMPILATION: + { + if (Yap_ExecutionMode == MIXED_MODE) { + // execution mode only can be 'CONTINUOUS_COMPILATION' if 'Yap_ExecutionMode == MIXED_MODE' (passing -J1 on command line) + ExpEnv.config_struc.frequency_type = COUNTER; + ExpEnv.config_struc.frequency_bound = 1024.0; + ExpEnv.config_struc.profiling_startp = 0.72; + ExpEnv.config_struc.mainclause_ty = HOT_AND_CALLEE; + ExpEnv.config_struc.compilation_threads = ExpEnv.config_struc.ncores-1; +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) + fprintf(stderr," YAP Execution mode changed to CONTINUOUS COMPILATION!!\n"); +#endif + } + else { + // 'Yap_ExecutionMode' is not compatible + Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"CONTINUOUS COMPILATION"); + return FALSE; + } + } + break; + case JUST_COMPILED: + { + if (Yap_ExecutionMode == COMPILED) { + // execution mode only can be 'JUST_COMPILED' if 'Yap_ExecutionMode == COMPILED' (passing -J2 on command line) + // 'JUST_COMPILED' does not use these parameters + ExpEnv.config_struc.frequency_type = NO_FREQ; + ExpEnv.config_struc.frequency_bound = 0.0; + ExpEnv.config_struc.profiling_startp = 0.0; + ExpEnv.config_struc.mainclause_ty = UNUSED; + ExpEnv.config_struc.compilation_threads = 0; +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) + fprintf(stderr," YAP Execution mode changed to JUST COMPILED!!\n"); +#endif + } + else { + // 'Yap_ExecutionMode' is not compatible + Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"JUST COMPILED"); + return FALSE; + } + } + break; + } + /***/ + return TRUE; +} + +static Int +p_interpreted_mode( USES_REGS1 ) +{ + // Same as 'execution_mode(0)' or 'execution_mode(interpreted)' + if (Yap_ExecutionMode == INTERPRETED) { + // execution mode only can be 'JUST_INTERPRETED' if 'Yap_ExecutionMode == INTERPRETED' (passing -J0 on command line) + ExpEnv.config_struc.execution_mode = JUST_INTERPRETED; // setting mode + ExpEnv.config_struc.frequency_type = NO_FREQ; // does not use frequency type + ExpEnv.config_struc.frequency_bound = 0.0; // does not use frequency bound + ExpEnv.config_struc.profiling_startp = 0.0; // does not use profiling startp + ExpEnv.config_struc.mainclause_ty = UNUSED; // does not use mainclause ty + ExpEnv.config_struc.compilation_threads = 0; // does not use compilation threads +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) + fprintf(stderr," YAP Execution mode changed to INTERPRETED!!\n"); +#endif + return TRUE; + } + else { + // 'Yap_ExecutionMode' is not compatible + Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"INTERPRETED"); + return FALSE; + } +} + +static Int +p_smartjit_mode( USES_REGS1 ) +{ + // Same as 'execution_mode(1)' or 'execution_mode(smartjit)' + if (Yap_ExecutionMode == MIXED_MODE) { + // execution mode only can be 'SMART_JIT' if 'Yap_ExecutionMode == MIXED_MODE' (passing -J1 on command line) + ExpEnv.config_struc.execution_mode = SMART_JIT; // setting mode + ExpEnv.config_struc.frequency_type = COUNTER; // default value + ExpEnv.config_struc.frequency_bound = 1024.0; // default value + ExpEnv.config_struc.profiling_startp = 0.72; // default value + ExpEnv.config_struc.mainclause_ty = HOT_AND_CALLEE; // default value + /* does not use compilation threads */ + ExpEnv.config_struc.compilation_threads = 0; + ExpEnv.config_struc.threaded_compiler_threads = NULL; + ExpEnv.config_struc.posthreads = NULL; + /***/ +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) + fprintf(stderr," YAP Execution mode changed to SMART JIT!!\n"); + if (ExpEnv.debug_struc.pprint_intermediate.print_to_file) + strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "trace"); +#endif + return TRUE; + } + else { + // 'Yap_ExecutionMode' is not compatible + Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"SMART JIT"); + return FALSE; + } +} + +static Int +p_continuouscompilation_mode( USES_REGS1 ) +{ + // Same as 'execution_mode(2)' or 'execution_mode(continuouscompilation)' + if (Yap_ExecutionMode == MIXED_MODE) { + // execution mode only can be 'CONTINUOUS_COMPILATION' if 'Yap_ExecutionMode == MIXED_MODE' (passing -J1 on command line) + ExpEnv.config_struc.execution_mode = CONTINUOUS_COMPILATION; // setting mode + ExpEnv.config_struc.frequency_type = COUNTER; // default value + ExpEnv.config_struc.frequency_bound = 1024.0; // default value + ExpEnv.config_struc.profiling_startp = 0.72; // default value + ExpEnv.config_struc.mainclause_ty = HOT_AND_CALLEE; // default value + ExpEnv.config_struc.compilation_threads = ExpEnv.config_struc.ncores-1; // default value for this mode + /* initializing structures which will handle compilation threads */ + { + if (ExpEnv.config_struc.threaded_compiler_threads) free(ExpEnv.config_struc.threaded_compiler_threads); + if (ExpEnv.config_struc.posthreads) free(ExpEnv.config_struc.posthreads); + ExpEnv.config_struc.threaded_compiler_threads = (pthread_t*)malloc(ExpEnv.config_struc.compilation_threads*sizeof(pthread_t)); + ExpEnv.config_struc.posthreads = (CELL*)malloc(ExpEnv.config_struc.compilation_threads*sizeof(CELL)); + int i; + for (i = 0; i < ExpEnv.config_struc.compilation_threads; i++) ExpEnv.config_struc.posthreads[i] = 0; + } + /***/ +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) + fprintf(stderr," YAP Execution mode changed to CONTINUOUS COMPILATION!!\n"); + if (ExpEnv.debug_struc.pprint_intermediate.print_to_file) + strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "trace"); +#endif + return TRUE; + } + else { + // 'Yap_ExecutionMode' is not compatible + Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"CONTINUOUS COMPILATION"); + return FALSE; + } +} + +static Int +p_justcompiled_mode( USES_REGS1 ) +{ + // Same as 'execution_mode(3)' or 'execution_mode(justcompiled)' + if (Yap_ExecutionMode == COMPILED) { + // execution mode only can be 'JUST_COMPILED' if 'Yap_ExecutionMode == COMPILED' (passing -J2 on command line) + ExpEnv.config_struc.execution_mode = JUST_COMPILED; // setting mode + ExpEnv.config_struc.frequency_type = NO_FREQ; // does not use frequency type + ExpEnv.config_struc.frequency_bound = 0.0; // does not use frequency bound + ExpEnv.config_struc.profiling_startp = 0.0; // does not use profiling startp + ExpEnv.config_struc.mainclause_ty = UNUSED; // does not use mainclause ty + ExpEnv.config_struc.compilation_threads = 0; // does not use compilation threads +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) + fprintf(stderr," YAP Execution mode changed to JUST COMPILED!!\n"); + if (ExpEnv.debug_struc.pprint_intermediate.print_to_file) + strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "clause"); +#endif + return TRUE; + } + else { + // 'Yap_ExecutionMode' is not compatible + Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"JUST COMPILED"); + return FALSE; + } +} + +static Int +p_frequencyty1( USES_REGS1 ) +{ + // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes + if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { + Term t = Deref(ARG1); + // valid value for ARG1 is just 'atom' + if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detectng frequency type according to 'str' + if (strcmp(str, "COUNTER") == 0 || strcmp(str, "COUNT") == 0) { + ExpEnv.config_struc.frequency_type = COUNTER; // setting frequency type to 'counter' + ExpEnv.config_struc.frequency_bound = 1024.0; // if 'counter', frequency bound is '1024.0' + return TRUE; + } + else if (strcmp(str, "TIME") == 0 || strcmp(str, "TIMING") == 0) { + ExpEnv.config_struc.frequency_type = TIME; // setting frequency type to 'time' + ExpEnv.config_struc.frequency_bound = 0.02; // if 'time', frequency bound is '0.02' + return TRUE; + } + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + } + else { + // ARG1 is not an atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Frequency type"); + return FALSE; + } + } + else { + // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' + Yap_NilError(INCOMPATIBLEMODE_WARNING,""); + return FALSE; + } +} + +static Int +p_frequencyty2( USES_REGS1 ) +{ + // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes + if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { + Term t = Deref(ARG1); + // valid value for ARG1 is just 'atom' + if (IsAtomTerm(t)) { + Term u = Deref(ARG2); + // valid values for ARG2 are 'integer' and 'float' + if (IsIntTerm(u) || IsFloatTerm(u)) { + // ARG1 is atom and ARG2 is integer or float + int i = 0, j = 0; + char *tmp; + // getting string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Making upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // getting ARG2 value + Float v; + if (IsIntTerm(u)) v = (Float)IntOfTerm(u); + if (IsFloatTerm(u)) v = FloatOfTerm(u); + + // setting 'frequency type' and 'frequency bound' if 'COUNTER' + if (strcmp(str, "COUNTER") == 0 || strcmp(str, "COUNT") == 0) { + if (v < 20.0) { + // Very low frequency bound to apply on 'COUNTER' + fprintf(stderr,"%.2f is a very low value for the active frequency type. Reconsider its value...\n", v); + return FALSE; + } + ExpEnv.config_struc.frequency_type = COUNTER; + ExpEnv.config_struc.frequency_bound = roundf(v); + return TRUE; + } + // setting 'frequency type' and 'frequency bound' if 'TIME' + else if (strcmp(str, "TIME") == 0 || strcmp(str, "TIMING") == 0) { + if (v <= 0.0 || v > 0.49) { + // Very low frequency bound to apply on 'COUNTER' + fprintf(stderr,"%.2f is an invalid or a very high value for the active frequency type. Reconsider its value...\n", v); + return FALSE; + } + ExpEnv.config_struc.frequency_type = TIME; + ExpEnv.config_struc.frequency_bound = v; + return TRUE; + } + else { + // value passed by argument (ARG1) is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + } + else { + // ARG2 is not an 'integer' or 'float' + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"frequencyty/2 (2nd arg)"); + return FALSE; + } + } + else { + // ARG1 is not an atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"frequencyty/2 (1st arg)"); + return FALSE; + } + } + else { + // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' + Yap_NilError(INCOMPATIBLEMODE_WARNING,""); + return FALSE; + } +} + +static Int +p_frequency_bound( USES_REGS1 ) +{ + // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes + if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { + Term t = Deref(ARG1); + // valid values for ARG1 are 'integer' and 'float' + if (IsIntTerm(t) || IsFloatTerm(t)) { + // ARG1 is integer or float + // getting ARG1 value + Float v; + if (IsIntTerm(t)) v = (Float)IntOfTerm(t); + if (IsFloatTerm(t)) v = FloatOfTerm(t); + + // setting 'frequency bound' if 'frequency type' is 'COUNTER' + if (ExpEnv.config_struc.frequency_type == COUNTER) { + if (v < 20.0) { + fprintf(stderr,"%.2f is a very low value for the active frequency type. Reconsider its value...\n", v); + return FALSE; + } + ExpEnv.config_struc.frequency_bound = roundf(v); + return TRUE; + } + // setting 'frequency bound' if 'frequency type' is 'TIME' + else { + if (v <= 0.0 || v > 0.49) { + fprintf(stderr,"%.2f is an invalid or a very high value for the active frequency type. Reconsider its value...\n", v); + return FALSE; + } + ExpEnv.config_struc.frequency_bound = v; + return TRUE; + } + } + else { + // ARG1 is not an 'integer' or 'float' + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"frequency_bound/1 (1st arg)"); + return FALSE; + } + } + else { + // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' + Yap_NilError(INCOMPATIBLEMODE_WARNING,""); + return FALSE; + } +} + +static Int +p_profiling_start_point( USES_REGS1 ) +{ + // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes + if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { + Term t = Deref(ARG1); + Float v; + // valid value for ARG1 is just 'float' + if (IsFloatTerm(t)) { + v = FloatOfTerm(t); + if (v < 0.0 || v >= 1.0) { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.config_struc.profiling_startp = v; + return TRUE; + } + else { + // ARG1 is not float + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"profiling_start_point/1 (1st arg)"); + return FALSE; + } + } + else { + // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' + Yap_NilError(INCOMPATIBLEMODE_WARNING,""); + return FALSE; + } +} + +static Int +p_main_clause_ty( USES_REGS1 ) +{ + // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes + if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { + Term t = Deref(ARG1); + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + Int v; + v = IntOfTerm(t); + if (v < 0 || v > 3) { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) { + switch(v) { + case 0: + fprintf(stderr," Type of main clause was changed to JUST HOT!!\n"); + break; + case 1: + fprintf(stderr," Type of main clause was changed to HOT AND CALLEE!!\n"); + break; + case 2: + fprintf(stderr," Type of main clause was changed to HOT AND GREATER!!\n"); + break; + case 3: + fprintf(stderr," Type of main clause was changed to HOT AND FEWER!!\n"); + break; + } + } +#endif + // setting 'mainclause_ty' -- I should de add '1' because the first enum of 'enumMainClauseType' is 'UNUSED', used just for control + ExpEnv.config_struc.mainclause_ty = (enumMainClauseType)(v+1); + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + enumMainClauseType v; + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting mainclause type chosen by user according to 'str' + if (strcmp(str, "JUSTHOT") == 0) { + v = JUST_HOT; +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to JUST HOT!!\n"); +#endif + } + else if (strcmp(str, "HOTANDCALLEE") == 0) { + v = HOT_AND_CALLEE; +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to HOT AND CALLEE!!\n"); +#endif + } + else if (strcmp(str, "HOTANDGREATER") == 0) { + v = HOT_AND_GREATER; +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to HOT AND GREATER!!\n"); +#endif + } + else if (strcmp(str, "HOTANDFEWER") == 0) { + v = HOT_AND_FEWER; +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to HOT AND FEWER!!\n"); +#endif + } + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.config_struc.mainclause_ty = v; + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"main_clause_ty/1 (1st arg)"); + return FALSE; + } + } + else { + // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' + Yap_NilError(INCOMPATIBLEMODE_WARNING,""); + return FALSE; + } +} + +static Int +p_compilation_threads( USES_REGS1 ) +{ + // this predicate works only 'CONTINUOUS_COMPILATION' mode + if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { + Term t = Deref(ARG1); + Int v; + // valid value for ARG1 is 'integer' (because it defines number of threads) + if (IsIntTerm(t)) { + // ARG1 is integer + v = IntOfTerm(t); + if (v < 1) { + // ERROR: number of threads is negative!! + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + if (v >= ExpEnv.config_struc.ncores) { + // WARNING: number of threads is not ideal -- real parallelism won't occur!! + fprintf(stderr, + " It was detected %ld cores on this computer, therefore it is ideally to set just %ld compilation thread. Reconsider its value...\n", + ExpEnv.config_struc.ncores, ExpEnv.config_struc.ncores-1); + } + // setting compilation threads + ExpEnv.config_struc.compilation_threads = v; + + /* initializing structures which will handle compilation threads */ + { + if (ExpEnv.config_struc.threaded_compiler_threads) free(ExpEnv.config_struc.threaded_compiler_threads); + if (ExpEnv.config_struc.posthreads) free(ExpEnv.config_struc.posthreads); + ExpEnv.config_struc.threaded_compiler_threads = (pthread_t*)malloc(v*sizeof(pthread_t)); + ExpEnv.config_struc.posthreads = (CELL*)malloc(v*sizeof(CELL)); + int i; + for (i = 0; i < v; i++) ExpEnv.config_struc.posthreads[i] = 0; + } + /***/ +#if YAP_DBG_PREDS + if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to HOT AND FEWER!!\n"); +#endif + return TRUE; + } + else { + // ARG1 is not an integer + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"compilation_threads/1 (1st arg)"); + return FALSE; + } + } + else { + // current execution mode differs of 'CONTINUOUS_COMPILATION' + Yap_NilError(INCOMPATIBLEMODE_WARNING,""); + return FALSE; + } +} + +static Int +p_enable_recompilation( USES_REGS1 ) +{ + ExpEnv.config_struc.torecompile = 1; + return TRUE; +} + +static Int +p_disable_recompilation( USES_REGS1 ) +{ + ExpEnv.config_struc.torecompile = 0; + return TRUE; +} + +static Int +p_only_profiled_interpreter( USES_REGS1 ) +{ + ExpEnv.config_struc.useonlypi = 1; + return TRUE; +} + +static Int +p_noonly_profiled_interpreter( USES_REGS1 ) +{ + ExpEnv.config_struc.useonlypi = 0; + return TRUE; +} +#pragma GCC diagnostic pop + +void +Yap_InitJitConfigPreds(void) +{ + Yap_InitCPred("execution_mode", 1, p_execution_mode, SafePredFlag); + Yap_InitCPred("interpreted_mode", 0, p_interpreted_mode, SafePredFlag); + Yap_InitCPred("smartjit_mode", 0, p_smartjit_mode, SafePredFlag); + Yap_InitCPred("continuouscompilation_mode", 0, p_continuouscompilation_mode, SafePredFlag); + Yap_InitCPred("justcompiled_mode", 0, p_justcompiled_mode, SafePredFlag); + Yap_InitCPred("frequencyty1", 1, p_frequencyty1, SafePredFlag); + Yap_InitCPred("frequencyty2", 2, p_frequencyty2, SafePredFlag); + Yap_InitCPred("frequency_bound", 1, p_frequency_bound, SafePredFlag); + Yap_InitCPred("profiling_start_point", 1, p_profiling_start_point, SafePredFlag); + Yap_InitCPred("main_clause_ty", 1, p_main_clause_ty, SafePredFlag); + Yap_InitCPred("compilation_threads", 1, p_compilation_threads, SafePredFlag); + Yap_InitCPred("enable_recompilation", 0, p_enable_recompilation, SafePredFlag); + Yap_InitCPred("disable_recompilation", 0, p_disable_recompilation, SafePredFlag); + Yap_InitCPred("only_profiled_interpreter", 0, p_only_profiled_interpreter, SafePredFlag); + Yap_InitCPred("noonly_profiled_interpreter", 0, p_noonly_profiled_interpreter, SafePredFlag); +} diff --git a/JIT/jit_debugpreds.c b/JIT/jit_debugpreds.c new file mode 100644 index 000000000..99247c5c9 --- /dev/null +++ b/JIT/jit_debugpreds.c @@ -0,0 +1,2476 @@ +/************************************************************************* +* * +* Extension for YAP Prolog * +* * +* Copyright G.S.Oliveira, A.F.Silva and Universidade Estadual de Maringá * +* * +* Yap Prolog was developed at NCCUP - Universidade do Porto * +* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * +* * +************************************************************************** +* * +* File: jit_debugpreds.c * +* comments: Debugging predicates * +* * +* Last rev: 2013-10-18 * +*************************************************************************/ + +#include "jit_predicates.hh" + +static Int p_no_print_instruction( USES_REGS1 ); +static Int p_no_print_basic_instruction( USES_REGS1 ); +static Int p_no_print_std_instruction( USES_REGS1 ); +static Int p_no_print_standard_instruction( USES_REGS1 ); +static Int p_print_instruction( USES_REGS1 ); +static Int p_print_basic_instruction( USES_REGS1 ); +static Int p_print_std_instruction( USES_REGS1 ); +static Int p_print_standard_instruction( USES_REGS1 ); +static Int p_print_instruction_msg_before( USES_REGS1 ); +static Int p_print_basic_instruction_msg_before( USES_REGS1 ); +static Int p_print_std_instruction_msg_before( USES_REGS1 ); +static Int p_print_standard_instruction_msg_before( USES_REGS1 ); +static Int p_print_instruction_msg_after( USES_REGS1 ); +static Int p_print_basic_instruction_msg_after( USES_REGS1 ); +static Int p_print_std_instruction_msg_after( USES_REGS1 ); +static Int p_print_standard_instruction_msg_after( USES_REGS1 ); +static Int p_print_instruction3( USES_REGS1 ); +static Int p_print_basic_instruction3( USES_REGS1 ); +static Int p_print_std_instruction3( USES_REGS1 ); +static Int p_print_standard_instruction3( USES_REGS1 ); +static Int p_print_profiled_instruction( USES_REGS1 ); +static Int p_print_traced_instruction( USES_REGS1 ); +static Int p_print_pfd_instruction( USES_REGS1 ); +static Int p_print_profiled_instruction_msg_before( USES_REGS1 ); +static Int p_print_traced_instruction_msg_before( USES_REGS1 ); +static Int p_print_pfd_instruction_msg_before( USES_REGS1 ); +static Int p_print_profiled_instruction_msg_after( USES_REGS1 ); +static Int p_print_traced_instruction_msg_after( USES_REGS1 ); +static Int p_print_pfd_instruction_msg_after( USES_REGS1 ); +static Int p_print_profiled_instruction3( USES_REGS1 ); +static Int p_print_traced_instruction3( USES_REGS1 ); +static Int p_print_pfd_instruction3( USES_REGS1 ); +static Int p_print_native_instruction( USES_REGS1 ); +static Int p_print_ntv_instruction( USES_REGS1 ); +static Int p_print_native_instruction_msg_before( USES_REGS1 ); +static Int p_print_ntv_instruction_msg_before( USES_REGS1 ); +static Int p_print_native_instruction_msg_after( USES_REGS1 ); +static Int p_print_ntv_instruction_msg_after( USES_REGS1 ); +static Int p_print_native_instruction3( USES_REGS1 ); +static Int p_print_ntv_instruction3( USES_REGS1 ); +static Int p_no_print_basic_block( USES_REGS1 ); +static Int p_no_print_basicblock( USES_REGS1 ); +static Int p_no_print_bb( USES_REGS1 ); +static Int p_print_basic_block( USES_REGS1 ); +static Int p_print_basicblock( USES_REGS1 ); +static Int p_print_bb( USES_REGS1 ); +static Int p_print_basic_block_msg_before( USES_REGS1 ); +static Int p_print_basicblock_msg_before( USES_REGS1 ); +static Int p_print_bb_msg_before( USES_REGS1 ); +static Int p_print_basic_block_msg_after( USES_REGS1 ); +static Int p_print_basicblock_msg_after( USES_REGS1 ); +static Int p_print_bb_msg_after( USES_REGS1 ); +static Int p_print_basic_block3( USES_REGS1 ); +static Int p_print_basicblock3( USES_REGS1 ); +static Int p_print_bb3( USES_REGS1 ); +static Int p_print_native_basic_block( USES_REGS1 ); +static Int p_print_native_basicblock( USES_REGS1 ); +static Int p_print_native_bb( USES_REGS1 ); +static Int p_print_native_basic_block_msg_before( USES_REGS1 ); +static Int p_print_native_basicblock_msg_before( USES_REGS1 ); +static Int p_print_native_bb_msg_before( USES_REGS1 ); +static Int p_print_native_basic_block_msg_after( USES_REGS1 ); +static Int p_print_native_basicblock_msg_after( USES_REGS1 ); +static Int p_print_native_bb_msg_after( USES_REGS1 ); +static Int p_print_native_basic_block3( USES_REGS1 ); +static Int p_print_native_basicblock3( USES_REGS1 ); +static Int p_print_native_bb3( USES_REGS1 ); +static Int p_no_print_clause( USES_REGS1 ); +static Int p_print_clause( USES_REGS1 ); +static Int p_no_print_intermediate( USES_REGS1 ); +static Int p_print_intermediate( USES_REGS1 ); +static Int p_print_intermediate_to_std( USES_REGS1 ); +static Int p_print_intermediate_to_std1( USES_REGS1 ); +static Int p_print_intermediate_to_file( USES_REGS1 ); +static Int p_print_intermediate_to_file1( USES_REGS1 ); +static Int p_no_print_llva( USES_REGS1 ); +static Int p_print_llva_before( USES_REGS1 ); +static Int p_print_llva_after( USES_REGS1 ); +static Int p_no_print_me( USES_REGS1 ); +static Int p_print_me( USES_REGS1 ); +static Int p_default_debug( USES_REGS1 ); +static Int p_print_default_predicate_msgs( USES_REGS1 ); +static Int p_print_all_predicate_msgs( USES_REGS1 ); +static Int p_print_info_predicate_msgs( USES_REGS1 ); +static Int p_print_success_predicate_msgs( USES_REGS1 ); +static Int p_print_warning_predicate_msgs( USES_REGS1 ); +static Int p_print_error_predicate_msgs( USES_REGS1 ); +static Int p_no_print_all_predicate_msgs( USES_REGS1 ); +static Int p_no_print_info_predicate_msgs( USES_REGS1 ); +static Int p_no_print_success_predicate_msgs( USES_REGS1 ); +static Int p_no_print_warning_predicate_msgs( USES_REGS1 ); +static Int p_no_print_error_predicate_msgs( USES_REGS1 ); +static Int p_print_predicate_msgs( USES_REGS1 ); +static Int p_exit_on_warning( USES_REGS1 ); +static Int p_disable_on_warning( USES_REGS1 ); +static Int p_exit_on_error( USES_REGS1 ); +static Int p_no_exit_on_warning( USES_REGS1 ); +static Int p_enable_on_warning( USES_REGS1 ); +static Int p_no_exit_on_error( USES_REGS1 ); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wimplicit-function-declaration" + +static Int +p_no_print_instruction( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + if (ExpEnv.debug_struc.pyaam_##OP.msg_before) free((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before); \ + if (ExpEnv.debug_struc.pyaam_##OP.msg_after) free((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after); \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)NO_PLACE; \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = 0; \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = 0; \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_instruction / no_print_basic_instruction / no_print_std_instruction / no_print_standard_instruction"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_instruction / no_print_basic_instruction / no_print_std_instruction / no_print_standard_instruction"); + return FALSE; + } +} + +static Int +p_no_print_basic_instruction( USES_REGS1 ) +{ + return p_no_print_instruction(); +} + +static Int +p_no_print_std_instruction( USES_REGS1 ) +{ + return p_no_print_instruction(); +} + +static Int +p_no_print_standard_instruction( USES_REGS1 ) +{ + return p_no_print_instruction(); +} + +static Int +p_print_instruction( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_INTERPRETER; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_INTERPRETER; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); + return FALSE; + } +} + +static Int +p_print_basic_instruction( USES_REGS1 ) +{ + return p_print_instruction(); +} + +static Int +p_print_std_instruction( USES_REGS1 ) +{ + return p_print_instruction(); +} + +static Int +p_print_standard_instruction( USES_REGS1 ) +{ + return p_print_instruction(); +} + +static Int +p_print_instruction_msg_before( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_before / print_basic_instruction_msg_before / print_std_instruction_msg_before / print_standard_instruction_msg_before"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_INTERPRETER; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_INTERPRETER; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_before / print_basic_instruction_msg_before / print_std_instruction_msg_before / print_standard_instruction_msg_before"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_before / print_basic_instruction_msg_before / print_std_instruction_msg_before / print_standard_instruction_msg_before"); + return FALSE; + } +} + +static Int +p_print_basic_instruction_msg_before( USES_REGS1 ) +{ + return p_print_instruction_msg_before(); +} + +static Int +p_print_std_instruction_msg_before( USES_REGS1 ) +{ + return p_print_instruction_msg_before(); +} + +static Int +p_print_standard_instruction_msg_before( USES_REGS1 ) +{ + return p_print_instruction_msg_before(); +} + +static Int +p_print_instruction_msg_after( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_after / print_basic_instruction_msg_after / print_std_instruction_msg_after / print_standard_instruction_msg_after"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_INTERPRETER; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_INTERPRETER; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ + strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_after / print_basic_instruction_msg_after / print_std_instruction_msg_after / print_standard_instruction_msg_after"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_after / print_basic_instruction_msg_after / print_std_instruction_msg_after / print_standard_instruction_msg_after"); + return FALSE; + } +} + +static Int +p_print_basic_instruction_msg_after( USES_REGS1 ) +{ + return p_print_instruction_msg_after(); +} + +static Int +p_print_std_instruction_msg_after( USES_REGS1 ) +{ + return p_print_instruction_msg_after(); +} + +static Int +p_print_standard_instruction_msg_after( USES_REGS1 ) +{ + return p_print_instruction_msg_after(); +} + +static Int +p_print_instruction3( USES_REGS1 ) +{ + Term t = Deref(ARG3); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); + return FALSE; + } + + t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_INTERPRETER; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_INTERPRETER; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ + strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); + return FALSE; + } +} + +static Int +p_print_basic_instruction3( USES_REGS1 ) +{ + return p_print_instruction3(); +} + +static Int +p_print_std_instruction3( USES_REGS1 ) +{ + return p_print_instruction3(); +} + +static Int +p_print_standard_instruction3( USES_REGS1 ) +{ + return p_print_instruction3(); +} + +static Int +p_print_profiled_instruction( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_PROFILED_INTERPRETER; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_PROFILED_INTERPRETER; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction / print_traced_instruction / print_pfd_instruction"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction / print_traced_instruction / print_pfd_instruction"); + return FALSE; + } +} + +static Int +p_print_traced_instruction( USES_REGS1 ) +{ + return p_print_profiled_instruction(); +} + +static Int +p_print_pfd_instruction( USES_REGS1 ) +{ + return p_print_profiled_instruction(); +} + +static Int +p_print_profiled_instruction_msg_before( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_before / print_traced_instruction_msg_before / print_pfd_instruction_msg_before"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_PROFILED_INTERPRETER; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_PROFILED_INTERPRETER; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_before / print_traced_instruction_msg_before / print_pfd_instruction_msg_before"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_before / print_traced_instruction_msg_before / print_pfd_instruction_msg_before"); + return FALSE; + } +} + +static Int +p_print_traced_instruction_msg_before( USES_REGS1 ) +{ + return p_print_profiled_instruction_msg_before(); +} + +static Int +p_print_pfd_instruction_msg_before( USES_REGS1 ) +{ + return p_print_profiled_instruction_msg_before(); +} + +static Int +p_print_profiled_instruction_msg_after( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_after / print_traced_instruction_msg_after / print_pfd_instruction_msg_after"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_PROFILED_INTERPRETER; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_PROFILED_INTERPRETER; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ + strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_after / print_traced_instruction_msg_after / print_pfd_instruction_msg_after"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_after / print_traced_instruction_msg_after / print_pfd_instruction_msg_after"); + return FALSE; + } +} + +static Int +p_print_traced_instruction_msg_after( USES_REGS1 ) +{ + return p_print_profiled_instruction_msg_after(); +} + +static Int +p_print_pfd_instruction_msg_after( USES_REGS1 ) +{ + return p_print_profiled_instruction_msg_after(); +} + +static Int +p_print_profiled_instruction3( USES_REGS1 ) +{ + Term t = Deref(ARG3); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction/ print_traced_instruction / print_pfd_instruction"); + return FALSE; + } + + t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction/ print_traced_instruction / print_pfd_instruction"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_PROFILED_INTERPRETER; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_PROFILED_INTERPRETER; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ + strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction/ print_traced_instruction / print_pfd_instruction"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction/ print_traced_instruction / print_pfd_instruction"); + return FALSE; + } +} + +static Int +p_print_traced_instruction3( USES_REGS1 ) +{ + return p_print_profiled_instruction3(); +} + +static Int +p_print_pfd_instruction3( USES_REGS1 ) +{ + return p_print_profiled_instruction3(); +} + +static Int +p_print_native_instruction( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_NATIVE; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_NATIVE; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); + return FALSE; + } +} + +static Int +p_print_ntv_instruction( USES_REGS1 ) +{ + return p_print_native_instruction(); +} + +static Int +p_print_native_instruction_msg_before( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_before / print_ntv_instruction_msg_before"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_NATIVE; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_NATIVE; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_before / print_ntv_instruction_msg_before"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_before / print_ntv_instruction_msg_before"); + return FALSE; + } +} + +static Int +p_print_ntv_instruction_msg_before( USES_REGS1 ) +{ + return p_print_native_instruction_msg_before(); +} + +static Int +p_print_native_instruction_msg_after( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_after / print_ntv_instruction_msg_after"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_NATIVE; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_NATIVE; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ + strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_after / print_ntv_instruction_msg_after"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_after / print_ntv_instruction_msg_after"); + return FALSE; + } +} + +static Int +p_print_ntv_instruction_msg_after( USES_REGS1 ) +{ + return p_print_native_instruction_msg_after(); +} + +static Int +p_print_native_instruction3( USES_REGS1 ) +{ + Term t = Deref(ARG3); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); + return FALSE; + } + + t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strop = (char*)malloc(100*sizeof(char)); + #define OPCODE(OP,TYPE) \ + strcpy(strop, #OP); \ + UPPER_ENTRY(strop); \ + if (strcmp(str, strop) == 0) { \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ + if (!ExpEnv.debug_struc.pyaam_##OP.print) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_NATIVE; \ + else \ + ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_NATIVE; \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ + strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ + strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ + } + #include "YapAppliedOpcodes.h" + #undef OPCODE + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); + return FALSE; + } +} + +static Int +p_print_ntv_instruction3( USES_REGS1 ) +{ + return p_print_native_instruction3(); +} + +static Int +p_no_print_basic_block( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strbb = (char*)malloc(100*sizeof(char)); + #define BBLOCK(BB) \ + strcpy(strbb, #BB); \ + UPPER_ENTRY(strbb); \ + if (strcmp(str, strbb) == 0) { \ + if (ExpEnv.debug_struc.pbbs_##BB.msg_before) free((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before); \ + if (ExpEnv.debug_struc.pbbs_##BB.msg_after) free((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after);\ + ExpEnv.debug_struc.pbbs_##BB.print = (Int)NO_PLACE; \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = 0; \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = 0; \ + } + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_basic_block / no_print_basicblock / no_print_bb"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_basic_block / no_print_basicblock / no_print_bb"); + return FALSE; + } +} + +static Int +p_no_print_basicblock( USES_REGS1 ) +{ + return p_no_print_basic_block(); +} + +static Int +p_no_print_bb( USES_REGS1 ) +{ + return p_no_print_basic_block(); +} + +static Int +p_print_basic_block( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strbb = (char*)malloc(100*sizeof(char)); + #define BBLOCK(BB) \ + strcpy(strbb, #BB); \ + UPPER_ENTRY(strbb); \ + if (strcmp(str, strbb) == 0) { \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pbbs_##BB.print) \ + ExpEnv.debug_struc.pbbs_##BB.print = ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ + else \ + ExpEnv.debug_struc.pbbs_##BB.print |= ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ + } + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); + return FALSE; + } +} + +static Int +p_print_basicblock( USES_REGS1 ) +{ + return p_print_basic_block(); +} + +static Int +p_print_bb( USES_REGS1 ) +{ + return p_print_basic_block(); +} + +static Int +p_print_basic_block_msg_before( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_before / print_basicblock_msg_before / print_bb_msg_before"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strbb = (char*)malloc(100*sizeof(char)); + #define BBLOCK(BB) \ + strcpy(strbb, #BB); \ + UPPER_ENTRY(strbb); \ + if (strcmp(str, strbb) == 0) { \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pbbs_##BB.print) \ + ExpEnv.debug_struc.pbbs_##BB.print = ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ + else \ + ExpEnv.debug_struc.pbbs_##BB.print |= ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ + } + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_before / print_basicblock_msg_before / print_bb_msg_before"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_before / print_basicblock_msg_before / print_bb_msg_before"); + return FALSE; + } +} + +static Int +p_print_basicblock_msg_before( USES_REGS1 ) +{ + return p_print_basic_block_msg_before(); +} + +static Int +p_print_bb_msg_before( USES_REGS1 ) +{ + return p_print_basic_block_msg_before(); +} + +static Int +p_print_basic_block_msg_after( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_after / print_basicblock_msg_after / print_bb_msg_after"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strbb = (char*)malloc(100*sizeof(char)); + #define BBLOCK(BB) \ + strcpy(strbb, #BB); \ + UPPER_ENTRY(strbb); \ + if (strcmp(str, strbb) == 0) { \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pbbs_##BB.print) \ + ExpEnv.debug_struc.pbbs_##BB.print = ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ + else \ + ExpEnv.debug_struc.pbbs_##BB.print |= ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ + } + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_after / print_basicblock_msg_after / print_bb_msg_after"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_after / print_basicblock_msg_after / print_bb_msg_after"); + return FALSE; + } +} + +static Int +p_print_basicblock_msg_after( USES_REGS1 ) +{ + return p_print_basic_block_msg_after(); +} + +static Int +p_print_bb_msg_after( USES_REGS1 ) +{ + return p_print_basic_block_msg_after(); +} + +static Int +p_print_basic_block3( USES_REGS1 ) +{ + Term t = Deref(ARG3); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); + return FALSE; + } + + t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strbb = (char*)malloc(100*sizeof(char)); + #define BBLOCK(BB) \ + strcpy(strbb, #BB); \ + UPPER_ENTRY(strbb); \ + if (strcmp(str, strbb) == 0) { \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pbbs_##BB.print) \ + ExpEnv.debug_struc.pbbs_##BB.print = ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ + else \ + ExpEnv.debug_struc.pbbs_##BB.print |= ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ + } + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); + return FALSE; + } +} + +static Int +p_print_basicblock3( USES_REGS1 ) +{ + return p_print_basic_block3(); +} + +static Int +p_print_bb3( USES_REGS1 ) +{ + return p_print_basic_block3(); +} + +static Int +p_print_native_basic_block( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsAtomTerm(t)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + UPPER_ENTRY(str); + if (strcmp(str, "ALL") == 0) { + #define BBLOCK(BB) \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pbbs_##BB.print) \ + ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ + else \ + ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + return TRUE; + } + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + else if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strbb = (char*)malloc(100*sizeof(char)); + #define BBLOCK(BB) \ + strcpy(strbb, #BB); \ + UPPER_ENTRY(strbb); \ + if (strcmp(str, strbb) == 0) { \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pbbs_##BB.print) \ + ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ + else \ + ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ + } + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); + return FALSE; + } +} + +static Int +p_print_native_basicblock( USES_REGS1 ) +{ + return p_print_native_basic_block(); +} + +static Int +p_print_native_bb( USES_REGS1 ) +{ + return p_print_native_basic_block(); +} + +static Int +p_print_native_basic_block_msg_before( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_before / print_native_basicblock_msg_before / print_native_bb_msg_before"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strbb = (char*)malloc(100*sizeof(char)); + #define BBLOCK(BB) \ + strcpy(strbb, #BB); \ + UPPER_ENTRY(strbb); \ + if (strcmp(str, strbb) == 0) { \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pbbs_##BB.print) \ + ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ + else \ + ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ + } + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_before / print_native_basicblock_msg_before / print_native_bb_msg_before"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_before / print_native_basicblock_msg_before / print_native_bb_msg_before"); + return FALSE; + } +} + +static Int +p_print_native_basicblock_msg_before( USES_REGS1 ) +{ + return p_print_native_basic_block_msg_before(); +} + +static Int +p_print_native_bb_msg_before( USES_REGS1 ) +{ + return p_print_native_basic_block_msg_before(); +} + +static Int +p_print_native_basic_block_msg_after( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_after / print_native_basicblock_msg_after / print_native_bb_msg_after"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strbb = (char*)malloc(100*sizeof(char)); + #define BBLOCK(BB) \ + strcpy(strbb, #BB); \ + UPPER_ENTRY(strbb); \ + if (strcmp(str, strbb) == 0) { \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pbbs_##BB.print) \ + ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ + else \ + ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ + } + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_after / print_native_basicblock_msg_after / print_native_bb_msg_after"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_after / print_native_basicblock_msg_after / print_native_bb_msg_after"); + return FALSE; + } +} + +static Int +p_print_native_basicblock_msg_after( USES_REGS1 ) +{ + return p_print_native_basic_block_msg_after(); +} + +static Int +p_print_native_bb_msg_after( USES_REGS1 ) +{ + return p_print_native_basic_block_msg_after(); +} + +static Int +p_print_native_basic_block3( USES_REGS1 ) +{ + Term t = Deref(ARG3); + char *msga; + if (IsAtomTerm(t)) { + msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msga, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); + return FALSE; + } + + t = Deref(ARG2); + char *msgb; + if (IsAtomTerm(t)) { + msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msgb, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); + return FALSE; + } + + t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + char *strbb = (char*)malloc(100*sizeof(char)); + #define BBLOCK(BB) \ + strcpy(strbb, #BB); \ + UPPER_ENTRY(strbb); \ + if (strcmp(str, strbb) == 0) { \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ + if (!ExpEnv.debug_struc.pbbs_##BB.print) \ + ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ + else \ + ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ + strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ + } + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); + return FALSE; + } +} + +static Int +p_print_native_basicblock3( USES_REGS1 ) +{ + return p_print_native_basic_block3(); +} + +static Int +p_print_native_bb3( USES_REGS1 ) +{ + return p_print_native_basic_block3(); +} + +static Int +p_no_print_clause( USES_REGS1 ) +{ + if (ExpEnv.debug_struc.pmainclause_on_head.msg_before) free((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_before); + if (ExpEnv.debug_struc.pmainclause_on_head.msg_after) free((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_after); + ExpEnv.debug_struc.pmainclause_on_head.print = (Int)NO_PLACE; + ExpEnv.debug_struc.pmainclause_on_head.msg_before = 0; + ExpEnv.debug_struc.pmainclause_on_head.msg_after = 0; + return TRUE; +} + +static Int +p_print_clause( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + if (strcmp(str, "STANDARD") == 0 || strcmp(str, "STD") == 0) { + ExpEnv.debug_struc.pmainclause_on_head.msg_before = (CELL)malloc(sizeof(char)); + ExpEnv.debug_struc.pmainclause_on_head.msg_after = (CELL)malloc(2*sizeof(char)); + if (!ExpEnv.debug_struc.pmainclause_on_head.print) + ExpEnv.debug_struc.pmainclause_on_head.print = (Int)ON_INTERPRETER; + else + ExpEnv.debug_struc.pmainclause_on_head.print |= (Int)ON_INTERPRETER; + strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_before), ""); + strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_after), "\n"); + } + else if (strcmp(str, "PROFILED") == 0 || strcmp(str, "PFD") == 0) { + ExpEnv.debug_struc.pmainclause_on_head.msg_before = (CELL)malloc(sizeof(char)); + ExpEnv.debug_struc.pmainclause_on_head.msg_after = (CELL)malloc(2*sizeof(char)); + if (!ExpEnv.debug_struc.pmainclause_on_head.print) + ExpEnv.debug_struc.pmainclause_on_head.print = (Int)ON_PROFILED_INTERPRETER; + else + ExpEnv.debug_struc.pmainclause_on_head.print |= (Int)ON_PROFILED_INTERPRETER; + strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_before), ""); + strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_after), "\n"); + } + else if (strcmp(str, "NATIVE") == 0 || strcmp(str, "NTV") == 0) { + ExpEnv.debug_struc.pmainclause_on_head.msg_before = (CELL)malloc(sizeof(char)); + ExpEnv.debug_struc.pmainclause_on_head.msg_after = (CELL)malloc(2*sizeof(char)); + if (!ExpEnv.debug_struc.pmainclause_on_head.print) + ExpEnv.debug_struc.pmainclause_on_head.print = (Int)ON_NATIVE; + else + ExpEnv.debug_struc.pmainclause_on_head.print |= (Int)ON_NATIVE; + strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_before), ""); + strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_after), "\n"); + } + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); + return FALSE; + } +} + +static Int +p_no_print_intermediate( USES_REGS1 ) +{ + if (ExpEnv.debug_struc.pprint_intermediate.std_name) free((char*)ExpEnv.debug_struc.pprint_intermediate.std_name); + if (ExpEnv.debug_struc.pprint_intermediate.file_name) free((char*)ExpEnv.debug_struc.pprint_intermediate.file_name); + ExpEnv.debug_struc.pprint_intermediate.print_to_std = 0; + ExpEnv.debug_struc.pprint_intermediate.print_to_file = 0; + ExpEnv.debug_struc.pprint_intermediate.std_name = 0; + ExpEnv.debug_struc.pprint_intermediate.file_name = 0; + return TRUE; +} + +static Int +p_print_intermediate( USES_REGS1 ) +{ + ExpEnv.debug_struc.pprint_intermediate.print_to_std = 1; + ExpEnv.debug_struc.pprint_intermediate.std_name = (CELL)malloc(7*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.std_name), "STDOUT"); + return TRUE; +} + +static Int +p_print_intermediate_to_std( USES_REGS1 ) +{ + ExpEnv.debug_struc.pprint_intermediate.print_to_std = 1; + ExpEnv.debug_struc.pprint_intermediate.std_name = (CELL)malloc(7*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.std_name), "STDOUT"); + return TRUE; +} + +static Int +p_print_intermediate_to_std1( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsAtomTerm(t)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + UPPER_ENTRY(str); + if (strcmp(str, "STDOUT") == 0 || strcmp(str, "STDERR") == 0) { + ExpEnv.debug_struc.pprint_intermediate.print_to_std = 1; + ExpEnv.debug_struc.pprint_intermediate.std_name = (CELL)malloc(strlen(str)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.std_name), str); + return TRUE; + } + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_intermediate_to_std"); + return FALSE; + } +} + +static Int +p_print_intermediate_to_file( USES_REGS1 ) +{ + ExpEnv.debug_struc.pprint_intermediate.print_to_file = 1; + ExpEnv.debug_struc.pprint_intermediate.file_name = (CELL)malloc(7*sizeof(char)); + if (Yap_ExecutionMode == MIXED_MODE) + strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "trace"); + else + strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "clause"); + return TRUE; +} + +static Int +p_print_intermediate_to_file1( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsAtomTerm(t)) { + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + ExpEnv.debug_struc.pprint_intermediate.print_to_file = 1; + ExpEnv.debug_struc.pprint_intermediate.file_name = (CELL)malloc(strlen(str)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), str); + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_intermediate_to_file"); + return FALSE; + } +} + +static Int +p_no_print_llva( USES_REGS1 ) +{ + ExpEnv.debug_struc.pprint_llva.print_llva_before = 0; + ExpEnv.debug_struc.pprint_llva.print_llva_after = 0; + return TRUE; +} + +static Int +p_print_llva_before( USES_REGS1 ) +{ + ExpEnv.debug_struc.pprint_llva.print_llva_before = 1; + return TRUE; +} + +static Int +p_print_llva_after( USES_REGS1 ) +{ + ExpEnv.debug_struc.pprint_llva.print_llva_after = 1; + return TRUE; +} + +static Int +p_no_print_me( USES_REGS1 ) +{ + Term t = Deref(ARG1); + if (IsAtomTerm(t)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + UPPER_ENTRY(str); + if (strcmp(str, "INTERPRETEDBACKTRACK") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.interpreted_backtrack); + if (strcmp(str, "PROFILEDINTERPRETEDBACKTRACK") == 0 || strcmp(str, "TRACEDINTERPRETEDBACKTRACK") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.profiled_interpreted_backtrack); + else if (strcmp(str, "NATIVEBACKTRACK") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.native_backtrack); + else if (strcmp(str, "TREATIHEAP") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.interpreted_treat_heap); + else if (strcmp(str, "TREATNHEAP") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); + else if (strcmp(str, "TREATITRAIL") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.interpreted_treat_trail); + else if (strcmp(str, "TREATNTRAIL") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.native_treat_trail); + else if (strcmp(str, "CRITICALS") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.criticals); + else if (strcmp(str, "ATCOMPILATION") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.at_compilation); + else if (strcmp(str, "ATRECOMPILATION") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.at_recompilation); + else if (strcmp(str, "NATIVERUNINIT") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.nativerun_init); + else if (strcmp(str, "NATIVERUNEXITBYSUCCESS") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success); + else if (strcmp(str, "NATIVERUNEXITBYFAIL") == 0) + free((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail); + else if (strcmp(str, "NATIVERUNEXIT") == 0) { + free((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success); + free((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail); + } + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_me"); + return FALSE; + } +} + +static Int +p_print_me( USES_REGS1 ) +{ + Term t = Deref(ARG2); + char *msg; + if (IsAtomTerm(t)) { + msg = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(msg, AtomName(AtomOfTerm(t))); + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_me"); + return FALSE; + } + t = Deref(ARG1); + if (IsAtomTerm(t)) { + int i = 0, j = 0; + char *tmp; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + UPPER_ENTRY(str); + if (strcmp(str, "INTERPRETEDBACKTRACK") == 0) { + ExpEnv.debug_struc.pprint_me.interpreted_backtrack = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.interpreted_backtrack), msg); + } + else if (strcmp(str, "PROFILEDINTERPRETEDBACKTRACK") == 0 || strcmp(str, "TRACEDINTERPRETEDBACKTRACK") == 0) { + ExpEnv.debug_struc.pprint_me.profiled_interpreted_backtrack = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.profiled_interpreted_backtrack), msg); + } + else if (strcmp(str, "NATIVEBACKTRACK") == 0) { + ExpEnv.debug_struc.pprint_me.native_backtrack = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.native_backtrack), msg); + } + else if (strcmp(str, "TREATIHEAP") == 0) { + ExpEnv.debug_struc.pprint_me.interpreted_treat_heap = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.interpreted_treat_heap), msg); + } + else if (strcmp(str, "TREATNHEAP") == 0) { + ExpEnv.debug_struc.pprint_me.native_treat_heap = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap), msg); + } + else if (strcmp(str, "TREATITRAIL") == 0) { + ExpEnv.debug_struc.pprint_me.interpreted_treat_trail = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.interpreted_treat_trail), msg); + } + else if (strcmp(str, "TREATNTRAIL") == 0) { + ExpEnv.debug_struc.pprint_me.native_treat_trail = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.native_treat_trail), msg); + } + else if (strcmp(str, "CRITICALS") == 0) { + ExpEnv.debug_struc.pprint_me.criticals = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.criticals), msg); + } + else if (strcmp(str, "ATCOMPILATION") == 0) { + ExpEnv.debug_struc.pprint_me.at_compilation = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.at_compilation), msg); + } + else if (strcmp(str, "ATRECOMPILATION") == 0) { + ExpEnv.debug_struc.pprint_me.at_recompilation = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.at_recompilation), msg); + } + else if (strcmp(str, "NATIVERUNINIT") == 0) { + ExpEnv.debug_struc.pprint_me.nativerun_init = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_init), msg); + } + else if (strcmp(str, "NATIVERUNEXITBYSUCCESS") == 0) { + ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success), msg); + } + else if (strcmp(str, "NATIVERUNEXITBYFAIL") == 0) { + ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail), msg); + } + else if (strcmp(str, "NATIVERUNEXIT") == 0) { + ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success), msg); + ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail = (CELL)malloc(strlen(msg)*sizeof(char)); + strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail), msg); + } + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_me"); + return FALSE; + } +} + +static Int +p_default_debug( USES_REGS1 ) +{ + #define OPCODE(OP,TYPE) \ + ExpEnv.debug_struc.pyaam_##OP.print = (Int)NO_PLACE; \ + ExpEnv.debug_struc.pyaam_##OP.msg_before = 0; \ + ExpEnv.debug_struc.pyaam_##OP.msg_after = 0; + #include "YapAppliedOpcodes.h" + #undef OPCODE + + #define BBLOCK(BB) \ + ExpEnv.debug_struc.pbbs_##BB.print = (Int)NO_PLACE; \ + ExpEnv.debug_struc.pbbs_##BB.msg_before = 0; \ + ExpEnv.debug_struc.pbbs_##BB.msg_after = 0; + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + + ExpEnv.debug_struc.pmainclause_on_head.print = (Int)NO_PLACE; + ExpEnv.debug_struc.pmainclause_on_head.msg_before = 0; + ExpEnv.debug_struc.pmainclause_on_head.msg_after = 0; + + ExpEnv.debug_struc.pprint_intermediate.print_to_std = 0; + ExpEnv.debug_struc.pprint_intermediate.print_to_file = 0; + ExpEnv.debug_struc.pprint_intermediate.std_name = 0; + ExpEnv.debug_struc.pprint_intermediate.file_name = 0; + + ExpEnv.debug_struc.pprint_llva.print_llva_before = 0; + ExpEnv.debug_struc.pprint_llva.print_llva_after = 0; + + ExpEnv.debug_struc.pprint_me.interpreted_backtrack = 0; + ExpEnv.debug_struc.pprint_me.profiled_interpreted_backtrack = 0; + ExpEnv.debug_struc.pprint_me.native_backtrack = 0; + ExpEnv.debug_struc.pprint_me.interpreted_treat_heap = 0; + ExpEnv.debug_struc.pprint_me.native_treat_heap = 0; + ExpEnv.debug_struc.pprint_me.interpreted_treat_trail = 0; + ExpEnv.debug_struc.pprint_me.native_treat_trail = 0; + ExpEnv.debug_struc.pprint_me.criticals = 0; + ExpEnv.debug_struc.pprint_me.at_compilation = 0; + ExpEnv.debug_struc.pprint_me.at_recompilation = 0; + ExpEnv.debug_struc.pprint_me.nativerun_init = 0; + ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success = 0; + ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail = 0; + + ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 0; + ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 0; + ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; + ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; + + ExpEnv.debug_struc.act_predicate_actions.exit_on_warning = 0; + ExpEnv.debug_struc.act_predicate_actions.disable_on_warning = 1; + ExpEnv.debug_struc.act_predicate_actions.exit_on_error = 1; + + return TRUE; +} + +static Int +p_print_default_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 0; + ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 0; + ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; + ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; + return TRUE; +} + +static Int +p_print_all_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 1; + ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 1; + ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; + ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; + return TRUE; +} + +static Int +p_print_info_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 1; + return TRUE; +} + +static Int +p_print_success_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 1; + return TRUE; +} + +static Int +p_print_warning_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; + return TRUE; +} + +static Int +p_print_error_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; + return TRUE; +} + +static Int +p_no_print_all_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 0; + ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 0; + ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 0; + ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 0; + return TRUE; +} + +static Int +p_no_print_info_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 0; + return TRUE; +} + +static Int +p_no_print_success_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 0; + return TRUE; +} + +static Int +p_no_print_warning_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 0; + return TRUE; +} + +static Int +p_no_print_error_predicate_msgs( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 0; + return TRUE; +} + +static Int +p_print_predicate_msgs( USES_REGS1 ) +{ + int i = 0, j = 0; + char *tmp; + Term t = Deref(ARG1); + if (IsAtomTerm(t)) { + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + UPPER_ENTRY(str); + if (strcmp(str, "ALL") == 0) { + ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 1; + ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 1; + ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; + ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; + return TRUE; + } + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + else if (IsPairTerm(t)) { + Term u = HeadOfTermCell(t); + u = Deref(u); + while (1) { + if (IsAtomTerm(u)) { + int i = 0, j = 0; + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + UPPER_ENTRY(str); + if (strcmp(str, "INFO") == 0 || strcmp(str, "INFORMATION") == 0) + ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 1; + else if (strcmp(str, "SUCCESS") == 0) + ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 1; + else if (strcmp(str, "WARNING") == 0) + ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; + else if (strcmp(str, "ERROR") == 0) + ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; + else { + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_predicate_msgs"); + return FALSE; + } + t = TailOfTermCell(t); + t = Deref(t); + if (IsAtomTerm(t)) break; + u = HeadOfTermCell(t); + u = Deref(u); + } + return TRUE; + } + else { + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_predicate_msgs"); + return FALSE; + } +} + +static Int +p_exit_on_warning( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_actions.exit_on_warning = 1; + return TRUE; +} + +static Int +p_disable_on_warning( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_actions.disable_on_warning = 1; + return TRUE; +} + +static Int +p_exit_on_error( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_actions.exit_on_error = 1; + return TRUE; +} + +static Int +p_no_exit_on_warning( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_actions.exit_on_warning = 0; + return TRUE; +} + +static Int +p_enable_on_warning( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_actions.disable_on_warning = 0; + return TRUE; +} + +static Int +p_no_exit_on_error( USES_REGS1 ) +{ + ExpEnv.debug_struc.act_predicate_actions.exit_on_error = 0; + return TRUE; +} + +#pragma GCC diagnostic pop + +void +Yap_InitJitDebugPreds( USES_REGS1 ) +{ + Yap_InitCPred("no_print_instruction", 1, p_no_print_instruction, SafePredFlag); + Yap_InitCPred("no_print_basic_instruction", 1, p_no_print_basic_instruction, SafePredFlag); + Yap_InitCPred("no_print_std_instruction", 1, p_no_print_std_instruction, SafePredFlag); + Yap_InitCPred("no_print_standard_instruction", 1, p_no_print_standard_instruction, SafePredFlag); + Yap_InitCPred("print_instruction", 1, p_print_instruction, SafePredFlag); + Yap_InitCPred("print_basic_instruction", 1, p_print_basic_instruction, SafePredFlag); + Yap_InitCPred("print_std_instruction", 1, p_print_std_instruction, SafePredFlag); + Yap_InitCPred("print_standard_instruction", 1, p_print_standard_instruction, SafePredFlag); + Yap_InitCPred("print_instruction_msg_before", 2, p_print_instruction_msg_before, SafePredFlag); + Yap_InitCPred("print_basic_instruction_msg_before", 2, p_print_basic_instruction_msg_before, SafePredFlag); + Yap_InitCPred("print_std_instruction_msg_before", 2, p_print_std_instruction_msg_before, SafePredFlag); + Yap_InitCPred("print_standard_instruction_msg_before", 2, p_print_standard_instruction_msg_before, SafePredFlag); + Yap_InitCPred("print_instruction_msg_after", 2, p_print_instruction_msg_after, SafePredFlag); + Yap_InitCPred("print_basic_instruction_msg_after", 2, p_print_basic_instruction_msg_after, SafePredFlag); + Yap_InitCPred("print_std_instruction_msg_after", 2, p_print_std_instruction_msg_after, SafePredFlag); + Yap_InitCPred("print_standard_instruction_msg_after", 2, p_print_standard_instruction_msg_after, SafePredFlag); + Yap_InitCPred("print_instruction", 3, p_print_instruction3, SafePredFlag); + Yap_InitCPred("print_basic_instruction", 3, p_print_basic_instruction3, SafePredFlag); + Yap_InitCPred("print_std_instruction", 3, p_print_std_instruction3, SafePredFlag); + Yap_InitCPred("print_standard_instruction", 3, p_print_standard_instruction3, SafePredFlag); + Yap_InitCPred("print_profiled_instruction", 1, p_print_profiled_instruction, SafePredFlag); + Yap_InitCPred("print_traced_instruction", 1, p_print_traced_instruction, SafePredFlag); + Yap_InitCPred("print_pfd_instruction", 1, p_print_pfd_instruction, SafePredFlag); + Yap_InitCPred("print_profiled_instruction_msg_before", 2, p_print_profiled_instruction_msg_before, SafePredFlag); + Yap_InitCPred("print_traced_instruction_msg_before", 2, p_print_traced_instruction_msg_before, SafePredFlag); + Yap_InitCPred("print_pfd_instruction_msg_before", 2, p_print_pfd_instruction_msg_before, SafePredFlag); + Yap_InitCPred("print_profiled_instruction_msg_after", 2, p_print_profiled_instruction_msg_after, SafePredFlag); + Yap_InitCPred("print_traced_instruction_msg_after", 2, p_print_traced_instruction_msg_after, SafePredFlag); + Yap_InitCPred("print_pfd_instruction_msg_after", 2, p_print_pfd_instruction_msg_after, SafePredFlag); + Yap_InitCPred("print_profiled_instruction", 3, p_print_profiled_instruction3, SafePredFlag); + Yap_InitCPred("print_traced_instruction", 3, p_print_traced_instruction3, SafePredFlag); + Yap_InitCPred("print_pfd_instruction", 3, p_print_pfd_instruction3, SafePredFlag); + Yap_InitCPred("print_native_instruction", 1, p_print_native_instruction, SafePredFlag); + Yap_InitCPred("print_ntv_instruction", 1, p_print_ntv_instruction, SafePredFlag); + Yap_InitCPred("print_native_instruction_msg_before", 2, p_print_native_instruction_msg_before, SafePredFlag); + Yap_InitCPred("print_ntv_instruction_msg_before", 2, p_print_ntv_instruction_msg_before, SafePredFlag); + Yap_InitCPred("print_native_instruction_msg_after", 2, p_print_native_instruction_msg_after, SafePredFlag); + Yap_InitCPred("print_ntv_instruction_msg_after", 2, p_print_ntv_instruction_msg_after, SafePredFlag); + Yap_InitCPred("print_native_instruction", 3, p_print_native_instruction3, SafePredFlag); + Yap_InitCPred("print_ntv_instruction", 3, p_print_ntv_instruction3, SafePredFlag); + Yap_InitCPred("no_print_basic_block", 1, p_no_print_basic_block, SafePredFlag); + Yap_InitCPred("no_print_basicblock", 1, p_no_print_basicblock, SafePredFlag); + Yap_InitCPred("no_print_bb", 1, p_no_print_bb, SafePredFlag); + Yap_InitCPred("print_basic_block", 1, p_print_basic_block, SafePredFlag); + Yap_InitCPred("print_basicblock", 1, p_print_basicblock, SafePredFlag); + Yap_InitCPred("print_bb", 1, p_print_bb, SafePredFlag); + Yap_InitCPred("print_basic_block_msg_before", 2, p_print_basic_block_msg_before, SafePredFlag); + Yap_InitCPred("print_basicblock_msg_before", 2, p_print_basicblock_msg_before, SafePredFlag); + Yap_InitCPred("print_bb_msg_before", 2, p_print_bb_msg_before, SafePredFlag); + Yap_InitCPred("print_basic_block_msg_after", 2, p_print_basic_block_msg_after, SafePredFlag); + Yap_InitCPred("print_basicblock_msg_after", 2, p_print_basicblock_msg_after, SafePredFlag); + Yap_InitCPred("print_bb_msg_after", 2, p_print_bb_msg_after, SafePredFlag); + Yap_InitCPred("print_basic_block", 3, p_print_basic_block3, SafePredFlag); + Yap_InitCPred("print_basicblock", 3, p_print_basicblock3, SafePredFlag); + Yap_InitCPred("print_bb", 3, p_print_bb3, SafePredFlag); + Yap_InitCPred("print_native_basic_block", 1, p_print_native_basic_block, SafePredFlag); + Yap_InitCPred("print_native_basicblock", 1, p_print_native_basicblock, SafePredFlag); + Yap_InitCPred("print_native_bb", 1, p_print_native_bb, SafePredFlag); + Yap_InitCPred("print_native_basic_block_msg_before", 2, p_print_native_basic_block_msg_before, SafePredFlag); + Yap_InitCPred("print_native_basicblock_msg_before", 2, p_print_native_basicblock_msg_before, SafePredFlag); + Yap_InitCPred("print_native_bb_msg_before", 2, p_print_native_bb_msg_before, SafePredFlag); + Yap_InitCPred("print_native_basic_block_msg_after", 2, p_print_native_basic_block_msg_after, SafePredFlag); + Yap_InitCPred("print_native_basicblock_msg_after", 2, p_print_native_basicblock_msg_after, SafePredFlag); + Yap_InitCPred("print_native_bb_msg_after", 2, p_print_native_bb_msg_after, SafePredFlag); + Yap_InitCPred("print_native_basic_block", 3, p_print_native_basic_block3, SafePredFlag); + Yap_InitCPred("print_native_basicblock", 3, p_print_native_basicblock3, SafePredFlag); + Yap_InitCPred("print_native_bb", 3, p_print_native_bb3, SafePredFlag); + Yap_InitCPred("no_print_clause", 0, p_no_print_clause, SafePredFlag); + Yap_InitCPred("print_clause", 1, p_print_clause, SafePredFlag); + Yap_InitCPred("no_print_intermediate", 0, p_no_print_intermediate, SafePredFlag); + Yap_InitCPred("print_intermediate", 0, p_print_intermediate, SafePredFlag); + Yap_InitCPred("print_intermediate_to_std", 0, p_print_intermediate_to_std, SafePredFlag); + Yap_InitCPred("print_intermediate_to_std", 1, p_print_intermediate_to_std1, SafePredFlag); + Yap_InitCPred("print_intermediate_to_file", 0, p_print_intermediate_to_file, SafePredFlag); + Yap_InitCPred("print_intermediate_to_file", 1, p_print_intermediate_to_file1, SafePredFlag); + Yap_InitCPred("no_print_llva", 0, p_no_print_llva, SafePredFlag); + Yap_InitCPred("print_llva_before", 0, p_print_llva_before, SafePredFlag); + Yap_InitCPred("print_llva_after", 0, p_print_llva_after, SafePredFlag); + Yap_InitCPred("no_print_me", 1, p_no_print_me, SafePredFlag); + Yap_InitCPred("print_me", 2, p_print_me, SafePredFlag); + Yap_InitCPred("default_debug", 0, p_default_debug, SafePredFlag); + Yap_InitCPred("print_default_predicate_msgs", 0, p_print_default_predicate_msgs, SafePredFlag); + Yap_InitCPred("print_all_predicate_msgs", 0, p_print_all_predicate_msgs, SafePredFlag); + Yap_InitCPred("print_info_predicate_msgs", 0, p_print_info_predicate_msgs, SafePredFlag); + Yap_InitCPred("print_success_predicate_msgs", 0, p_print_success_predicate_msgs, SafePredFlag); + Yap_InitCPred("print_warning_predicate_msgs", 0, p_print_warning_predicate_msgs, SafePredFlag); + Yap_InitCPred("print_error_predicate_msgs", 0, p_print_error_predicate_msgs, SafePredFlag); + Yap_InitCPred("no_print_all_predicate_msgs", 0, p_no_print_all_predicate_msgs, SafePredFlag); + Yap_InitCPred("no_print_info_predicate_msgs", 0, p_no_print_info_predicate_msgs, SafePredFlag); + Yap_InitCPred("no_print_success_predicate_msgs", 0, p_no_print_success_predicate_msgs, SafePredFlag); + Yap_InitCPred("no_print_warning_predicate_msgs", 0, p_no_print_warning_predicate_msgs, SafePredFlag); + Yap_InitCPred("no_print_error_predicate_msgs", 0, p_no_print_error_predicate_msgs, SafePredFlag); + Yap_InitCPred("print_predicate_msgs", 1, p_print_predicate_msgs, SafePredFlag); + Yap_InitCPred("exit_on_warning", 0, p_exit_on_warning, SafePredFlag); + Yap_InitCPred("disable_on_warning", 0, p_disable_on_warning, SafePredFlag); + Yap_InitCPred("exit_on_error", 0, p_exit_on_error, SafePredFlag); + Yap_InitCPred("no_exit_on_warning", 0, p_no_exit_on_warning, SafePredFlag); + Yap_InitCPred("enable_on_warning", 0, p_enable_on_warning, SafePredFlag); + Yap_InitCPred("no_exit_on_error", 0, p_no_exit_on_error, SafePredFlag); +} diff --git a/JIT/jit_statisticpreds.c b/JIT/jit_statisticpreds.c new file mode 100644 index 000000000..5c1521fa3 --- /dev/null +++ b/JIT/jit_statisticpreds.c @@ -0,0 +1,838 @@ +/************************************************************************* +* * +* Extension for YAP Prolog * +* * +* Copyright G.S.Oliveira, A.F.Silva and Universidade Estadual de Maringá * +* * +* Yap Prolog was developed at NCCUP - Universidade do Porto * +* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * +* * +************************************************************************** +* * +* File: jit_statisticpreds.c * +* comments: JIT Compiler Statistics predicates * +* * +* Last rev: 2013-10-18 * +*************************************************************************/ + +#include "jit_predicates.hh" +#include + +static Int p_init_low_level_stats( USES_REGS1 ); +static Int p_statistics_jit( USES_REGS1 ); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wimplicit-function-declaration" + +static Int +p_init_low_level_stats( USES_REGS1 ) +{ + int i = 0, j = 0; + char *tmp; + Term t = Deref(ARG1); + // valid value for ARG1 is just 'atom' + if (IsAtomTerm(t)) { + // ARG1 is atom + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects one papi event (each event is a set of several performance counters) + // Such events are: 'conditional_branching', 'cache_requests', 'conditional_store', 'floating_point_operations', 'instruction_counting', 'cache_access', 'data_access', and 'tlb_operations' + // Event chosen by user is stored on 'ExpEnv.stats_struc.papi_event_type' + // Only one event can be chosen at a time + if (strcmp(str, "CONDITIONALBRANCHING") == 0) + ExpEnv.stats_struc.papi_event_type = 0; + else if (strcmp(str, "CACHEREQUESTS") == 0) + ExpEnv.stats_struc.papi_event_type = 1; + else if (strcmp(str, "CONDITIONALSTORE") == 0) + ExpEnv.stats_struc.papi_event_type = 2; + else if (strcmp(str, "FLOATINGPOINTOPERATIONS") == 0) + ExpEnv.stats_struc.papi_event_type = 3; + else if (strcmp(str, "INSTRUCTIONCOUNTING") == 0) + ExpEnv.stats_struc.papi_event_type = 4; + else if (strcmp(str, "CACHEACCESS") == 0) + ExpEnv.stats_struc.papi_event_type = 5; + else if (strcmp(str, "DATAACCESS") == 0) + ExpEnv.stats_struc.papi_event_type = 6; + else if (strcmp(str, "TLBOPERATIONS") == 0) + ExpEnv.stats_struc.papi_event_type = 7; + else { + // value passed by argument is out of known range (unknown event) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + + /* Initializing PAPI library */ + if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) { + fprintf(stderr, "PAPI library init error!\n"); + exit(1); + } + /***/ + + /* Create one event set */ + if (PAPI_create_eventset(&ExpEnv.stats_struc.papi_eventset) != PAPI_OK) + fprintf (stderr, "%s:%d\t ERROR\n", __FILE__, __LINE__); + /***/ + + /* Add counters to event set */ + if (ExpEnv.stats_struc.papi_event_type == 0) { + // Event type is 'conditional_branching' -- contains 9 performance counters + ExpEnv.stats_struc.papi_valid_values = (short*)malloc(9*sizeof(short)); + + /* Initializing 'ExpEnv.stats_struc.papi_valid_values'. Not all performance counters of an event are available, because they are machine-dependent. 'ExpEnv.stats_struc.papi_valid_values[i]' will be set with '1' if event 'i' is available */ + for (i = 0; i < 9; i++) { + ExpEnv.stats_struc.papi_valid_values[i] = 0; + } + + /* Adding performance counters of event*/ + // Conditional Branching -- Conditional branch instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_BR_CN) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[0] = 1; + // Conditional Branching -- Branch instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_BR_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[1] = 1; + // Conditional Branching -- Conditional branch instructions mispredicted + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_BR_MSP) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[2] = 1; + // Conditional Branching -- Conditional branch instructions not taken + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_BR_NTK) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[3] = 1; + // Conditional Branching -- Conditional branch instructions correctly predicted + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_BR_PRC) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[4] = 1; + // Conditional Branching -- Conditional branch instructions taken + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_BR_TKN) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[5] = 1; + // Conditional Branching -- Unconditional branch instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_BR_UCN) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[6] = 1; + // Conditional Branching -- Cycles branch units are idle + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_BRU_IDL) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[7] = 1; + // Conditional Branching -- Branch target address cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_BTAC_M) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[8] = 1; + } + + else if (ExpEnv.stats_struc.papi_event_type == 1) { + // Event type is 'cache_requests' -- contains 5 performance counters + ExpEnv.stats_struc.papi_valid_values = (short*)malloc(5*sizeof(short)); + + /* Initializing 'ExpEnv.stats_struc.papi_valid_values'. Not all performance counters of an event are available, because they are machine-dependent. 'ExpEnv.stats_struc.papi_valid_values[i]' will be set with '1' if event 'i' is available */ + for (i = 0; i < 5; i++) { + ExpEnv.stats_struc.papi_valid_values[i] = 0; + } + + /* Adding performance counters of event*/ + // Cache Requests -- Requests for exclusive access to clean cache line + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_CA_CLN) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[0] = 1; + // Cache Requests -- Requests for cache line invalidation + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_CA_INV) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[1] = 1; + // Cache Requests -- Requests for cache line intervention + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_CA_ITV) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[2] = 1; + // Cache Requests -- Requests for exclusive access to shared cache line + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_CA_SHR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[3] = 1; + // Cache Requests -- Requests for a snoop + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_CA_SNP) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[4] = 1; + } + + else if (ExpEnv.stats_struc.papi_event_type == 2) { + // Event type is 'conditional_store' -- contains 3 performance counters + ExpEnv.stats_struc.papi_valid_values = (short*)malloc(3*sizeof(short)); + + /* Initializing 'ExpEnv.stats_struc.papi_valid_values'. Not all performance counters of an event are available, because they are machine-dependent. 'ExpEnv.stats_struc.papi_valid_values[i]' will be set with '1' if event 'i' is available */ + for (i = 0; i < 3; i++) { + ExpEnv.stats_struc.papi_valid_values[i] = 0; + } + + /* Adding performance counters of event*/ + // Conditional Store -- Failed store conditional instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_CSR_FAL) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[0] = 1; + // Conditional Store -- Successful store conditional instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_CSR_SUC) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[1] = 1; + // Conditional Store -- Total store conditional instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_CSR_TOT) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[2] = 1; + } + + else if (ExpEnv.stats_struc.papi_event_type == 3) { + // Event type is 'floating_point_operations' -- contains 14 performance counters + ExpEnv.stats_struc.papi_valid_values = (short*)malloc(14*sizeof(short)); + + /* Initializing 'ExpEnv.stats_struc.papi_valid_values'. Not all performance counters of an event are available, because they are machine-dependent. 'ExpEnv.stats_struc.papi_valid_values[i]' will be set with '1' if event 'i' is available */ + for (i = 0; i < 14; i++) { + ExpEnv.stats_struc.papi_valid_values[i] = 0; + } + + /* Adding performance counters of event*/ + // Floating Point Operations -- Floating point add instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FAD_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[0] = 1; + // Floating Point Operations -- Floating point divide instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FDV_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[1] = 1; + // Floating Point Operations -- FMA instructions completed + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FMA_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[2] = 1; + // Floating Point Operations -- Floating point multiply instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FML_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[3] = 1; + // Floating Point Operations -- Floating point inverse instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FNV_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[4] = 1; + // Floating Point Operations -- Floating point instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FP_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[5] = 1; + // Floating Point Operations -- Floating point operations + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FP_OPS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[6] = 1; + // Floating Point Operations -- Cycles the FP unit + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FP_STAL) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[7] = 1; + // Floating Point Operations -- Cycles floating point units are idle + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FPU_IDL) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[8] = 1; + // Floating Point Operations -- Floating point square root instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FSQ_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[9] = 1; + // Floating Point Operations -- Floating point operations executed; optimized to count scaled single precision vector operations + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_SP_OPS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[10] = 1; + // Floating Point Operations -- Floating point operations executed; optimized to count scaled double precision vector operations + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_DP_OPS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[11] = 1; + // Floating Point Operations -- Single precision vector/SIMD instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_VEC_SP) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[12] = 1; + // Floating Point Operations -- Double precision vector/SIMD instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_VEC_DP) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[13] = 1; + } + + else if (ExpEnv.stats_struc.papi_event_type == 4) { + // Event type is 'instruction_counting' -- contains 9 performance counters + ExpEnv.stats_struc.papi_valid_values = (short*)malloc(9*sizeof(short)); + + /* Initializing 'ExpEnv.stats_struc.papi_valid_values'. Not all performance counters of an event are available, because they are machine-dependent. 'ExpEnv.stats_struc.papi_valid_values[i]' will be set with '1' if event 'i' is available */ + for (i = 0; i < 9; i++) { + ExpEnv.stats_struc.papi_valid_values[i] = 0; + } + + /* Adding performance counters of event*/ + // Instruction Counting -- Cycles with maximum instructions completed + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FUL_CCY) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[0] = 1; + // Instruction Counting -- Cycles with maximum instruction issue + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FUL_ICY) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[1] = 1; + // Instruction Counting -- Cycles integer units are idle + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_FXU_IDL) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[2] = 1; + // Instruction Counting -- Hardware interrupts + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_HW_INT) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[3] = 1; + // Instruction Counting -- Integer instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_INT_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[4] = 1; + // Instruction Counting -- Total cycles + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_TOT_CYC) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[5] = 1; + // Instruction Counting -- Instructions issued + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_TOT_IIS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[6] = 1; + // Instruction Counting -- Instructions completed + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_TOT_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[7] = 1; + // Instruction Counting -- Vector/SIMD instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_VEC_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[8] = 1; + } + + else if (ExpEnv.stats_struc.papi_event_type == 5) { + // Event type is 'cache_access' -- contains 51 performance counters + ExpEnv.stats_struc.papi_valid_values = (short*)malloc(51*sizeof(short)); + + /* Initializing 'ExpEnv.stats_struc.papi_valid_values'. Not all performance counters of an event are available, because they are machine-dependent. 'ExpEnv.stats_struc.papi_valid_values[i]' will be set with '1' if event 'i' is available */ + for (i = 0; i < 51; i++) { + ExpEnv.stats_struc.papi_valid_values[i] = 0; + } + + /* Adding performance counters of event*/ + // Cache Access -- L1 data cache accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_DCA) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[0] = 1; + // Cache Access -- L1 data cache hits + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_DCH) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[1] = 1; + // Cache Access -- L1 data cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_DCM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[2] = 1; + // Cache Access -- L1 data cache reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_DCR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[3] = 1; + // Cache Access -- L1 data cache writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_DCW) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[4] = 1; + // Cache Access -- L1 instruction cache accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_ICA) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[5] = 1; + // Cache Access -- L1 instruction cache hits + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_ICH) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[6] = 1; + // Cache Access -- L1 instruction cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_ICM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[7] = 1; + // Cache Access -- L1 instruction cache reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_ICR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[8] = 1; + // Cache Access -- L1 instruction cache writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_ICW) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[9] = 1; + // Cache Access -- L1 load misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_LDM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[10] = 1; + // Cache Access -- L1 store misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_STM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[11] = 1; + // Cache Access -- L1 total cache accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_TCA) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[12] = 1; + // Cache Access -- L1 total cache hits + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_TCH) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[13] = 1; + // Cache Access -- L1 total cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_TCM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[14] = 1; + // Cache Access -- L1 total cache reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_TCR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[15] = 1; + // Cache Access -- L1 total cache writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L1_TCW) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[16] = 1; + // Cache Access -- L2 data cache accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_DCA) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[17] = 1; + // Cache Access -- L2 data cache hits + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_DCH) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[18] = 1; + // Cache Access -- L2 data cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_DCM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[19] = 1; + // Cache Access -- L2 data cache reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_DCR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[20] = 1; + // Cache Access -- L2 data cache writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_DCW) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[21] = 1; + // Cache Access -- L2 instruction cache accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_ICA) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[22] = 1; + // Cache Access -- L2 instruction cache hits + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_ICH) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[23] = 1; + // Cache Access -- L2 instruction cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_ICM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[24] = 1; + // Cache Access -- L2 instruction cache reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_ICR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[25] = 1; + // Cache Access -- L2 instruction cache writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_ICW) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[26] = 1; + // Cache Access -- L2 load misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_LDM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[27] = 1; + // Cache Access -- L2 store misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_STM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[28] = 1; + // Cache Access -- L2 total cache accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_TCA) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[29] = 1; + // Cache Access -- L2 total cache hits + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_TCH) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[30] = 1; + // Cache Access -- L2 total cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_TCM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[31] = 1; + // Cache Access -- L2 total cache reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_TCR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[32] = 1; + // Cache Access -- L2 total cache writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L2_TCW) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[33] = 1; + // Cache Access -- L3 data cache accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_DCA) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[34] = 1; + // Cache Access -- L3 data cache hits + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_DCH) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[35] = 1; + // Cache Access -- L3 data cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_DCM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[36] = 1; + // Cache Access -- L3 data cache reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_DCR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[37] = 1; + // Cache Access -- L3 data cache writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_DCW) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[38] = 1; + // Cache Access -- L3 instruction cache accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_ICA) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[39] = 1; + // Cache Access -- L3 instruction cache hits + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_ICH) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[40] = 1; + // Cache Access -- L3 instruction cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_ICM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[41] = 1; + // Cache Access -- L3 instruction cache reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_ICR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[42] = 1; + // Cache Access -- L3 instruction cache writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_ICW) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[43] = 1; + // Cache Access -- L3 load misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_LDM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[44] = 1; + // Cache Access -- L3 store misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_STM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[45] = 1; + // Cache Access -- L3 total cache accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_TCA) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[46] = 1; + // Cache Access -- L3 total cache hits + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_TCH) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[47] = 1; + // Cache Access -- L3 total cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_TCM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[48] = 1; + // Cache Access -- L3 total cache reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_TCR) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[49] = 1; + // Cache Access -- L3 total cache writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_L3_TCW) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[50] = 1; + } + + else if (ExpEnv.stats_struc.papi_event_type == 6) { + // Event type is 'data_access' -- contains 12 performance counters + ExpEnv.stats_struc.papi_valid_values = (short*)malloc(12*sizeof(short)); + + /* Initializing 'ExpEnv.stats_struc.papi_valid_values'. Not all performance counters of an event are available, because they are machine-dependent. 'ExpEnv.stats_struc.papi_valid_values[i]' will be set with '1' if event 'i' is available */ + for (i = 0; i < 12; i++) { + ExpEnv.stats_struc.papi_valid_values[i] = 0; + } + + /* Adding performance counters of event*/ + // Data Access -- Load instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_LD_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[0] = 1; + // Data Access -- Load/store instructions completed + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_LST_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[1] = 1; + // Data Access -- Cycles load/store units are idle + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_LSU_IDL) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[2] = 1; + // Data Access -- Cycles Stalled Waiting for memory reads + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_MEM_RCY) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[3] = 1; + // Data Access -- Cycles Stalled Waiting for memory accesses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_MEM_SCY) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[4] = 1; + // Data Access -- Cycles Stalled Waiting for memory writes + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_MEM_WCY) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[5] = 1; + // Data Access -- Data prefetch cache misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_PRF_DM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[6] = 1; + // Data Access -- Cycles stalled on any resource + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_RES_STL) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[7] = 1; + // Data Access -- Store instructions + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_SR_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[8] = 1; + // Data Access -- Cycles with no instructions completed + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_STL_CCY) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[9] = 1; + // Data Access -- Cycles with no instruction issue + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_STL_ICY) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[10] = 1; + // Data Access -- Synchronization instructions completed + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_SYC_INS) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[11] = 1; + } + + else if (ExpEnv.stats_struc.papi_event_type == 7) { + // Event type is 'tbl_operations' -- contains 4 performance counters + ExpEnv.stats_struc.papi_valid_values = (short*)malloc(4*sizeof(short)); + + /* Initializing 'ExpEnv.stats_struc.papi_valid_values'. Not all performance counters of an event are available, because they are machine-dependent. 'ExpEnv.stats_struc.papi_valid_values[i]' will be set with '1' if event 'i' is available */ + for (i = 0; i < 4; i++) { + ExpEnv.stats_struc.papi_valid_values[i] = 0; + } + + /* Adding performance counters of event*/ + // TLB Operations -- Data translation lookaside buffer misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_TLB_DM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[0] = 1; + // TLB Operations -- Instruction translation lookaside buffer misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_TLB_IM) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[1] = 1; + // TLB Operations -- Translation lookaside buffer shootdowns + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_TLB_SD) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[2] = 1; + // TLB Operations -- Total translation lookaside buffer misses + if (PAPI_add_event(ExpEnv.stats_struc.papi_eventset, PAPI_TLB_TL) == PAPI_OK) + ExpEnv.stats_struc.papi_valid_values[3] = 1; + } + + // Setting 'ExpEnv.stats_struc.papi_initialized'. This flag will be tested on predicate 'statistics_jit/0' and event's results will be emitted if '1' + ExpEnv.stats_struc.papi_initialized = 1; + + /* Start counting */ + if (PAPI_start(ExpEnv.stats_struc.papi_eventset) != PAPI_OK) + ExpEnv.stats_struc.papi_initialized = 0; + /***/ + + return TRUE; + + } + else { + // ARG1 is not an atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR, "Low-level stats"); + return FALSE; + } +} + +static Int +p_statistics_jit( USES_REGS1 ) +{ + if (NativeArea && NativeArea->n) { // This exp will be true only if JIT Compiler was used + // printing... + int i, j; + fprintf(stderr, "------------------------------\n"); + fprintf(stderr, "Statistics for JIT::\n"); + fprintf(stderr, "------------------------------\n"); + for (i = 0; i < NativeArea->n; i++) { // For each slot in NativeArea + if (NativeArea->area.ok[i] == 1) { // For each compiled code. Some slots in NativeArea may be empty because not all code is compiled (I still do not know why LLVM fails to compile some code) + fprintf(stderr, " Trace %d:\n", i+1); + + /* print size of each intermediate code compiled on each (re)compilation */ + for (j = 0; j < NativeArea->area.nrecomp[i]; j++) { + fprintf(stderr, "\tSize (%d): %ld bytes.\n", j+1, NativeArea->area.trace_size_bytes[i][j]); + } + + /* print size of each native code on each (re)compilation */ + for (j = 0; j < NativeArea->area.nrecomp[i]; j++) { + fprintf(stderr, "\tNative size (%d): %ld bytes.\n", j+1, NativeArea->area.native_size_bytes[i][j]); + } + + /* print compile time of each native code on each (re)compilation */ + for (j = 0; j < NativeArea->area.nrecomp[i]; j++) { + fprintf(stderr, "\tNative compile time (%d): %.3lf sec.\n", j+1, NativeArea->area.compilation_time[i][j]); + } + + // get address on IntermediatecodeArea which is stored on first instruction of native code (this instruction is NativeArea->area.pc[i]') + int taddress = ((yamop*)NativeArea->area.pc[i])->u.jhc.jh->caa.taddress; + + if (taddress != -1) { + fprintf(stderr, "\tProfiling time: %.3lf sec.\n", IntermediatecodeArea->area.profiling_time[taddress]); + fprintf(stderr, "\tRun time: %.3lf sec.\n", NativeArea->t_runs[i]); + fprintf(stderr, "\t%ld runs\n", NativeArea->runs[i]); + fprintf(stderr, "\t%ld success\n", NativeArea->success[i]); + } + } + } + fprintf(stderr, "------------------------------\n"); + } + + // From this point until the end we do: + // 1. We verify if PAPI was initialized (ExpEnv.stats_struc.papi_initialized). If yes, we do: + // 2. We verify what event type was used. Based on this, we alloc memory for 'ExpEnv.stats_struc.papi_values' + // 3. 'ExpEnv.stats_struc.papi_values' is a vector which will be contain performance counters' values + // 4. As previously mentioned, not all performance counters are available on target machine. For such, the position in 'ExpEnv.stats_struc.papi_values' will be '0'. Therefore not be considered + // 5. Values of each performance counter will be read by function 'PAPI_read'. Note that one of argument is that 'ExpEnv.stats_struc.papi_values' + // 6. Finally, values will be printed (stderr) + if (ExpEnv.stats_struc.papi_initialized) { + if (ExpEnv.stats_struc.papi_event_type == 0) + ExpEnv.stats_struc.papi_values = (long long*)malloc(9*sizeof(long long)); + else if (ExpEnv.stats_struc.papi_event_type == 1) + ExpEnv.stats_struc.papi_values = (long long*)malloc(5*sizeof(long long)); + else if (ExpEnv.stats_struc.papi_event_type == 2) + ExpEnv.stats_struc.papi_values = (long long*)malloc(3*sizeof(long long)); + else if (ExpEnv.stats_struc.papi_event_type == 3) + ExpEnv.stats_struc.papi_values = (long long*)malloc(14*sizeof(long long)); + else if (ExpEnv.stats_struc.papi_event_type == 4) + ExpEnv.stats_struc.papi_values = (long long*)malloc(9*sizeof(long long)); + else if (ExpEnv.stats_struc.papi_event_type == 5) + ExpEnv.stats_struc.papi_values = (long long*)malloc(51*sizeof(long long)); + else if (ExpEnv.stats_struc.papi_event_type == 6) + ExpEnv.stats_struc.papi_values = (long long*)malloc(12*sizeof(long long)); + else if (ExpEnv.stats_struc.papi_event_type == 7) + ExpEnv.stats_struc.papi_values = (long long*)malloc(4*sizeof(long long)); + + if (PAPI_read(ExpEnv.stats_struc.papi_eventset, ExpEnv.stats_struc.papi_values) != PAPI_OK) + fprintf (stderr, "%s:%d\t ERROR\n", __FILE__, __LINE__); + + int k = 0; + if (ExpEnv.stats_struc.papi_event_type == 0) { + if (ExpEnv.stats_struc.papi_valid_values[0]) + fprintf(stderr, "\tConditional branch instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[1]) + fprintf(stderr, "\tBranch instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[2]) + fprintf(stderr, "\tConditional branch instructions mispredicted:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[3]) + fprintf(stderr, "\tConditional branch instructions not taken:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[4]) + fprintf(stderr, "\tConditional branch instructions correctly predicted:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[5]) + fprintf(stderr, "\tConditional branch instructions taken:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[6]) + fprintf(stderr, "\tUnconditional branch instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[7]) + fprintf(stderr, "\tCycles branch units are idle:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[8]) + fprintf(stderr, "\tBranch target address cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + } + + else if (ExpEnv.stats_struc.papi_event_type == 1) { + if (ExpEnv.stats_struc.papi_valid_values[0]) + fprintf(stderr, "\tRequests for exclusive access to clean cache line:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[1]) + fprintf(stderr, "\tRequests for cache line invalidation:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[2]) + fprintf(stderr, " CCache Requests -- Requests for cache line intervention:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[3]) + fprintf(stderr, "\tRequests for exclusive access to shared cache line:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[4]) + fprintf(stderr, "\tRequests for a snoop:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + } + + else if (ExpEnv.stats_struc.papi_event_type == 2) { + if (ExpEnv.stats_struc.papi_valid_values[0]) + fprintf(stderr, "\tFailed store conditional instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[1]) + fprintf(stderr, "\tSuccessful store conditional instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[2]) + fprintf(stderr, "\tTotal store conditional instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + } + + else if (ExpEnv.stats_struc.papi_event_type == 3) { + if (ExpEnv.stats_struc.papi_valid_values[0]) + fprintf(stderr, "\tFloating point add instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[1]) + fprintf(stderr, "\tFloating point divide instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[2]) + fprintf(stderr, "\tFMA instructions completed:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[3]) + fprintf(stderr, "\tFloating point multiply instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[4]) + fprintf(stderr, "\tFloating point inverse instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[5]) + fprintf(stderr, "\tFloating point instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[6]) + fprintf(stderr, "\tFloating point operations:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[7]) + fprintf(stderr, "\tCycles the FP unit:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[8]) + fprintf(stderr, "\tCycles floating point units are idle:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[9]) + fprintf(stderr, "\tFloating point square root instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[10]) + fprintf(stderr, "\tFloating point operations executed; optimized to count scaled single precision vector operations:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[11]) + fprintf(stderr, "\tFloating point operations executed; optimized to count scaled double precision vector operations:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[12]) + fprintf(stderr, "\tSingle precision vector/SIMD instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[13]) + fprintf(stderr, "\tDouble precision vector/SIMD instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + } + + else if (ExpEnv.stats_struc.papi_event_type == 4) { + if (ExpEnv.stats_struc.papi_valid_values[0]) + fprintf(stderr, "\tCycles with maximum instructions completed:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[1]) + fprintf(stderr, " FInstruction Counting -- Cycles with maximum instruction issue:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[2]) + fprintf(stderr, "\tCycles integer units are idle:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[3]) + fprintf(stderr, "\tHardware interrupts:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[4]) + fprintf(stderr, "\tInteger instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[5]) + fprintf(stderr, "\tTotal cycles:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[6]) + fprintf(stderr, "\tInstructions issued:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[7]) + fprintf(stderr, "\tInstructions completed:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[8]) + fprintf(stderr, "\tVector/SIMD instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + } + + else if (ExpEnv.stats_struc.papi_event_type == 5) { + if (ExpEnv.stats_struc.papi_valid_values[0]) + fprintf(stderr, "\tL1 data cache accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[1]) + fprintf(stderr, "\tL1 data cache hits:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[2]) + fprintf(stderr, "\tL1 data cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[3]) + fprintf(stderr, "\tL1 data cache reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[4]) + fprintf(stderr, "\tL1 data cache writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[5]) + fprintf(stderr, "\tL1 instruction cache accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[6]) + fprintf(stderr, "\tL1 instruction cache hits:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[7]) + fprintf(stderr, "\tL1 instruction cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[8]) + fprintf(stderr, "\tL1 instruction cache reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[9]) + fprintf(stderr, "\tL1 instruction cache writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[10]) + fprintf(stderr, "\tL1 load misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[11]) + fprintf(stderr, "\tL1 store misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[12]) + fprintf(stderr, "\tL1 total cache accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[13]) + fprintf(stderr, "\tL1 total cache hits:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[14]) + fprintf(stderr, "\tL1 total cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[15]) + fprintf(stderr, "\tL1 total cache reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[16]) + fprintf(stderr, "\tL1 total cache writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[17]) + fprintf(stderr, "\tL2 data cache accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[18]) + fprintf(stderr, "\tL2 data cache hits:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[19]) + fprintf(stderr, "\tL2 data cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[20]) + fprintf(stderr, "\tL2 data cache reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[21]) + fprintf(stderr, "\tL2 data cache writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[22]) + fprintf(stderr, "\tL2 instruction cache accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[23]) + fprintf(stderr, "\tL2 instruction cache hits:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[24]) + fprintf(stderr, "\tL2 instruction cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[25]) + fprintf(stderr, "\tL2 instruction cache reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[26]) + fprintf(stderr, "\tL2 instruction cache writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[27]) + fprintf(stderr, "\tL2 load misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[28]) + fprintf(stderr, "\tL2 store misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[29]) + fprintf(stderr, "\tL2 total cache accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[30]) + fprintf(stderr, "\tL2 total cache hits:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[31]) + fprintf(stderr, "\tL2 total cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[32]) + fprintf(stderr, "\tL2 total cache reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[33]) + fprintf(stderr, "\tL2 total cache writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[34]) + fprintf(stderr, "\tL3 data cache accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[35]) + fprintf(stderr, "\tL3 data cache hits:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[36]) + fprintf(stderr, "\tL3 data cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[37]) + fprintf(stderr, "\tL3 data cache reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[38]) + fprintf(stderr, "\tL3 data cache writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[39]) + fprintf(stderr, "\tL3 instruction cache accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[40]) + fprintf(stderr, "\tL3 instruction cache hits:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[41]) + fprintf(stderr, "\tL3 instruction cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[42]) + fprintf(stderr, "\tL3 instruction cache reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[43]) + fprintf(stderr, "\tL3 instruction cache writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[44]) + fprintf(stderr, "\tL3 load misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[45]) + fprintf(stderr, "\tL3 store misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[46]) + fprintf(stderr, "\tL3 total cache accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[47]) + fprintf(stderr, "\tL3 total cache hits:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[48]) + fprintf(stderr, "\tL3 total cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[49]) + fprintf(stderr, "\tL3 total cache reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[50]) + fprintf(stderr, "\tL3 total cache writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + } + + else if (ExpEnv.stats_struc.papi_event_type == 6) { + if (ExpEnv.stats_struc.papi_valid_values[0]) + fprintf(stderr, "\tLoad instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[1]) + fprintf(stderr, "\tLoad/store instructions completed:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[2]) + fprintf(stderr, "\tCycles load/store units are idle:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[3]) + fprintf(stderr, "\tCycles Stalled Waiting for memory reads:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[4]) + fprintf(stderr, "\tCycles Stalled Waiting for memory accesses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[5]) + fprintf(stderr, "\tCycles Stalled Waiting for memory writes:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[6]) + fprintf(stderr, "\tData prefetch cache misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[7]) + fprintf(stderr, "\tCycles stalled on any resource:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[8]) + fprintf(stderr, "\tStore instructions:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[9]) + fprintf(stderr, "\tCycles with no instructions completed:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[10]) + fprintf(stderr, "\tCycles with no instruction issue:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[11]) + fprintf(stderr, "\tSynchronization instructions completed:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + } + + else if (ExpEnv.stats_struc.papi_event_type == 7) { + if (ExpEnv.stats_struc.papi_valid_values[0]) + fprintf(stderr, "\tData translation lookaside buffer misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[1]) + fprintf(stderr, "\tInstruction translation lookaside buffer misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[2]) + fprintf(stderr, "\tTranslation lookaside buffer shootdowns:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + if (ExpEnv.stats_struc.papi_valid_values[3]) + fprintf(stderr, "\tTotal translation lookaside buffer misses:: %lld\n", ExpEnv.stats_struc.papi_values[k++]); + } + + fprintf(stderr, "------------------------------\n"); + } + + return TRUE; +} + +#pragma GCC diagnostic pop + +void +Yap_InitJitStatisticPreds(void) +{ + Yap_InitCPred("init_low_level_stats", 1, p_init_low_level_stats, SafePredFlag); + Yap_InitCPred("statistics_jit", 0, p_statistics_jit, SafePredFlag); +} diff --git a/JIT/jit_transformpreds.c b/JIT/jit_transformpreds.c new file mode 100644 index 000000000..d0b97f171 --- /dev/null +++ b/JIT/jit_transformpreds.c @@ -0,0 +1,1213 @@ +/************************************************************************* +* * +* Extension for YAP Prolog * +* * +* Copyright G.S.Oliveira, A.F.Silva and Universidade Estadual de Maringá * +* * +* Yap Prolog was developed at NCCUP - Universidade do Porto * +* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * +* * +************************************************************************** +* * +* File: jit_transformpreds.c * +* comments: JIT Compiler Optimizations predicates * +* * +* Last rev: 2013-10-18 * +*************************************************************************/ + +#include "jit_predicates.hh" + +#define N_TRANSFORM_PASSES 69 + +// Disable one (passed by argument) LLVM transform pass +static Int p_disable_transform_pass( USES_REGS1 ); + +// Enable one (passed by argument) LLVM transform pass +static Int p_transform_pass( USES_REGS1 ); + +// Enable one (passed by argument) LLVM transform pass +static Int p_enable_transform_pass( USES_REGS1 ); + +// Enable a list (passed by argument) of LLVM transform passes +static Int p_transform_passes( USES_REGS1 ); + +// Enable all available LLVM transform passes +static Int p_enable_all_transform_passes( USES_REGS1 ); + +// Disable all available LLVM transform passes +static Int p_disable_all_transform_passes( USES_REGS1 ); + +// Enable n LLVM transform passes (randomly) +static Int p_n_transform_passes( USES_REGS1 ); + +// Enable a transform level +static Int p_transform_level( USES_REGS1 ); + +// Max element of Argument Promotion Pass +static Int p_argument_promotion_max_elements( USES_REGS1 ); + +// Threshold of Scalar Repl Aggregates Pass +static Int p_scalar_replace_aggregates_threshold( USES_REGS1 ); + +// Threshold of Loop Unroll Pass +static Int p_loop_unroll_threshold( USES_REGS1 ); + +// Threshold of Function Inlining Pass +static Int p_inline_threshold( USES_REGS1 ); + +// Eliminates (or not) only debugging information on Strip Symbols Pass +static Int p_strip_symbols_pass_type( USES_REGS1 ); + +// Optimizes (or not) for size on Loop Unswitch Pass +static Int p_loop_unswitch_optimize_for_size( USES_REGS1 ); + +/* + * Default value of 'max elements on Argument Promotion Pass * + * 'threshold of Scalar Repl Aggregates Pass * + * 'threshold of Loop Unroll Pass * + * 'threshold of Function Inlining Pass * + * 'Strip Symbols Pass * + * 'Loop Unswitch Pass * +*/ +static Int p_default_optimization_args( USES_REGS1 ); + +// Same as 'p_default_optimization_args' +static Int p_reset_optimization_args( USES_REGS1 ); + +// Enable IPO by LLVM +static Int p_enable_unit_at_time( USES_REGS1 ); + +// Enable libcalls simplification by LLVM +static Int p_enable_simplify_libcalls( USES_REGS1 ); + +// Disable IPO by LLVM +static Int p_disable_unit_at_time( USES_REGS1 ); + +// Disable libcalls simplification by LLVM +static Int p_disable_simplify_libcalls( USES_REGS1 ); + +// Enable (or not) link-time optimization +static Int p_link_time_opt1( USES_REGS1 ); + +/* + * Same as 'p_link_time_opt1', but accepts 3 arguments: * + * 1 -- Should I apply this opt? * + * 2 -- Should I run internalize? * + * 3 -- Should I run inliner? * +*/ +static Int p_link_time_opt3( USES_REGS1 ); + +// Enable link-time optimization. Same as 'link_time_opt(true)' +static Int p_enable_link_time_opt( USES_REGS1 ); + +/* + * Same as 'p_enable_link_time_opt', but accepts 2 arguments: * + * 1 -- Should I run internalize? * + * 2 -- Should I run inliner? * +*/ +static Int p_enable_link_time_opt2( USES_REGS1 ); + +// Disable link-time optimization. +static Int p_disable_link_time_opt( USES_REGS1 ); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wimplicit-function-declaration" + +static Int +p_disable_transform_pass( USES_REGS1 ) +{ + // First: stores what transform pass should be disabled + + Term t = Deref(ARG1); + enumTransformPasses f; + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + Int v = IntOfTerm(t); + if (v < 0 || v >= N_TRANSFORM_PASSES) { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + f = (enumTransformPasses)v; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + if (strcmp(str, "ALL") == 0) { + // atom is 'all' -- this will disable all passes + if (ExpEnv.transform_struc.act_tr) free(ExpEnv.transform_struc.act_tr); + ExpEnv.transform_struc.act_tr = NULL; + ExpEnv.transform_struc.n = 0; + return TRUE; + } + + // Detects one pass according to 'str' -- store it + if (strcmp(str, "AGGRESSIVEDCE") == 0 || strcmp(str, "ADCE") == 0) f = t_createAggressiveDCEPass; + else if (strcmp(str, "ARGUMENTPROMOTION") == 0 || strcmp(str, "ARGPROMOTION") == 0) f = t_createArgumentPromotionPass; + else if (strcmp(str, "BBVECTORIZE") == 0) f = t_createBBVectorizePass; + else if (strcmp(str, "BLOCKEXTRACTOR") == 0 || strcmp(str, "EXTRACTBLOCKS") == 0) f = t_createBlockExtractorPass; + else if (strcmp(str, "BLOCKPLACEMENT") == 0) f = t_createBlockPlacementPass; + else if (strcmp(str, "BREAKCRITICALEDGES") == 0 || strcmp(str, "BREAKCRITEDGES") == 0) f = t_createBreakCriticalEdgesPass; + else if (strcmp(str, "CFGSIMPLIFICATION") == 0 || strcmp(str, "SIMPLIFYCFG") == 0) f = t_createCFGSimplificationPass; + else if (strcmp(str, "CODEGENPREPARE") == 0) f = t_createCodeGenPreparePass; + else if (strcmp(str, "CONSTANTMERGE") == 0 || strcmp(str, "CONSTMERGE") == 0) f = t_createConstantMergePass; + else if (strcmp(str, "CONSTANTPROPAGATION") == 0 || strcmp(str, "CONSTPROP") == 0) f = t_createConstantPropagationPass; + else if (strcmp(str, "CORRELATEDVALUEPROPAGATION") == 0 || strcmp(str, "CORRELATEDPROPAGATION") == 0) f = t_createCorrelatedValuePropagationPass; + else if (strcmp(str, "DEADARGELIMINATION") == 0 || strcmp(str, "DEADARGELIM") == 0) f = t_createDeadArgEliminationPass; + else if (strcmp(str, "DEADARGHACKING") == 0 || strcmp(str, "DEADARGHAX0R") == 0) f = t_createDeadArgHackingPass; + else if (strcmp(str, "DEADCODEELIMINATION") == 0 || strcmp(str, "DCE") == 0) f = t_createDeadCodeEliminationPass; + else if (strcmp(str, "DEADINSTELIMINATION") == 0 || strcmp(str, "DIE") == 0) f = t_createDeadInstEliminationPass; + else if (strcmp(str, "DEADSTOREELIMINATION") == 0 || strcmp(str, "DSE") == 0) f = t_createDeadStoreEliminationPass; + else if (strcmp(str, "DEMOTEREGISTERTOMEMORY") == 0 || strcmp(str, "REG2MEM") == 0) f = t_createDemoteRegisterToMemoryPass; + else if (strcmp(str, "EARLYCSE") == 0) f = t_createEarlyCSEPass; + else if (strcmp(str, "FUNCTIONATTRS") == 0) f = t_createFunctionAttrsPass; + else if (strcmp(str, "FUNCTIONINLINING") == 0 || strcmp(str, "INLINE") == 0) f = t_createFunctionInliningPass; + else if (strcmp(str, "GLOBALDCE") == 0) f = t_createGlobalDCEPass; + else if (strcmp(str, "GLOBALOPTIMIZER") == 0 || strcmp(str, "GLOBALOPT") == 0) f = t_createGlobalOptimizerPass; + else if (strcmp(str, "GVEXTRACTION") == 0) f = t_createGVExtractionPass; + else if (strcmp(str, "GVN") == 0) f = t_createGVNPass; + else if (strcmp(str, "INDVARSIMPLIFY") == 0 || strcmp(str, "INDVARS") == 0) f = t_createIndVarSimplifyPass; + else if (strcmp(str, "INSTRUCTIONCOMBINING") == 0 || strcmp(str, "INSTCOMBINE") == 0) f = t_createInstructionCombiningPass; + else if (strcmp(str, "INSTRUCTIONNAMER") == 0 || strcmp(str, "INSTNAMER") == 0) f = t_createInstructionNamerPass; + else if (strcmp(str, "INSTRUCTIONSIMPLIFIER") == 0 || strcmp(str, "INSTSIMPLIFY") == 0) f = t_createInstructionSimplifierPass; + else if (strcmp(str, "INTERNALIZE") == 0) f = t_createInternalizePass; + else if (strcmp(str, "IPCONSTANTPROPAGATION") == 0 || strcmp(str, "IPCONSTPROP") == 0) f = t_createIPConstantPropagationPass; + else if (strcmp(str, "IPSCCP") == 0) f = t_createIPSCCPPass; + else if (strcmp(str, "JUMPTHREADING") == 0) f = t_createJumpThreadingPass; + else if (strcmp(str, "LCSSA") == 0) f = t_createLCSSAPass; + else if (strcmp(str, "LICM") == 0) f = t_createLICMPass; + else if (strcmp(str, "LOOPDELETION") == 0) f = t_createLoopDeletionPass; + else if (strcmp(str, "LOOPEXTRACTOR") == 0 || strcmp(str, "LOOPEXTRACT") == 0) f = t_createLoopExtractorPass; + else if (strcmp(str, "LOOPIDIOM") == 0) f = t_createLoopIdiomPass; + else if (strcmp(str, "LOOPINSTSIMPLIFY") == 0) f = t_createLoopInstSimplifyPass; + else if (strcmp(str, "LOOPROTATE") == 0) f = t_createLoopRotatePass; + else if (strcmp(str, "LOOPSIMPLIFY") == 0) f = t_createLoopSimplifyPass; + else if (strcmp(str, "LOOPSTRENGTHREDUCE") == 0 || strcmp(str, "LOOPREDUCE") == 0) f = t_createLoopStrengthReducePass; + else if (strcmp(str, "LOOPUNROLL") == 0) f = t_createLoopUnrollPass; + else if (strcmp(str, "LOOPUNSWITCH") == 0) f = t_createLoopUnswitchPass; + else if (strcmp(str, "LOWERATOMIC") == 0) f = t_createLowerAtomicPass; + else if (strcmp(str, "LOWEREXPECTINTRINSIC") == 0 || strcmp(str, "LOWEREXPECT") == 0) f = t_createLowerExpectIntrinsicPass; + else if (strcmp(str, "LOWERINVOKE") == 0) f = t_createLowerInvokePass; + else if (strcmp(str, "LOWERSWITCH") == 0) f = t_createLowerSwitchPass; + else if (strcmp(str, "MEMCPYOPT") == 0) f = t_createMemCpyOptPass; + else if (strcmp(str, "MERGEFUNCTIONS") == 0 || strcmp(str, "MERGEFUNC") == 0) f = t_createMergeFunctionsPass; + else if (strcmp(str, "OBJCARCAPELIM") == 0) f = t_createObjCARCAPElimPass; + else if (strcmp(str, "OBJCARCCONTRACT") == 0) f = t_createObjCARCContractPass; + else if (strcmp(str, "OBJCARCEXPAND") == 0) f = t_createObjCARCExpandPass; + else if (strcmp(str, "OBJCARCOPT") == 0 || strcmp(str, "OBJCARC") == 0) f = t_createObjCARCOptPass; + else if (strcmp(str, "PARTIALINLINING") == 0 || strcmp(str, "PARTIALINLINER") == 0) f = t_createPartialInliningPass; + else if (strcmp(str, "PROMOTEMEMORYTOREGISTER") == 0 || strcmp(str, "MEM2REG") == 0) f = t_createPromoteMemoryToRegisterPass; + else if (strcmp(str, "PRUNEEH") == 0) f = t_createPruneEHPass; + else if (strcmp(str, "REASSOCIATE") == 0) f = t_createReassociatePass; + else if (strcmp(str, "SCALARREPLAGGREGATES") == 0 || strcmp(str, "SCALARREPL") == 0) f = t_createScalarReplAggregatesPass; + else if (strcmp(str, "SCCP") == 0) f = t_createSCCPPass; + else if (strcmp(str, "SIMPLIFYLIBCALLS") == 0) f = t_createSimplifyLibCallsPass; + else if (strcmp(str, "SINGLELOOPEXTRACTOR") == 0 || strcmp(str, "LOOPEXTRACTSINGLE") == 0) f = t_createSingleLoopExtractorPass; + else if (strcmp(str, "SINKING") == 0 || strcmp(str, "SINK") == 0) f = t_createSinkingPass; + else if (strcmp(str, "STRIPDEADDEBUGINFO") == 0) f = t_createStripDeadDebugInfoPass; + else if (strcmp(str, "STRIPDEADPROTOTYPES") == 0) f = t_createStripDeadPrototypesPass; + else if (strcmp(str, "STRIPDEBUGDECLARE") == 0) f = t_createStripDebugDeclarePass; + else if (strcmp(str, "STRIPNONDEBUGSYMBOLS") == 0) f = t_createStripNonDebugSymbolsPass; + else if (strcmp(str, "STRIPSYMBOLS") == 0 || strcmp(str, "STRIP") == 0) f = t_createStripSymbolsPass; + else if (strcmp(str, "TAILCALLELIMINATION") == 0 || strcmp(str, "TAILCALLELIM") == 0) f = t_createTailCallEliminationPass; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Transform pass"); + return FALSE; + } + + // Second: creates a new list with all transform on 'ExpEnv.analysis_struc.act_tr' but that transform stored on first step + enumTransformPasses *tmplist = NULL; + COUNT tmpn = 0; + int i = 0; + while (i < ExpEnv.transform_struc.n) { + if (ExpEnv.transform_struc.act_tr[i] != f) { + tmpn += 1; + tmplist = (enumTransformPasses*)realloc(tmplist, tmpn*sizeof(enumTransformPasses)); + tmplist[tmpn-1] = ExpEnv.transform_struc.act_tr[i]; + } + i += 1; + } + + // Third: makes 'ExpEnv.analysis_struc.act_tr' to point to new list created on second step + free(ExpEnv.transform_struc.act_tr); + ExpEnv.transform_struc.n = tmpn; + ExpEnv.transform_struc.act_tr = tmplist; + return TRUE; +} + +static Int +p_transform_pass( USES_REGS1 ) +{ + // First: disables analysis pass (if be active) + p_disable_transform_pass(); + + // Second: valids argument and inserts new transform pass + // valid values for ARG1 are 'integer' and 'atom' + Term t = Deref(ARG1); + Int v; + if (IsIntTerm(t)) { + // ARG1 is integer + v = IntOfTerm(t); + if (v < 0 || v >= N_TRANSFORM_PASSES) { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + // creates a new slot in 'ExpEnv.analysis_struc.act_tr' and appends the pass in it + ExpEnv.transform_struc.n += 1; + ExpEnv.transform_struc.act_tr = (enumTransformPasses*) + realloc(ExpEnv.transform_struc.act_tr, ExpEnv.transform_struc.n * sizeof(enumTransformPasses)); + ExpEnv.transform_struc.act_tr[ExpEnv.transform_struc.n-1] = (enumTransformPasses)v; + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects one pass according to 'str' + if (strcmp(str, "AGGRESSIVEDCE") == 0 || strcmp(str, "ADCE") == 0) v = t_createAggressiveDCEPass; + else if (strcmp(str, "ARGUMENTPROMOTION") == 0 || strcmp(str, "ARGPROMOTION") == 0) v = t_createArgumentPromotionPass; + else if (strcmp(str, "BBVECTORIZE") == 0) v = t_createBBVectorizePass; + else if (strcmp(str, "BLOCKEXTRACTOR") == 0 || strcmp(str, "EXTRACTBLOCKS") == 0) v = t_createBlockExtractorPass; + else if (strcmp(str, "BLOCKPLACEMENT") == 0) v = t_createBlockPlacementPass; + else if (strcmp(str, "BREAKCRITICALEDGES") == 0 || strcmp(str, "BREAKCRITEDGES") == 0) v = t_createBreakCriticalEdgesPass; + else if (strcmp(str, "CFGSIMPLIFICATION") == 0 || strcmp(str, "SIMPLIFYCFG") == 0) v = t_createCFGSimplificationPass; + else if (strcmp(str, "CODEGENPREPARE") == 0) v = t_createCodeGenPreparePass; + else if (strcmp(str, "CONSTANTMERGE") == 0 || strcmp(str, "CONSTMERGE") == 0) v = t_createConstantMergePass; + else if (strcmp(str, "CONSTANTPROPAGATION") == 0 || strcmp(str, "CONSTPROP") == 0) v = t_createConstantPropagationPass; + else if (strcmp(str, "CORRELATEDVALUEPROPAGATION") == 0 || strcmp(str, "CORRELATEDPROPAGATION") == 0) v = t_createCorrelatedValuePropagationPass; + else if (strcmp(str, "DEADARGELIMINATION") == 0 || strcmp(str, "DEADARGELIM") == 0) v = t_createDeadArgEliminationPass; + else if (strcmp(str, "DEADARGHACKING") == 0 || strcmp(str, "DEADARGHAX0R") == 0) v = t_createDeadArgHackingPass; + else if (strcmp(str, "DEADCODEELIMINATION") == 0 || strcmp(str, "DCE") == 0) v = t_createDeadCodeEliminationPass; + else if (strcmp(str, "DEADINSTELIMINATION") == 0 || strcmp(str, "DIE") == 0) v = t_createDeadInstEliminationPass; + else if (strcmp(str, "DEADSTOREELIMINATION") == 0 || strcmp(str, "DSE") == 0) v = t_createDeadStoreEliminationPass; + else if (strcmp(str, "DEMOTEREGISTERTOMEMORY") == 0 || strcmp(str, "REG2MEM") == 0) v = t_createDemoteRegisterToMemoryPass; + else if (strcmp(str, "EARLYCSE") == 0) v = t_createEarlyCSEPass; + else if (strcmp(str, "FUNCTIONATTRS") == 0) v = t_createFunctionAttrsPass; + else if (strcmp(str, "FUNCTIONINLINING") == 0 || strcmp(str, "INLINE") == 0) v = t_createFunctionInliningPass; + else if (strcmp(str, "GLOBALDCE") == 0) v = t_createGlobalDCEPass; + else if (strcmp(str, "GLOBALOPTIMIZER") == 0 || strcmp(str, "GLOBALOPT") == 0) v = t_createGlobalOptimizerPass; + else if (strcmp(str, "GVEXTRACTION") == 0) v = t_createGVExtractionPass; + else if (strcmp(str, "GVN") == 0) v = t_createGVNPass; + else if (strcmp(str, "INDVARSIMPLIFY") == 0 || strcmp(str, "INDVARS") == 0) v = t_createIndVarSimplifyPass; + else if (strcmp(str, "INSTRUCTIONCOMBINING") == 0 || strcmp(str, "INSTCOMBINE") == 0) v = t_createInstructionCombiningPass; + else if (strcmp(str, "INSTRUCTIONNAMER") == 0 || strcmp(str, "INSTNAMER") == 0) v = t_createInstructionNamerPass; + else if (strcmp(str, "INSTRUCTIONSIMPLIFIER") == 0 || strcmp(str, "INSTSIMPLIFY") == 0) v = t_createInstructionSimplifierPass; + else if (strcmp(str, "INTERNALIZE") == 0) v = t_createInternalizePass; + else if (strcmp(str, "IPCONSTANTPROPAGATION") == 0 || strcmp(str, "IPCONSTPROP") == 0) v = t_createIPConstantPropagationPass; + else if (strcmp(str, "IPSCCP") == 0) v = t_createIPSCCPPass; + else if (strcmp(str, "JUMPTHREADING") == 0) v = t_createJumpThreadingPass; + else if (strcmp(str, "LCSSA") == 0) v = t_createLCSSAPass; + else if (strcmp(str, "LICM") == 0) v = t_createLICMPass; + else if (strcmp(str, "LOOPDELETION") == 0) v = t_createLoopDeletionPass; + else if (strcmp(str, "LOOPEXTRACTOR") == 0 || strcmp(str, "LOOPEXTRACT") == 0) v = t_createLoopExtractorPass; + else if (strcmp(str, "LOOPIDIOM") == 0) v = t_createLoopIdiomPass; + else if (strcmp(str, "LOOPINSTSIMPLIFY") == 0) v = t_createLoopInstSimplifyPass; + else if (strcmp(str, "LOOPROTATE") == 0) v = t_createLoopRotatePass; + else if (strcmp(str, "LOOPSIMPLIFY") == 0) v = t_createLoopSimplifyPass; + else if (strcmp(str, "LOOPSTRENGTHREDUCE") == 0 || strcmp(str, "LOOPREDUCE") == 0) v = t_createLoopStrengthReducePass; + else if (strcmp(str, "LOOPUNROLL") == 0) v = t_createLoopUnrollPass; + else if (strcmp(str, "LOOPUNSWITCH") == 0) v = t_createLoopUnswitchPass; + else if (strcmp(str, "LOWERATOMIC") == 0) v = t_createLowerAtomicPass; + else if (strcmp(str, "LOWEREXPECTINTRINSIC") == 0 || strcmp(str, "LOWEREXPECT") == 0) v = t_createLowerExpectIntrinsicPass; + else if (strcmp(str, "LOWERINVOKE") == 0) v = t_createLowerInvokePass; + else if (strcmp(str, "LOWERSWITCH") == 0) v = t_createLowerSwitchPass; + else if (strcmp(str, "MEMCPYOPT") == 0) v = t_createMemCpyOptPass; + else if (strcmp(str, "MERGEFUNCTIONS") == 0 || strcmp(str, "MERGEFUNC") == 0) v = t_createMergeFunctionsPass; + else if (strcmp(str, "OBJCARCAPELIM") == 0) v = t_createObjCARCAPElimPass; + else if (strcmp(str, "OBJCARCCONTRACT") == 0) v = t_createObjCARCContractPass; + else if (strcmp(str, "OBJCARCEXPAND") == 0) v = t_createObjCARCExpandPass; + else if (strcmp(str, "OBJCARCOPT") == 0 || strcmp(str, "OBJCARC") == 0) v = t_createObjCARCOptPass; + else if (strcmp(str, "PARTIALINLINING") == 0 || strcmp(str, "PARTIALINLINER") == 0) v = t_createPartialInliningPass; + else if (strcmp(str, "PROMOTEMEMORYTOREGISTER") == 0 || strcmp(str, "MEM2REG") == 0) v = t_createPromoteMemoryToRegisterPass; + else if (strcmp(str, "PRUNEEH") == 0) v = t_createPruneEHPass; + else if (strcmp(str, "REASSOCIATE") == 0) v = t_createReassociatePass; + else if (strcmp(str, "SCALARREPLAGGREGATES") == 0 || strcmp(str, "SCALARREPL") == 0) v = t_createScalarReplAggregatesPass; + else if (strcmp(str, "SCCP") == 0) v = t_createSCCPPass; + else if (strcmp(str, "SIMPLIFYLIBCALLS") == 0) v = t_createSimplifyLibCallsPass; + else if (strcmp(str, "SINGLELOOPEXTRACTOR") == 0 || strcmp(str, "LOOPEXTRACTSINGLE") == 0) v = t_createSingleLoopExtractorPass; + else if (strcmp(str, "SINKING") == 0 || strcmp(str, "SINK") == 0) v = t_createSinkingPass; + else if (strcmp(str, "STRIPDEADDEBUGINFO") == 0) v = t_createStripDeadDebugInfoPass; + else if (strcmp(str, "STRIPDEADPROTOTYPES") == 0) v = t_createStripDeadPrototypesPass; + else if (strcmp(str, "STRIPDEBUGDECLARE") == 0) v = t_createStripDebugDeclarePass; + else if (strcmp(str, "STRIPNONDEBUGSYMBOLS") == 0) v = t_createStripNonDebugSymbolsPass; + else if (strcmp(str, "STRIPSYMBOLS") == 0 || strcmp(str, "STRIP") == 0) v = t_createStripSymbolsPass; + else if (strcmp(str, "TAILCALLELIMINATION") == 0 || strcmp(str, "TAILCALLELIM") == 0) v = t_createTailCallEliminationPass; + else { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + + // creates a new slot in 'ExpEnv.analysis_struc.act_tr' and appends the pass in it + ExpEnv.transform_struc.n += 1; + ExpEnv.transform_struc.act_tr = (enumTransformPasses*) + realloc(ExpEnv.transform_struc.act_tr, ExpEnv.transform_struc.n * sizeof(enumTransformPasses)); + ExpEnv.transform_struc.act_tr[ExpEnv.transform_struc.n-1] = v; + ExpEnv.transform_struc.optlevel = -1; // using this, optlevel won't be used + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Transform pass"); + return FALSE; + } +} + +static Int +p_enable_transform_pass( USES_REGS1 ) +{ + return p_transform_pass(); +} + +static Int +p_transform_passes( USES_REGS1 ) +{ + int i = 0, j = 0; + char *tmp; + // valid values for ARG1 are 'atom' and 'list (pair)' + Term t = Deref(ARG1); + if (IsAtomTerm(t)) { + // ARG1 is atom + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // If ARG1 is atom, 'all' is the only valid value + if (strcmp(str, "ALL") == 0) { + // First: disables all transform passes + free(ExpEnv.transform_struc.act_tr); + ExpEnv.transform_struc.act_tr = NULL; + ExpEnv.transform_struc.n = 0; + + // Second, insert all transform passes on 'ExpEnv.analysis_struc.act_tr' + int i; + for (i = 0; i < N_TRANSFORM_PASSES; i++) { + ExpEnv.transform_struc.n += 1; + ExpEnv.transform_struc.act_tr = (enumTransformPasses*)realloc(ExpEnv.transform_struc.act_tr, ExpEnv.transform_struc.n * sizeof(enumTransformPasses)); + ExpEnv.transform_struc.act_tr[ExpEnv.transform_struc.n-1] = i; + } + return TRUE; + } + // value passed by argument is out of known range (ARG1 differs of 'all') + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + else if (IsPairTerm(t)) { + // ARG1 is list + // First: disables all transform passes + if (ExpEnv.transform_struc.act_tr) free(ExpEnv.transform_struc.act_tr); + ExpEnv.transform_struc.act_tr = NULL; + ExpEnv.transform_struc.n = 0; + + // Second: scrolls over the list treating each element individually + Term u = HeadOfTermCell(t); // get head of list 't' + u = Deref(u); + while (1) { + Int v; + enumTransformPasses w; + + // valid values for head are 'integer' and 'atom' (the list can contain both) + if (IsIntTerm(u)) { + // head is integer + v = IntOfTerm(u); + if (v < 0 || v >= N_TRANSFORM_PASSES) { + // head's value is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + + // insert transform pass defined by 'head' on 'ExpEnv.analysis_struc.act_tr' + ExpEnv.transform_struc.n += 1; + ExpEnv.transform_struc.act_tr = (enumTransformPasses*)realloc(ExpEnv.transform_struc.act_tr, ExpEnv.transform_struc.n * sizeof(enumTransformPasses)); + ExpEnv.transform_struc.act_tr[ExpEnv.transform_struc.n-1] = (enumTransformPasses)v; + } + else if (IsAtomTerm(u)) { + // head is atom + int i = 0, j = 0; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detects one pass according to 'str' + if (strcmp(str, "AGGRESSIVEDCE") == 0 || strcmp(str, "ADCE") == 0) w = t_createAggressiveDCEPass; + else if (strcmp(str, "ARGUMENTPROMOTION") == 0 || strcmp(str, "ARGPROMOTION") == 0) w = t_createArgumentPromotionPass; + else if (strcmp(str, "BBVECTORIZE") == 0) w = t_createBBVectorizePass; + else if (strcmp(str, "BLOCKEXTRACTOR") == 0 || strcmp(str, "EXTRACTBLOCKS") == 0) w = t_createBlockExtractorPass; + else if (strcmp(str, "BLOCKPLACEMENT") == 0) w = t_createBlockPlacementPass; + else if (strcmp(str, "BREAKCRITICALEDGES") == 0 || strcmp(str, "BREAKCRITEDGES") == 0) w = t_createBreakCriticalEdgesPass; + else if (strcmp(str, "CFGSIMPLIFICATION") == 0 || strcmp(str, "SIMPLIFYCFG") == 0) w = t_createCFGSimplificationPass; + else if (strcmp(str, "CODEGENPREPARE") == 0) w = t_createCodeGenPreparePass; + else if (strcmp(str, "CONSTANTMERGE") == 0 || strcmp(str, "CONSTMERGE") == 0) w = t_createConstantMergePass; + else if (strcmp(str, "CONSTANTPROPAGATION") == 0 || strcmp(str, "CONSTPROP") == 0) w = t_createConstantPropagationPass; + else if (strcmp(str, "CORRELATEDVALUEPROPAGATION") == 0 || strcmp(str, "CORRELATEDPROPAGATION") == 0) w = t_createCorrelatedValuePropagationPass; + else if (strcmp(str, "DEADARGELIMINATION") == 0 || strcmp(str, "DEADARGELIM") == 0) w = t_createDeadArgEliminationPass; + else if (strcmp(str, "DEADARGHACKING") == 0 || strcmp(str, "DEADARGHAX0R") == 0) w = t_createDeadArgHackingPass; + else if (strcmp(str, "DEADCODEELIMINATION") == 0 || strcmp(str, "DCE") == 0) w = t_createDeadCodeEliminationPass; + else if (strcmp(str, "DEADINSTELIMINATION") == 0 || strcmp(str, "DIE") == 0) w = t_createDeadInstEliminationPass; + else if (strcmp(str, "DEADSTOREELIMINATION") == 0 || strcmp(str, "DSE") == 0) w = t_createDeadStoreEliminationPass; + else if (strcmp(str, "DEMOTEREGISTERTOMEMORY") == 0 || strcmp(str, "REG2MEM") == 0) w = t_createDemoteRegisterToMemoryPass; + else if (strcmp(str, "EARLYCSE") == 0) w = t_createEarlyCSEPass; + else if (strcmp(str, "FUNCTIONATTRS") == 0) w = t_createFunctionAttrsPass; + else if (strcmp(str, "FUNCTIONINLINING") == 0 || strcmp(str, "INLINE") == 0) w = t_createFunctionInliningPass; + else if (strcmp(str, "GLOBALDCE") == 0) w = t_createGlobalDCEPass; + else if (strcmp(str, "GLOBALOPTIMIZER") == 0 || strcmp(str, "GLOBALOPT") == 0) w = t_createGlobalOptimizerPass; + else if (strcmp(str, "GVEXTRACTION") == 0) w = t_createGVExtractionPass; + else if (strcmp(str, "GVN") == 0) w = t_createGVNPass; + else if (strcmp(str, "INDVARSIMPLIFY") == 0 || strcmp(str, "INDVARS") == 0) w = t_createIndVarSimplifyPass; + else if (strcmp(str, "INSTRUCTIONCOMBINING") == 0 || strcmp(str, "INSTCOMBINE") == 0) w = t_createInstructionCombiningPass; + else if (strcmp(str, "INSTRUCTIONNAMER") == 0 || strcmp(str, "INSTNAMER") == 0) w = t_createInstructionNamerPass; + else if (strcmp(str, "INSTRUCTIONSIMPLIFIER") == 0 || strcmp(str, "INSTSIMPLIFY") == 0) w = t_createInstructionSimplifierPass; + else if (strcmp(str, "INTERNALIZE") == 0) w = t_createInternalizePass; + else if (strcmp(str, "IPCONSTANTPROPAGATION") == 0 || strcmp(str, "IPCONSTPROP") == 0) w = t_createIPConstantPropagationPass; + else if (strcmp(str, "IPSCCP") == 0) w = t_createIPSCCPPass; + else if (strcmp(str, "JUMPTHREADING") == 0) w = t_createJumpThreadingPass; + else if (strcmp(str, "LCSSA") == 0) w = t_createLCSSAPass; + else if (strcmp(str, "LICM") == 0) w = t_createLICMPass; + else if (strcmp(str, "LOOPDELETION") == 0) w = t_createLoopDeletionPass; + else if (strcmp(str, "LOOPEXTRACTOR") == 0 || strcmp(str, "LOOPEXTRACT") == 0) w = t_createLoopExtractorPass; + else if (strcmp(str, "LOOPIDIOM") == 0) w = t_createLoopIdiomPass; + else if (strcmp(str, "LOOPINSTSIMPLIFY") == 0) w = t_createLoopInstSimplifyPass; + else if (strcmp(str, "LOOPROTATE") == 0) w = t_createLoopRotatePass; + else if (strcmp(str, "LOOPSIMPLIFY") == 0) w = t_createLoopSimplifyPass; + else if (strcmp(str, "LOOPSTRENGTHREDUCE") == 0 || strcmp(str, "LOOPREDUCE") == 0) w = t_createLoopStrengthReducePass; + else if (strcmp(str, "LOOPUNROLL") == 0) w = t_createLoopUnrollPass; + else if (strcmp(str, "LOOPUNSWITCH") == 0) w = t_createLoopUnswitchPass; + else if (strcmp(str, "LOWERATOMIC") == 0) w = t_createLowerAtomicPass; + else if (strcmp(str, "LOWEREXPECTINTRINSIC") == 0 || strcmp(str, "LOWEREXPECT") == 0) w = t_createLowerExpectIntrinsicPass; + else if (strcmp(str, "LOWERINVOKE") == 0) w = t_createLowerInvokePass; + else if (strcmp(str, "LOWERSWITCH") == 0) w = t_createLowerSwitchPass; + else if (strcmp(str, "MEMCPYOPT") == 0) w = t_createMemCpyOptPass; + else if (strcmp(str, "MERGEFUNCTIONS") == 0 || strcmp(str, "MERGEFUNC") == 0) w = t_createMergeFunctionsPass; + else if (strcmp(str, "OBJCARCAPELIM") == 0) w = t_createObjCARCAPElimPass; + else if (strcmp(str, "OBJCARCCONTRACT") == 0) w = t_createObjCARCContractPass; + else if (strcmp(str, "OBJCARCEXPAND") == 0) w = t_createObjCARCExpandPass; + else if (strcmp(str, "OBJCARCOPT") == 0 || strcmp(str, "OBJCARC") == 0) w = t_createObjCARCOptPass; + else if (strcmp(str, "PARTIALINLINING") == 0 || strcmp(str, "PARTIALINLINER") == 0) w = t_createPartialInliningPass; + else if (strcmp(str, "PROMOTEMEMORYTOREGISTER") == 0 || strcmp(str, "MEM2REG") == 0) w = t_createPromoteMemoryToRegisterPass; + else if (strcmp(str, "PRUNEEH") == 0) w = t_createPruneEHPass; + else if (strcmp(str, "REASSOCIATE") == 0) w = t_createReassociatePass; + else if (strcmp(str, "SCALARREPLAGGREGATES") == 0 || strcmp(str, "SCALARREPL") == 0) w = t_createScalarReplAggregatesPass; + else if (strcmp(str, "SCCP") == 0) w = t_createSCCPPass; + else if (strcmp(str, "SIMPLIFYLIBCALLS") == 0) w = t_createSimplifyLibCallsPass; + else if (strcmp(str, "SINGLELOOPEXTRACTOR") == 0 || strcmp(str, "LOOPEXTRACTSINGLE") == 0) w = t_createSingleLoopExtractorPass; + else if (strcmp(str, "SINKING") == 0 || strcmp(str, "SINK") == 0) w = t_createSinkingPass; + else if (strcmp(str, "STRIPDEADDEBUGINFO") == 0) w = t_createStripDeadDebugInfoPass; + else if (strcmp(str, "STRIPDEADPROTOTYPES") == 0) w = t_createStripDeadPrototypesPass; + else if (strcmp(str, "STRIPDEBUGDECLARE") == 0) w = t_createStripDebugDeclarePass; + else if (strcmp(str, "STRIPNONDEBUGSYMBOLS") == 0) w = t_createStripNonDebugSymbolsPass; + else if (strcmp(str, "STRIPSYMBOLS") == 0 || strcmp(str, "STRIP") == 0) w = t_createStripSymbolsPass; + else if (strcmp(str, "TAILCALLELIMINATION") == 0 || strcmp(str, "TAILCALLELIM") == 0) w = t_createTailCallEliminationPass; + else { + // head's value is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + + // insert transform pass defined by 'head' on 'ExpEnv.analysis_struc.act_tr' + ExpEnv.transform_struc.n += 1; + ExpEnv.transform_struc.act_tr = (enumTransformPasses*)realloc(ExpEnv.transform_struc.act_tr, ExpEnv.transform_struc.n * sizeof(enumTransformPasses)); + ExpEnv.transform_struc.act_tr[ExpEnv.transform_struc.n-1] = w; + } + else { + // head's value is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Transform pass"); + return FALSE; + } + + // here, 'u' is the current head of list (just been treated) and 't' is our list itself + t = TailOfTermCell(t); // 't' is now our list without 'u' (tail of 't') + t = Deref(t); + if (IsAtomTerm(t)) break; // if 't' is an empty list (which is treated as atom by Prolog), we finish the loop + u = HeadOfTermCell(t); // else, 'u' is now next head which will be treated + u = Deref(u); + } + ExpEnv.transform_struc.optlevel = -1; // using this, optlevel won't be used + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Transform pass"); + return FALSE; + } +} + +static Int +p_enable_all_transform_passes( USES_REGS1 ) +{ + // Same as 'transform_passes(all)' + // First, disable all analysis passes + if (ExpEnv.transform_struc.act_tr) free(ExpEnv.transform_struc.act_tr); + ExpEnv.transform_struc.act_tr = NULL; + ExpEnv.transform_struc.n = 0; + // Second, insert all transform passes + int i; + for (i = 0; i < N_TRANSFORM_PASSES; i++) { + ExpEnv.transform_struc.n += 1; + ExpEnv.transform_struc.act_tr = (enumTransformPasses*) + realloc(ExpEnv.transform_struc.act_tr, ExpEnv.transform_struc.n * sizeof(enumTransformPasses)); + ExpEnv.transform_struc.act_tr[ExpEnv.transform_struc.n-1] = (enumTransformPasses)i; + } + ExpEnv.transform_struc.optlevel = -1; // using this, optlevel won't be used + return TRUE; +} + +static Int +p_disable_all_transform_passes( USES_REGS1 ) +{ + // Just empty 'ExpEnv.analysis_struc.act_tr' + if (ExpEnv.transform_struc.act_tr) free(ExpEnv.transform_struc.act_tr); + ExpEnv.transform_struc.act_tr = NULL; + ExpEnv.transform_struc.n = 0; + return TRUE; +} + +static Int +p_n_transform_passes( USES_REGS1 ) +{ + // valid value for ARG1 is just 'integer' (number of transform passes added randomly) + Term t = Deref(ARG1); + if (IsIntTerm(t)) { + // ARG1 is integer + Int n = IntOfTerm(t); + if (n < 0 || n >= N_TRANSFORM_PASSES) { + // value passed by argument is out of known range + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + // First: disables all transform passes + free(ExpEnv.transform_struc.act_tr); + ExpEnv.transform_struc.act_tr = NULL; + ExpEnv.transform_struc.n = 0; + + /* Second: adds n transform passes randomly */ + srand (time(NULL)); + while (ExpEnv.transform_struc.n < n) { + CELL v = rand() % (n); + if ( + ((enumTransformPasses)v == t_createBlockExtractorPass) || + ((enumTransformPasses)v == t_createDeadArgHackingPass) || + ((enumTransformPasses)v == t_createGVExtractionPass) || + ((enumTransformPasses)v == t_createLoopExtractorPass) || + ((enumTransformPasses)v == t_createStripDeadDebugInfoPass) || + ((enumTransformPasses)v == t_createStripDeadPrototypesPass) || + ((enumTransformPasses)v == t_createStripDebugDeclarePass) || + ((enumTransformPasses)v == t_createStripNonDebugSymbolsPass) || + ((enumTransformPasses)v == t_createStripSymbolsPass) + ) { + // I can't add these passes (they are used just for debugging) + n -= 1; + continue; + } + COUNT i = 0; + + /* I must ensure all steps are different from one another */ + while (i < ExpEnv.transform_struc.n) { + if (ExpEnv.transform_struc.act_tr[i] == (enumTransformPasses)v) break; + i++; + } + if (i == ExpEnv.transform_struc.n) { + /***/ + + // If pass is not specific for debugging and not yet added so I add it */ + ExpEnv.transform_struc.n += 1; + ExpEnv.transform_struc.act_tr = (enumTransformPasses*) + realloc(ExpEnv.transform_struc.act_tr, ExpEnv.transform_struc.n*sizeof(enumTransformPasses)); + ExpEnv.transform_struc.act_tr[ExpEnv.transform_struc.n-1] = (enumTransformPasses)v; + } + } + ExpEnv.transform_struc.optlevel = -1; // using this, optlevel won't be used + return TRUE; + } + else { + // ARG1 is not an integer + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"N transform passes"); + return FALSE; + } +} + +static Int +p_transform_level( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid value for ARG1 is just 'integer' + if (IsIntTerm(t)) { + // ARG1 is integer + Int lvl = IntOfTerm(t); + if (lvl < -1 || lvl > 3) { + // value passed by argument is out of known range (valid values are: 0, 1, 2, and 3) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + ExpEnv.transform_struc.optlevel = lvl; // if 'transform_pass' or similars are used before, they won't be considered + + /* Setting function inlining threshold (for createFunctionInliningPass) -- level 0 does not apply this */ + if (ExpEnv.transform_struc.optlevel == 3) + ExpEnv.transform_struc.opt_args.inline_threshold = 225; + else if (ExpEnv.transform_struc.optlevel == 2) + ExpEnv.transform_struc.opt_args.inline_threshold = 100; + else + ExpEnv.transform_struc.opt_args.inline_threshold = 40; + return TRUE; + } + else { + // ARG1 is not an integer + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Transform level"); + return FALSE; + } +} + +static Int +p_argument_promotion_max_elements( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid value for ARG1 is just 'integer' + if (IsIntTerm(t)) { + // ARG1 is integer + Int v = IntOfTerm(t); +#if SIZEOF_INT_P==4 + if (v < 0 || v > 0xffffffff) { // 32 bits +#else /* SIZEOF_INT_P==8 */ + if (v < 0 || v > 0x1999999999999999) { // 64 bits +#endif + // value passed by argument is out of known range (max value is machine-dependent) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + // Setting max elements for Argument Promotion Pass + ExpEnv.transform_struc.opt_args.arg_promotion_max_elements = v; + return TRUE; + } + else { + // ARG1 is not an integer + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Argument Promotion Max Elements"); + return FALSE; + } +} + +static Int +p_scalar_replace_aggregates_threshold( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid value for ARG1 is just 'integer' + if (IsIntTerm(t)) { + // ARG1 is integer + Int v = IntOfTerm(t); + if (v < -1 || v > 0xffff) { + // value passed by argument is out of known range (max value is 65535) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + // Setting threshold for Scalar Repl Aggregates Pass + ExpEnv.transform_struc.opt_args.scalar_replace_aggregates_threshold = v; + return TRUE; + } + else { + // ARG1 is not an integer + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Scalar Replace Aggregates Threshold"); + return FALSE; + } +} + +static Int +p_loop_unroll_threshold( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid value for ARG1 is just 'integer' + if (IsIntTerm(t)) { + // ARG1 is integer + Int v = IntOfTerm(t); + if (v < -1 || v > 0xffff) { + // value passed by argument is out of known range (max value is 65535) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + // Setting threshold for Loop Unroll Pass + ExpEnv.transform_struc.opt_args.loop_unroll_threshold = v; + return TRUE; + } + else { + // ARG1 is not an integer + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Loop Unroll Threshold"); + return FALSE; + } +} + +static Int +p_inline_threshold( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid value for ARG1 is just 'integer' + if (IsIntTerm(t)) { + // ARG1 is integer + Int v = IntOfTerm(t); + if (v < -1 || v > 0xffff) { + // value passed by argument is out of known range (max value is 65535) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + // Setting threshold for Function Inlining Pass + ExpEnv.transform_struc.opt_args.inline_threshold = v; + return TRUE; + } + else { + // ARG1 is not an integer + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Inline Threshold"); + return FALSE; + } +} + +static Int +p_strip_symbols_pass_type( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + // Setting Strip Symbols Pass condition. '0' is false; Any other value is true + ExpEnv.transform_struc.opt_args.strip_symbols_pass_type = IntOfTerm(t); + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting value according to 'str' + if (strcmp(str, "FALSE") == 0) ExpEnv.transform_struc.opt_args.strip_symbols_pass_type = 0; + else if (strcmp(str, "TRUE") == 0) ExpEnv.transform_struc.opt_args.strip_symbols_pass_type = 1; + else { + // value passed by argument is out of known range (only 'true' or 'false' are allowed) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Strip Symbols Pass Type"); + return FALSE; + } +} + +static Int +p_loop_unswitch_optimize_for_size( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid values for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // ARG1 is integer + // Setting Loop Unswitch Pass condition. '0' is false; Any other value is true + ExpEnv.transform_struc.opt_args.loop_unswitch_optimize_for_size = IntOfTerm(t); + return TRUE; + } + else if (IsAtomTerm(t)) { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting value according to 'str' + if (strcmp(str, "FALSE") == 0) ExpEnv.transform_struc.opt_args.loop_unswitch_optimize_for_size = 0; + else if (strcmp(str, "TRUE") == 0) ExpEnv.transform_struc.opt_args.loop_unswitch_optimize_for_size = 1; + else { + // value passed by argument is out of known range (only 'true' or 'false' are allowed) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Loop Unswitch Optimize for Size"); + return FALSE; + } +} + +static Int +p_default_optimization_args( USES_REGS1 ) +{ + /* resetting arguments used in some passes */ + ExpEnv.transform_struc.opt_args.arg_promotion_max_elements = 3; // Argument Promotion Pass + ExpEnv.transform_struc.opt_args.strip_symbols_pass_type = 0; // Strip Symbols Pass + ExpEnv.transform_struc.opt_args.scalar_replace_aggregates_threshold = -1; // Scalar Repl Aggregates Pass + ExpEnv.transform_struc.opt_args.loop_unswitch_optimize_for_size = 0; // Loop Unswitch Pass + ExpEnv.transform_struc.opt_args.loop_unroll_threshold = -1; // Loop Unroll Pass + + // Function Inlining Pass (according current 'optlevel') + if (ExpEnv.transform_struc.optlevel == 3) + ExpEnv.transform_struc.opt_args.inline_threshold = 225; + else if (ExpEnv.transform_struc.optlevel == 2) + ExpEnv.transform_struc.opt_args.inline_threshold = 100; + else if (ExpEnv.transform_struc.optlevel == 1) + ExpEnv.transform_struc.opt_args.inline_threshold = 40; + else // 0 + ExpEnv.transform_struc.opt_args.inline_threshold = 0; + /***/ + + // Link-time optimization + ExpEnv.transform_struc.link_time_opt.enabled = 0; + ExpEnv.transform_struc.link_time_opt.internalize = 0; + ExpEnv.transform_struc.link_time_opt.runinliner = 0; + return TRUE; +} + +static Int +p_reset_optimization_args( USES_REGS1 ) +{ + // Same as 'p_default_optimization_args' + p_default_optimization_args(); + return TRUE; +} + +static Int +p_enable_unit_at_time( USES_REGS1 ) +{ + // Enable IPO + ExpEnv.transform_struc.unit_at_time_enabled = 1; + return TRUE; +} + +static Int +p_enable_simplify_libcalls( USES_REGS1 ) +{ + // Enable libcalls simplification + ExpEnv.transform_struc.simplify_libcalls_enabled = 1; + return TRUE; +} + +static Int +p_disable_unit_at_time( USES_REGS1 ) +{ + // Disable IPO + ExpEnv.transform_struc.unit_at_time_enabled = 0; + return TRUE; +} + +static Int +p_disable_simplify_libcalls( USES_REGS1 ) +{ + // Disable libcalls simplification + ExpEnv.transform_struc.simplify_libcalls_enabled = 0; + return TRUE; +} + +static Int +p_link_time_opt1( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid value for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t)) { + // 'ARG1' is integer + // enabling link-time optimization ('internalize' = 1 and 'runinliner' = 0 are default) + ExpEnv.transform_struc.link_time_opt.enabled = IntOfTerm(t); + ExpEnv.transform_struc.link_time_opt.internalize = 1; + ExpEnv.transform_struc.link_time_opt.runinliner = 0; + return TRUE; + } + else if (IsAtomTerm(t)) { + // 'ARG1' is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting value according to 'str' + if (strcmp(str, "FALSE") == 0) { + // disabling link-time optimization ('internalize' and 'runinliner' does not work if 'enabled' = 0) + ExpEnv.transform_struc.link_time_opt.enabled = 0; + ExpEnv.transform_struc.link_time_opt.internalize = 0; + ExpEnv.transform_struc.link_time_opt.runinliner = 0; + } + else if (strcmp(str, "TRUE") == 0) { + // enabling link-time optimization ('internalize' = 1 and 'runinliner' = 0 are default) + ExpEnv.transform_struc.link_time_opt.enabled = 1; + ExpEnv.transform_struc.link_time_opt.internalize = 1; + ExpEnv.transform_struc.link_time_opt.runinliner = 0; + } + else { + // value passed by argument is out of known range (only 'true' or 'false' are allowed) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + return TRUE; + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Link-time optimization"); + return FALSE; + } +} + +static Int +p_link_time_opt3( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid value for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t) || IsAtomTerm(t)) { + Term u = Deref(ARG2); + // valid value for ARG2 are 'integer' and 'atom' + if (IsIntTerm(u) || IsAtomTerm(u)) { + Term v = Deref(ARG3); + // valid value for ARG3 are 'integer' and 'atom' + if (IsIntTerm(v) || IsAtomTerm(v)) { + + /* setting 1st argument (link-time optimization itself) */ + if (IsIntTerm(t)) { + // ARG1 is integer + ExpEnv.transform_struc.link_time_opt.enabled = IntOfTerm(t); + } + else /* atom */ { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting value according to 'str' + if (strcmp(str, "FALSE") == 0) ExpEnv.transform_struc.link_time_opt.enabled = 0; // disabling link-time opt + else if (strcmp(str, "TRUE") == 0) ExpEnv.transform_struc.link_time_opt.enabled = 1; // enabling link-time opt + else { + // value passed by argument is out of known range (only 'true' or 'false' are allowed) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + } + + /* setting 2nd argument (internalize) */ + if (IsIntTerm(u)) { + // ARG2 is integer + ExpEnv.transform_struc.link_time_opt.internalize = IntOfTerm(u); + } + else /* atom */ { + // ARG2 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting value according to 'str' + if (strcmp(str, "FALSE") == 0) ExpEnv.transform_struc.link_time_opt.internalize = 0; // disabling internalize + else if (strcmp(str, "TRUE") == 0) ExpEnv.transform_struc.link_time_opt.internalize = 1; // enabling internalize + else { + // value passed by argument is out of known range (only 'true' or 'false' are allowed) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + } + + /* setting 3rd argument (runinliner) */ + if (IsIntTerm(v)) { + // ARG3 is integer + ExpEnv.transform_struc.link_time_opt.runinliner = IntOfTerm(v); + return TRUE; + } + else /* atom */ { + // ARG3 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(v))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(v))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting value according to 'str' + if (strcmp(str, "FALSE") == 0) ExpEnv.transform_struc.link_time_opt.runinliner = 0; // disabling runinliner + else if (strcmp(str, "TRUE") == 0) ExpEnv.transform_struc.link_time_opt.runinliner = 1; // enabling runinliner + else { + // value passed by argument is out of known range (only 'true' or 'false' are allowed) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,v,""); + return FALSE; + } + return TRUE; + } + } + else { + // ARG3 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Link-time optimization (3rd arg)"); + return FALSE; + } + } + else { + // ARG2 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Link-time optimization (2nd arg)"); + return FALSE; + } + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Link-time optimization (1st arg)"); + return FALSE; + } +} + +static Int +p_enable_link_time_opt( USES_REGS1 ) +{ + // Same as 'link_time_opt(true)' + ExpEnv.transform_struc.link_time_opt.enabled = 1; + ExpEnv.transform_struc.link_time_opt.internalize = 1; + ExpEnv.transform_struc.link_time_opt.runinliner = 0; + return TRUE; +} + +static Int +p_enable_link_time_opt2( USES_REGS1 ) +{ + Term t = Deref(ARG1); + // valid value for ARG1 are 'integer' and 'atom' + if (IsIntTerm(t) || IsAtomTerm(t)) { + // valid value for ARG2 are 'integer' and 'atom' + Term u = Deref(ARG2); + if (IsIntTerm(u) || IsAtomTerm(u)) { + + /* setting 1st argument (internalize) */ + if (IsIntTerm(t)) { + // ARG1 is integer + ExpEnv.transform_struc.link_time_opt.internalize = IntOfTerm(t); + } + else /* atom */ { + // ARG1 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(t))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting value according to 'str' + if (strcmp(str, "FALSE") == 0) ExpEnv.transform_struc.link_time_opt.internalize = 0; // disabling internalize + else if (strcmp(str, "TRUE") == 0) ExpEnv.transform_struc.link_time_opt.internalize = 1; // enabling internalize + else { + // value passed by argument is out of known range (only 'true' or 'false' are allowed) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); + return FALSE; + } + } + + /* setting 2nd argument (runinliner) */ + if (IsIntTerm(u)) { + // ARG2 is integer + ExpEnv.transform_struc.link_time_opt.runinliner = IntOfTerm(u); + ExpEnv.transform_struc.link_time_opt.enabled = 1; + return TRUE; + } + else /* atom */ { + // ARG2 is atom + int i = 0, j = 0; + char *tmp; + // gets string from atom and stores it on 'str' + char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); + strcpy(str, AtomName(AtomOfTerm(u))); + // Makes upper characters of 'str' (for comparison) + UPPER_ENTRY(str); + + // Detecting value according to 'str' + if (strcmp(str, "FALSE") == 0) ExpEnv.transform_struc.link_time_opt.runinliner = 0; // disabling runinliner + else if (strcmp(str, "TRUE") == 0) ExpEnv.transform_struc.link_time_opt.runinliner = 1; // enabling runinliner + else { + // value passed by argument is out of known range (only 'true' or 'false' are allowed) + Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); + return FALSE; + } + ExpEnv.transform_struc.link_time_opt.enabled = 1; // enabling link-time opt + return TRUE; + } + } + else { + // ARG2 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Link-time optimization (2nd arg)"); + return FALSE; + } + } + else { + // ARG1 is not an integer or atom + Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Link-time optimization (1st arg)"); + return FALSE; + } +} + +static Int +p_disable_link_time_opt( USES_REGS1 ) +{ + ExpEnv.transform_struc.link_time_opt.enabled = 0; + ExpEnv.transform_struc.link_time_opt.internalize = 0; + ExpEnv.transform_struc.link_time_opt.runinliner = 0; + return TRUE; +} + +#pragma GCC diagnostic pop + +void +Yap_InitJitTransformPreds( void ) +{ + Yap_InitCPred("disable_transform_pass", 1, p_disable_transform_pass, SafePredFlag); + Yap_InitCPred("transform_pass", 1, p_transform_pass, SafePredFlag); + Yap_InitCPred("enable_transform_pass", 1, p_enable_transform_pass, SafePredFlag); + Yap_InitCPred("transform_passes", 1, p_transform_passes, SafePredFlag); + Yap_InitCPred("enable_all_transform_passes", 0, p_enable_all_transform_passes, SafePredFlag); + Yap_InitCPred("disable_all_transform_passes", 1, p_disable_all_transform_passes, SafePredFlag); + Yap_InitCPred("n_transform_passes", 1, p_n_transform_passes, SafePredFlag); + Yap_InitCPred("transform_level", 1, p_transform_level, SafePredFlag); + Yap_InitCPred("argument_promotion_max_elements", 1, p_argument_promotion_max_elements, SafePredFlag); + Yap_InitCPred("scalar_replace_aggregates_threshold", 1, p_scalar_replace_aggregates_threshold, SafePredFlag); + Yap_InitCPred("loop_unroll_threshold", 1, p_loop_unroll_threshold, SafePredFlag); + Yap_InitCPred("inline_threshold", 1, p_inline_threshold, SafePredFlag); + Yap_InitCPred("strip_symbols_pass_type", 1, p_strip_symbols_pass_type, SafePredFlag); + Yap_InitCPred("loop_unswitch_optimize_for_size", 1, p_loop_unswitch_optimize_for_size, SafePredFlag); + Yap_InitCPred("default_optimization_args", 0, p_default_optimization_args, SafePredFlag); + Yap_InitCPred("reset_optimization_args", 0, p_reset_optimization_args, SafePredFlag); + Yap_InitCPred("enable_unit_at_time", 0, p_enable_unit_at_time, SafePredFlag); + Yap_InitCPred("enable_simplify_libcalls", 0, p_enable_simplify_libcalls, SafePredFlag); + Yap_InitCPred("disable_unit_at_time", 0, p_disable_unit_at_time, SafePredFlag); + Yap_InitCPred("disable_simplify_libcalls", 0, p_disable_simplify_libcalls, SafePredFlag); + Yap_InitCPred("link_time_opt", 1, p_link_time_opt1, SafePredFlag); + Yap_InitCPred("link_time_opt", 3, p_link_time_opt3, SafePredFlag); + Yap_InitCPred("enable_link_time_opt", 0, p_enable_link_time_opt, SafePredFlag); + Yap_InitCPred("enable_link_time_opt", 2, p_enable_link_time_opt2, SafePredFlag); + Yap_InitCPred("disable_link_time_opt", 0, p_disable_link_time_opt, SafePredFlag); +} diff --git a/Makefile.in b/Makefile.in index 5c1a776ed..372ea37e2 100755 --- a/Makefile.in +++ b/Makefile.in @@ -103,6 +103,11 @@ TEXI2HTML=texi2html TEXI2PDF=texi2pdf YAPLIB=@YAPLIB@ SONAMEFLAG=@SONAMEFLAG@ +#--------------- +JITFLAGS=@JITFLAGS@ +JITLD=@JITLD@ +JITLIBS=@JITLIBS@ +PAPILIB=@PAPILIB@ VPATH=@srcdir@ CWD=$(PWD) @@ -211,7 +216,9 @@ HEADERS = \ OPTYap/locks_mips_funcs.h OPTYap/locks_alpha.h \ OPTYap/locks_alpha_funcs.h \ OPTYap/locks_pthread.h \ - library/dialect/swi/fli/swi.h + library/dialect/swi/fli/swi.h \ + JIT/HPP/JIT.hh JIT/HPP/JIT_Compiler.hh \ + JIT/HPP/jit_predicates.hh IOLIB_SOURCES=os/pl-buffer.c os/pl-ctype.c \ os/pl-codelist.c \ @@ -277,7 +284,6 @@ C_SOURCES= \ C/utilpreds.c C/write.c console/yap.c \ C/yap-args.c \ C/ypstdio.c \ - CXX/yapi.cpp \ BEAM/eam_am.c BEAM/eam_showcode.c \ BEAM/eamindex.c BEAM/eamamasm.c \ BEAM/eam_gc.c BEAM/eam_split.c \ @@ -293,6 +299,11 @@ C_SOURCES= \ # library/mpi/mpi.c library/mpi/mpe.c \ # library/lammpi/yap_mpi.c library/lamm1pi/hash.c library/lammpi/prologterms2c.c +CXX_SOURCES = \ + CXX/yapi.cpp \ + JIT/JIT_Compiler.cpp + + PLCONS_SOURCES = \ console/LGPL/pl-nt.c \ console/LGPL/pl-ntcon.c \ @@ -388,6 +399,15 @@ ENGINE_OBJECTS = \ yap-args.o write.o \ blobs.o swi.o ypstdio.o $(IOLIB_OBJECTS) +JIT_OBJECTS = \ + @JITCOMPILER@ \ + @JITCONFIGPREDS@ \ + @JITANALYSISPREDS@ \ + @JITTRANSFORMPREDS@ \ + @JITCODEGENPREDS@ \ + @JITDEBUGPREDS@ \ + @JITSTATISTICPREDS@ + LIBTAI_OBJECTS = \ tai_add.o tai_now.o tai_pack.o \ tai_sub.o tai_unpack.o taia_add.o taia_approx.o \ @@ -415,7 +435,7 @@ BEAM_OBJECTS = \ STATIC_OBJECTS = \ @STATIC_MODE@sys.o yap_random.o regexp.o @NO_BUILTIN_REGEXP@ regcomp.o regerror.o regfree.o regexec.o -LIB_OBJECTS = $(ENGINE_OBJECTS) $(C_INTERFACE_OBJECTS) $(OR_OBJECTS) $(BEAM_OBJECTS) $(STATIC_OBJECTS) $(LIBTAI_OBJECTS) +LIB_OBJECTS = $(ENGINE_OBJECTS) $(C_INTERFACE_OBJECTS) $(OR_OBJECTS) $(BEAM_OBJECTS) $(STATIC_OBJECTS) $(LIBTAI_OBJECTS) $(JIT_OBJECTS) OBJECTS = yap.o yapi.o $(LIB_OBJECTS) @@ -482,6 +502,12 @@ yap_random.o: library/random/yap_random.c config.h %.o: os/%.c config.h $(CC) -c $(CFLAGS) -I$(srcdir)/include -I$(srcdir) -Ios @EXTRA_INCLUDES_FOR_WIN32@ $< -o $@ +JIT_Compiler.o: IT/JIT_Compiler.cpp + $(CXX) -c $(CFLAGS) $(JITFLAGS) $< -o $@ + +%.o: $JIT/%.c + $(CC) -c $(CFLAGS) $< -o $@ + pl-ntcon.o: console/LGPL/pl-ntcon.c config.h $(CC) -c $(CFLAGS) -DPL_CONSOLE=1 -I$(srcdir)/include $< -o $@ @@ -569,8 +595,8 @@ all: startup.yss -rm -f startup.yss echo "bootstrap('$(srcdir)/pl/init.yap'). module(user). qsave_program('startup.yss')." | @PRE_INSTALL_ENV@ ./yap@EXEC_SUFFIX@ -b $(srcdir)/pl/boot.yap -yap@EXEC_SUFFIX@: $(HEADERS) yap.o @YAPLIB@ libYap.a - $(MPI_CC) $(EXECUTABLE_CFLAGS) $(LDFLAGS) -o yap@EXEC_SUFFIX@ yap.o @YAPLIB@ $(LIBS) +yap@EXEC_SUFFIX@: $(HEADERS) yap.o @YAPLIB@ libYap.a + $(MPI_CC) $(EXECUTABLE_CFLAGS) $(LDFLAGS) -o yap@EXEC_SUFFIX@ yap.o @YAPLIB@ $(PAPILIB) $(JITLIBS) $(JITLD) yap-win: yap-win@EXEC_SUFFIX@ diff --git a/configure b/configure index 3ad986ffb..fa3caaa6e 100755 --- a/configure +++ b/configure @@ -701,6 +701,19 @@ RFC822_CFLAGS RFC2045_CFLAGS RFC2045CHARSET rfc822includedir +CLANG +LLVM +PAPILIB +JITCODEGENPREDS +JITTRANSFORMPREDS +JITANALYSISPREDS +JITCONFIGPREDS +JITCOMPILER +JITSTATISTICPREDS +JITDEBUGPREDS +JITLIBS +JITLD +JITFLAGS MYDDAS_LIBS PKG_MYDDAS EXTRA_LIBS_FOR_SWIDLLS @@ -883,6 +896,9 @@ with_max_threads enable_myddas enable_myddas_stats enable_myddas_top_level +enable_jit +enable_debug_predicates +enable_statistic_predicates with_rfc2045_package with_rfc2045_version enable_mimecharset @@ -1553,6 +1569,9 @@ Optional Features: --enable-myddas[=DIR] enable the MYDDAS library --enable-myddas-stats enable the MYDDAS library statistics support --enable-myddas-top-level enable the MYDDAS top-level support to MySQL + --enable-jit support just-in-time (JIT) compilation + --enable-debug-predicates support debug predicates + --enable-statistic-predicates support statistic predicates --enable-mimecharset=charset Default MIME charset to set on new messages --enable-bddlib dynamic bdd library --enable-cplint=DIR enable the cplint library using the CUDD library in DIR/lib @@ -10386,6 +10405,244 @@ fi + + + + + + + + + + + + + +# Check whether --enable-jit was given. +if test "${enable_jit+set}" = set; then : + enableval=$enable_jit; yap_jit="$enableval" +else + yap_jit=no +fi + + +# Check whether --enable-debug-predicates was given. +if test "${enable_debug_predicates+set}" = set; then : + enableval=$enable_debug_predicates; dbg_preds="$enableval" +else + dbg_preds=no +fi + + +# Check whether --enable-statistic-predicates was given. +if test "${enable_statistic_predicates+set}" = set; then : + enableval=$enable_statistic_predicates; stat_preds="$enableval" +else + stat_preds=no +fi + + +if test "$yap_jit" = "yes" +then + + # Extract the first word of "llvm-config", so it can be a program name with args. +set dummy llvm-config; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_LLVM+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$LLVM"; then + ac_cv_prog_LLVM="$LLVM" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_LLVM="yes" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + test -z "$ac_cv_prog_LLVM" && ac_cv_prog_LLVM="no" +fi +fi +LLVM=$ac_cv_prog_LLVM +if test -n "$LLVM"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LLVM" >&5 +$as_echo "$LLVM" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + if test "$LLVM" = "no" ;then + as_fn_error $? "--enable-jit was given, but test for LLVM 3.1 failed" "$LINENO" 5 + + else + LLVM_VERSION="`llvm-config --version`" + if test "$LLVM_VERSION" != "3.1";then + as_fn_error $? "Test for LLVM 3.1 failed" "$LINENO" 5 + fi + + fi + + # Extract the first word of "clang", so it can be a program name with args. +set dummy clang; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CLANG+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CLANG"; then + ac_cv_prog_CLANG="$CLANG" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CLANG="yes" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + test -z "$ac_cv_prog_CLANG" && ac_cv_prog_CLANG="no" +fi +fi +CLANG=$ac_cv_prog_CLANG +if test -n "$CLANG"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLANG" >&5 +$as_echo "$CLANG" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + if test "$CLANG" = "no" ;then + as_fn_error $? "--enable-jit was given, but test for clang faild" "$LINENO" 5 + fi + + YAP_EXTRAS="$YAP_EXTRAS -DYAP_JIT=1" + JITCOMPILER="JIT_Compiler.o" + JITCONFIGPREDS="jit_configpreds.o" + JITANALYSISPREDS="jit_analysispreds.o" + JITTRANSFORMPREDS="jit_transformpreds.o" + JITCODEGENPREDS="jit_codegenpreds.o" + JITFLAGS="`llvm-config --cxxflags`" + JITLD="`llvm-config --ldflags`" + JITLIBS="`llvm-config --libs all`" + +fi + +if test "$dbg_preds" = "yes" + then + + if test "$yap_jit" = "no" + then + + as_fn_error $? "--enable-debug-predicates was given, but --enable-jit was not given" "$LINENO" 5 + + fi + + YAP_EXTRAS="$YAP_EXTRAS -DYAP_DBG_PREDS=1" + JITDEBUGPREDS="jit_debugpreds.o" +fi + +if test "$stat_preds" = "yes" + then + + if test "$yap_jit" = "no" + then + + as_fn_error $? "--enable-statistic-predicates was given, but --enable-jit was not given" "$LINENO" 5 + + fi + + ac_fn_c_check_header_mongrel "$LINENO" "papi.h" "ac_cv_header_papi_h" "$ac_includes_default" +if test "x$ac_cv_header_papi_h" = xyes; then : + +else + if test "$stat_preds" != "no"; then + as_fn_error $? "--enable-statistic-predicates was given, but papi.h not found" "$LINENO" 5 + fi + +fi + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PAPI_start in -lpapi" >&5 +$as_echo_n "checking for PAPI_start in -lpapi... " >&6; } +if ${ac_cv_lib_papi_PAPI_start+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lpapi $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char PAPI_start (); +int +main () +{ +return PAPI_start (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_papi_PAPI_start=yes +else + ac_cv_lib_papi_PAPI_start=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_papi_PAPI_start" >&5 +$as_echo "$ac_cv_lib_papi_PAPI_start" >&6; } +if test "x$ac_cv_lib_papi_PAPI_start" = xyes; then : + if test "$stat_preds" != "no"; then + PAPILIB="-lpapi" + fi + +else + if test "$stat_preds" != "no"; then + as_fn_error $? "--enable-statistic-predicates was given, but test for papi failed" "$LINENO" 5 + fi + +fi + + + YAP_EXTRAS="$YAP_EXTRAS -DYAP_STAT_PREDS=1" + JITSTATISTICPREDS="jit_statisticpreds.o" + PAPILIB="-lpapi" + +fi + + + if test "$PKG_CLIB" != "" then @@ -13338,7 +13595,7 @@ else JAVA_TEST=Test.java CLASS_TEST=Test.class cat << \EOF > $JAVA_TEST -/* #line 13341 "configure" */ +/* #line 13598 "configure" */ public class Test { } EOF @@ -13514,7 +13771,7 @@ EOF if uudecode$EXEEXT Test.uue; then ac_cv_prog_uudecode_base64=yes else - echo "configure: 13517: uudecode had trouble decoding base 64 file 'Test.uue'" >&5 + echo "configure: 13774: uudecode had trouble decoding base 64 file 'Test.uue'" >&5 echo "configure: failed file was:" >&5 cat Test.uue >&5 ac_cv_prog_uudecode_base64=no @@ -13645,7 +13902,7 @@ else JAVA_TEST=Test.java CLASS_TEST=Test.class cat << \EOF > $JAVA_TEST -/* #line 13648 "configure" */ +/* #line 13905 "configure" */ public class Test { } EOF @@ -13680,7 +13937,7 @@ JAVA_TEST=Test.java CLASS_TEST=Test.class TEST=Test cat << \EOF > $JAVA_TEST -/* [#]line 13683 "configure" */ +/* [#]line 13940 "configure" */ public class Test { public static void main (String args[]) { System.exit (0); @@ -14348,8 +14605,7 @@ fi if test -e "$srcdir"/packages/raptor/Makefile.in then - PKG_RAPTOR="packages/raptor" - + PKG_RAPTOR="packages/raptor"