yap-6.3/OPTYap/tab.tries.insts.i

/**********************************************************************
                                                               
                       The OPTYap Prolog system                
  OPTYap extends the Yap Prolog system to support or-parallel tabling
                                                               
  Copyright:   R. Rocha and NCC - University of Porto, Portugal
  File:        tab.tries.insts.i
  version:     $Id: tab.tries.insts.i,v 1.12 2007-04-26 14:11:08 ricroc Exp $   
                                                                     
**********************************************************************/

/* --------------------------------------------------------- **
**      Trie instructions: auxiliary stack organization      **
** --------------------------------------------------------- **
                 STANDARD_TRIE
              -------------------
              | ha = heap_arity | 
              -------------------  --
              |   heap ptr 1    |    |
              -------------------    |
              |       ...       |    -- heap_arity
              -------------------    |
              |   heap ptr ha   |    |
              -------------------  --
              | va = vars_arity |
              -------------------
              | sa = subs_arity |
              -------------------  --
              |   subs ptr sa   |    |
              -------------------    |
              |       ...       |    -- subs_arity 
              -------------------    |
              |   subs ptr 1    |    |
              -------------------  --
              |    var ptr va   |    |
              -------------------    |
              |       ...       |    -- vars_arity
              -------------------    |
              |    var ptr 1    |    |
              -------------------  -- 


                  GLOBAL_TRIE
              -------------------
              | va = vars_arity |
              -------------------  --
              |    var ptr va   |    |
              -------------------    |
              |       ...       |    -- vars_arity
              -------------------    |
              |    var ptr 1    |    |
              -------------------  -- 
              | sa = subs_arity |
              -------------------  --
              |   subs ptr sa   |    |
              -------------------    |
              |       ...       |    -- subs_arity 
              -------------------    |
              |   subs ptr 1    |    |
              -------------------  --
** --------------------------------------------------------- */



/* --------------------------------------------- **
**      Trie instructions: auxiliary macros      **
** --------------------------------------------- */

#ifdef GLOBAL_TRIE
#define copy_arity_stack()                                      \
        { int size = subs_arity + vars_arity + 2;               \
          YENV -= size;                                         \
          memcpy(YENV, aux_stack_ptr, size * sizeof(CELL *));   \
          aux_stack_ptr = YENV;                                 \
	}
#else
#define copy_arity_stack()                                      \
        { int size = heap_arity + subs_arity + vars_arity + 3;  \
          YENV -= size;                                         \
          memcpy(YENV, aux_stack_ptr, size * sizeof(CELL *));   \
          aux_stack_ptr = YENV;                                 \
	}
#endif /* GLOBAL_TRIE */

#define next_trie_instruction(NODE)                             \
        PREG = (yamop *) TrNode_child(NODE);                    \
        PREFETCH_OP(PREG);                                      \
        GONext()

#define next_instruction(CONDITION, NODE)                       \
        if (CONDITION) {                                        \
          PREG = (yamop *) TrNode_child(NODE);                  \
        } else {                                                \
          /* procceed */                                        \
	  PREG = (yamop *) CPREG;                               \
	  YENV = ENV;                                           \
        }                                                       \
        PREFETCH_OP(PREG);                                      \
        GONext()



/* ---------------------------------------------------------------------------- **
** the 'store_trie_node', 'restore_trie_node' and 'pop_trie_node' macros do not **
** include the 'set_cut' macro because there are no cuts in trie instructions.  **
** ---------------------------------------------------------------------------- */

#define store_trie_node(AP)                           \
        { register choiceptr cp;                      \
          YENV = (CELL *) (NORM_CP(YENV) - 1);        \
          cp = NORM_CP(YENV);                         \
          HBREG = H;                                  \
          store_yaam_reg_cpdepth(cp);                 \
          cp->cp_tr = TR;                             \
          cp->cp_h  = H;                              \
          cp->cp_b  = B;                              \
          cp->cp_cp = CPREG;                          \
          cp->cp_ap = (yamop *) AP;                   \
          cp->cp_env= ENV;                            \
          B = cp;                                     \
          YAPOR_SET_LOAD(B);                          \
          SET_BB(B);                                  \
          TABLING_ERRORS_check_stack;                 \
	}                                             \
        copy_arity_stack()

#define restore_trie_node(AP)                         \
        H = HBREG = PROTECT_FROZEN_H(B);              \
        restore_yaam_reg_cpdepth(B);                  \
        CPREG = B->cp_cp;                             \
        ENV = B->cp_env;                              \
        YAPOR_update_alternative(PREG, (yamop *) AP)  \
        B->cp_ap = (yamop *) AP;                      \
        YENV = (CELL *) PROTECT_FROZEN_B(B);          \
        SET_BB(NORM_CP(YENV));                        \
        copy_arity_stack()

#define really_pop_trie_node()                        \
        YENV = (CELL *) PROTECT_FROZEN_B((B + 1));    \
        H = PROTECT_FROZEN_H(B);                      \
        pop_yaam_reg_cpdepth(B);                      \
	CPREG = B->cp_cp;                             \
        TABLING_close_alt(B);                         \
        ENV = B->cp_env;                              \
	B = B->cp_b;                                  \
        HBREG = PROTECT_FROZEN_H(B);                  \
        SET_BB(PROTECT_FROZEN_B(B));                  \
        if ((choiceptr) YENV == B_FZ) {               \
          copy_arity_stack();                         \
        }

#ifdef YAPOR
#define pop_trie_node()                               \
        if (SCH_top_shared_cp(B)) {                   \
          restore_trie_node(NULL);                    \
        } else {                                      \
          really_pop_trie_node();                     \
        }
#else
#define pop_trie_node()  really_pop_trie_node()
#endif /* YAPOR */



/* ------------------- **
**      trie_null      **
** ------------------- */

#define stack_trie_null_instr()                              \
        next_trie_instruction(node)

#ifdef TRIE_COMPACT_PAIRS
/* trie compiled code for term 'CompactPairInit' */
#define stack_trie_null_in_new_pair_instr()                  \
        if (heap_arity) {                                    \
          aux_stack_ptr++;                                   \
          Bind_Global((CELL *) *aux_stack_ptr, AbsPair(H));  \
          *aux_stack_ptr-- = (CELL) (H + 1);                 \
          *aux_stack_ptr-- = (CELL) H;                       \
          *aux_stack_ptr = heap_arity - 1 + 2;               \
          YENV = aux_stack_ptr;                              \
        } else {                                             \
          int i;                                             \
          *aux_stack_ptr-- = (CELL) (H + 1);                 \
          *aux_stack_ptr-- = (CELL) H;                       \
          *aux_stack_ptr = 2;                                \
          YENV = aux_stack_ptr;                              \
          aux_stack_ptr += 2 + 2;                            \
          *aux_stack_ptr = subs_arity - 1;                   \
          aux_stack_ptr += subs_arity;                       \
          Bind((CELL *) *aux_stack_ptr, AbsPair(H));         \
          for (i = 0; i < vars_arity; i++) {                 \
            *aux_stack_ptr = *(aux_stack_ptr + 1);           \
            aux_stack_ptr++;                                 \
          }                                                  \
        }                                                    \
        H += 2;                                              \
        next_trie_instruction(node)
#endif /* TRIE_COMPACT_PAIRS */



/* ------------------ **
**      trie_var      **
** ------------------ */

#define stack_trie_var_instr()                                   \
        if (heap_arity) {                                        \
          CELL var;                                              \
          int i;                                                 \
          *aux_stack_ptr = heap_arity - 1;                       \
          var = *++aux_stack_ptr;                                \
          RESET_VARIABLE(var);                                   \
          for (i = 0; i < heap_arity - 1; i++) {                 \
            *aux_stack_ptr = *(aux_stack_ptr + 1);               \
            aux_stack_ptr++;                                     \
          }                                                      \
          *aux_stack_ptr++ = vars_arity + 1;                     \
          *aux_stack_ptr++ = subs_arity;                         \
          for (i = 0; i < subs_arity; i++) {                     \
            *aux_stack_ptr = *(aux_stack_ptr + 1);               \
            aux_stack_ptr++;                                     \
          }                                                      \
          *aux_stack_ptr = var;                                  \
          next_instruction(heap_arity - 1 || subs_arity, node);  \
        } else {                                                 \
          *++aux_stack_ptr = vars_arity + 1;                     \
          *++aux_stack_ptr = subs_arity - 1;                     \
          next_instruction(subs_arity - 1, node);                \
        }

#ifdef TRIE_COMPACT_PAIRS
#define stack_trie_var_in_new_pair_instr()                       \
        if (heap_arity) {                                        \
          int i;                                                 \
          *aux_stack_ptr-- = (CELL) (H + 1);                     \
          *aux_stack_ptr = heap_arity - 1 + 1;                   \
          YENV = aux_stack_ptr;                                  \
          aux_stack_ptr += 2;                                    \
          Bind_Global((CELL *) *aux_stack_ptr, AbsPair(H));      \
          for (i = 0; i < heap_arity - 1; i++) {                 \
            *aux_stack_ptr = *(aux_stack_ptr + 1);               \
            aux_stack_ptr++;                                     \
          }                                                      \
          *aux_stack_ptr++ = vars_arity + 1;                     \
          *aux_stack_ptr++ = subs_arity;                         \
          for (i = 0; i < subs_arity; i++) {                     \
            *aux_stack_ptr = *(aux_stack_ptr + 1);               \
            aux_stack_ptr++;                                     \
          }                                                      \
          *aux_stack_ptr = (CELL) H;                             \
        } else {                                                 \
          *aux_stack_ptr-- = (CELL) (H + 1);                     \
          *aux_stack_ptr = 1;                                    \
          YENV = aux_stack_ptr;                                  \
          aux_stack_ptr += 2;                                    \
          *aux_stack_ptr++ = vars_arity + 1;                     \
          *aux_stack_ptr = subs_arity - 1;                       \
          aux_stack_ptr += subs_arity;                           \
          Bind((CELL *) *aux_stack_ptr, AbsPair(H));             \
          *aux_stack_ptr = (CELL) H;                             \
        }                                                        \
        RESET_VARIABLE((CELL) H);                                \
        H += 2;                                                  \
        next_trie_instruction(node)
#endif /* TRIE_COMPACT_PAIRS */



/* ------------------ **
**      trie_val      **
** ------------------ */

#define stack_trie_val_instr()                                                              \
        if (heap_arity) {                                                                   \
          CELL aux_sub, aux_var, *vars_ptr;				                    \
          YENV = ++aux_stack_ptr;                                                           \
          vars_ptr = aux_stack_ptr + heap_arity + 1 + subs_arity + vars_arity - var_index;  \
          aux_sub = *aux_stack_ptr;                                                         \
          aux_var = *vars_ptr;                                                              \
          if (aux_sub > aux_var) {                                                          \
            Bind_Global((CELL *) aux_sub, aux_var);                                         \
          } else {                                                                          \
            RESET_VARIABLE(aux_sub);                                                        \
	    Bind_Local((CELL *) aux_var, aux_sub);                                          \
            *vars_ptr = aux_sub;                                                            \
          }                                                                                 \
          *aux_stack_ptr = heap_arity - 1;                                                  \
          next_instruction(heap_arity - 1 || subs_arity, node);                             \
        } else {                                                                            \
          CELL aux_sub, aux_var, *vars_ptr;                                                 \
          int i;                                                                            \
          aux_stack_ptr += 2;                                                               \
          *aux_stack_ptr = subs_arity - 1;                                                  \
          aux_stack_ptr += subs_arity;                                                      \
          vars_ptr = aux_stack_ptr + vars_arity - var_index;                                \
          aux_sub = *aux_stack_ptr;                                                         \
          aux_var = *vars_ptr;                                                              \
          if (aux_sub > aux_var) {                                                          \
	    if ((CELL *) aux_sub <= H) {                                                    \
              Bind_Global((CELL *) aux_sub, aux_var);                                       \
            } else if ((CELL *) aux_var <= H) {                                             \
              Bind_Local((CELL *) aux_sub, aux_var);                                        \
            } else {                                                                        \
              Bind_Local((CELL *) aux_var, aux_sub);                                        \
              *vars_ptr = aux_sub;                                                          \
            }                                                                               \
          } else {                                                                          \
	    if ((CELL *) aux_var <= H) {                                                    \
              Bind_Global((CELL *) aux_var, aux_sub);                                       \
              *vars_ptr = aux_sub;                                                          \
            } else if ((CELL *) aux_sub <= H) {                                             \
              Bind_Local((CELL *) aux_var, aux_sub);                                        \
              *vars_ptr = aux_sub;                                                          \
            } else {                                                                        \
              Bind_Local((CELL *) aux_sub, aux_var);                                        \
            }                                                                               \
          }                                                                                 \
          for (i = 0; i < vars_arity; i++) {                                                \
            *aux_stack_ptr = *(aux_stack_ptr + 1);                                          \
            aux_stack_ptr++;                                                                \
          }                                                                                 \
          next_instruction(subs_arity - 1, node);                                           \
        }

#ifdef TRIE_COMPACT_PAIRS      
#define stack_trie_val_in_new_pair_instr()                                                  \
        if (heap_arity) {                                                                   \
          CELL aux_sub, aux_var, *vars_ptr;	      	               		            \
          aux_stack_ptr++;				                                    \
          Bind_Global((CELL *) *aux_stack_ptr, AbsPair(H));                                 \
          *aux_stack_ptr = (CELL) (H + 1);                                                  \
          aux_sub = (CELL) H;                                                               \
          vars_ptr = aux_stack_ptr + heap_arity + 1 + subs_arity + vars_arity - var_index;  \
          aux_var = *vars_ptr;                                                              \
          if (aux_sub > aux_var) {                                                          \
            Bind_Global((CELL *) aux_sub, aux_var);                                         \
          } else {                                                                          \
            RESET_VARIABLE(aux_sub);                                                        \
  	    Bind_Local((CELL *) aux_var, aux_sub);                                          \
            *vars_ptr = aux_sub;                                                            \
          }                                                                                 \
        } else {                                                                            \
          CELL aux_sub, aux_var, *vars_ptr;                                                 \
          int i;                                                                            \
          *aux_stack_ptr-- = (CELL) (H + 1);                                                \
          *aux_stack_ptr = 1;                                                               \
          YENV = aux_stack_ptr;                                                             \
          aux_stack_ptr += 1 + 2;                                                           \
          aux_sub = (CELL) H;                                                               \
          vars_ptr = aux_stack_ptr + subs_arity + vars_arity - var_index;                   \
          aux_var = *vars_ptr;                                                              \
          if (aux_sub > aux_var) {                                                          \
            Bind_Global((CELL *) aux_sub, aux_var);                                         \
          } else {                                                                          \
            RESET_VARIABLE(aux_sub);                                                        \
	    Bind_Local((CELL *) aux_var, aux_sub);                                          \
            *vars_ptr = aux_sub;                                                            \
          }                                                                                 \
          *aux_stack_ptr = subs_arity - 1;                                                  \
          aux_stack_ptr += subs_arity;                                                      \
          Bind((CELL *) *aux_stack_ptr, AbsPair(H));                                        \
          for (i = 0; i < vars_arity; i++) {                                                \
            *aux_stack_ptr = *(aux_stack_ptr + 1);                                          \
            aux_stack_ptr++;                                                                \
          }                                                                                 \
        }                                                                                   \
        H += 2;                                                                             \
        next_trie_instruction(node)
#endif /* TRIE_COMPACT_PAIRS */



/* ------------------- **
**      trie_atom      **
** ------------------- */

#define stack_trie_atom_instr()                                      \
        if (heap_arity) {                                            \
          YENV = ++aux_stack_ptr;                                    \
          Bind_Global((CELL *) *aux_stack_ptr, TrNode_entry(node));  \
          *aux_stack_ptr = heap_arity - 1;                           \
          next_instruction(heap_arity - 1 || subs_arity, node);      \
        } else {                                                     \
          int i;                                                     \
          aux_stack_ptr += 2;                                        \
          *aux_stack_ptr = subs_arity - 1;                           \
          aux_stack_ptr += subs_arity;                               \
          Bind((CELL *) *aux_stack_ptr, TrNode_entry(node));         \
          for (i = 0; i < vars_arity; i++) {                         \
            *aux_stack_ptr = *(aux_stack_ptr + 1);                   \
            aux_stack_ptr++;                                         \
          }                                                          \
          next_instruction(subs_arity - 1, node);                    \
        }

#ifdef TRIE_COMPACT_PAIRS
#define stack_trie_atom_in_new_pair_instr()                          \
        if (heap_arity) {                                            \
          aux_stack_ptr++;		                             \
          Bind_Global((CELL *) *aux_stack_ptr, AbsPair(H));          \
          *aux_stack_ptr = (CELL) (H + 1);                           \
        } else {                                                     \
          int i;                                                     \
          *aux_stack_ptr-- = (CELL) (H + 1);                         \
          *aux_stack_ptr = 1;                                        \
          YENV = aux_stack_ptr;                                      \
          aux_stack_ptr += 1 + 2;                                    \
          *aux_stack_ptr = subs_arity - 1;                           \
          aux_stack_ptr += subs_arity;                               \
          Bind((CELL *) *aux_stack_ptr, AbsPair(H));                 \
          for (i = 0; i < vars_arity; i++) {                         \
            *aux_stack_ptr = *(aux_stack_ptr + 1);                   \
            aux_stack_ptr++;                                         \
          }                                                          \
        }                                                            \
        Bind_Global(H, TrNode_entry(node));                          \
        H += 2;                                                      \
        next_trie_instruction(node)
#endif /* TRIE_COMPACT_PAIRS */



/* ------------------- **
**      trie_pair      **
** ------------------- */

#ifdef TRIE_COMPACT_PAIRS
/* trie compiled code for term 'CompactPairEndList' */
#define stack_trie_pair_instr()		                     \
        if (heap_arity) {                                    \
          aux_stack_ptr++;                                   \
          Bind_Global((CELL *) *aux_stack_ptr, AbsPair(H));  \
          *aux_stack_ptr = (CELL) H;                         \
	} else {                                             \
          int i;                                             \
          *aux_stack_ptr-- = (CELL) H;                       \
          *aux_stack_ptr = 1;                                \
          YENV = aux_stack_ptr;                              \
          aux_stack_ptr += 1 + 2;                            \
          *aux_stack_ptr = subs_arity - 1;                   \
          aux_stack_ptr += subs_arity;                       \
          Bind((CELL *) *aux_stack_ptr, AbsPair(H));         \
          for (i = 0; i < vars_arity; i++) {                 \
            *aux_stack_ptr = *(aux_stack_ptr + 1);           \
            aux_stack_ptr++;                                 \
          }                                                  \
	}                                                    \
        Bind_Global(H + 1, TermNil);                         \
        H += 2;                                              \
        next_trie_instruction(node)
#else
#define stack_trie_pair_instr()                              \
        if (heap_arity) {                                    \
          aux_stack_ptr++;                                   \
          Bind_Global((CELL *) *aux_stack_ptr, AbsPair(H));  \
          *aux_stack_ptr-- = (CELL) (H + 1);                 \
          *aux_stack_ptr-- = (CELL) H;                       \
          *aux_stack_ptr = heap_arity - 1 + 2;               \
          YENV = aux_stack_ptr;                              \
        } else {                                             \
          int i;                                             \
          *aux_stack_ptr-- = (CELL) (H + 1);                 \
          *aux_stack_ptr-- = (CELL) H;                       \
          *aux_stack_ptr = 2;                                \
          YENV = aux_stack_ptr;                              \
          aux_stack_ptr += 2 + 2;                            \
          *aux_stack_ptr = subs_arity - 1;                   \
          aux_stack_ptr += subs_arity;                       \
          Bind((CELL *) *aux_stack_ptr, AbsPair(H));         \
          for (i = 0; i < vars_arity; i++) {                 \
            *aux_stack_ptr = *(aux_stack_ptr + 1);           \
            aux_stack_ptr++;                                 \
          }                                                  \
        }                                                    \
        H += 2;                                              \
        next_trie_instruction(node)
#endif /* TRIE_COMPACT_PAIRS */



/* --------------------- **
**      trie_struct      **
** --------------------- */

#define stack_trie_struct_instr()                                \
        if (heap_arity) {                                        \
          int i;                                                 \
          aux_stack_ptr++;                                       \
          Bind_Global((CELL *) *aux_stack_ptr, AbsAppl(H));      \
          for (i = 0; i < func_arity; i++)                       \
            *aux_stack_ptr-- = (CELL) (H + func_arity - i);      \
          *aux_stack_ptr = heap_arity - 1 + func_arity;          \
          YENV = aux_stack_ptr;                                  \
        } else {                                                 \
          int i;                                                 \
          for (i = 0; i < func_arity; i++)                       \
            *aux_stack_ptr-- = (CELL) (H + func_arity - i);      \
          *aux_stack_ptr = func_arity;                           \
          YENV = aux_stack_ptr;                                  \
          aux_stack_ptr += func_arity + 2;                       \
          *aux_stack_ptr = subs_arity - 1;                       \
          aux_stack_ptr += subs_arity;                           \
          Bind((CELL *) *aux_stack_ptr, AbsAppl(H));             \
          for (i = 0; i < vars_arity; i++) {                     \
            *aux_stack_ptr = *(aux_stack_ptr + 1);               \
            aux_stack_ptr++;                                     \
          }                                                      \
        }                                                        \
        *H = (CELL) func;                                        \
        H += 1 + func_arity;                                     \
        next_trie_instruction(node)

#ifdef TRIE_COMPACT_PAIRS
#define stack_trie_struct_in_new_pair_instr()	                 \
        if (heap_arity) {                                        \
          int i;                                                 \
          aux_stack_ptr++;		                         \
          Bind_Global((CELL *) *aux_stack_ptr, AbsPair(H));      \
          *aux_stack_ptr-- = (CELL) (H + 1);                     \
          for (i = 0; i < func_arity; i++)                       \
            *aux_stack_ptr-- = (CELL) (H + 2 + func_arity - i);  \
          *aux_stack_ptr = heap_arity - 1 + 1 + func_arity;      \
          YENV = aux_stack_ptr;                                  \
        } else {                                                 \
          int i;                                                 \
          *aux_stack_ptr-- = (CELL) (H + 1);                     \
          for (i = 0; i < func_arity; i++)                       \
            *aux_stack_ptr-- = (CELL) (H + 2 + func_arity - i);  \
          *aux_stack_ptr = 1 + func_arity;                       \
          YENV = aux_stack_ptr;                                  \
          aux_stack_ptr += 1 + func_arity + 2;                   \
          *aux_stack_ptr = subs_arity - 1;                       \
          aux_stack_ptr += subs_arity;                           \
          Bind((CELL *) *aux_stack_ptr, AbsPair(H));             \
          for (i = 0; i < vars_arity; i++) {                     \
            *aux_stack_ptr = *(aux_stack_ptr + 1);               \
            aux_stack_ptr++;                                     \
          }                                                      \
        }                                                        \
        Bind_Global(H, AbsAppl(H + 2));                          \
        H += 2;                                                  \
        *H = (CELL) func;                                        \
        H += 1 + func_arity;                                     \
        next_trie_instruction(node)
#endif /* TRIE_COMPACT_PAIRS */



/* ------------------------ **
**      trie_extension      **
** ------------------------ */

#define stack_trie_extension_instr()                               \
        *aux_stack_ptr-- = 0;  /* float/longint extension mark */  \
        *aux_stack_ptr-- = TrNode_entry(node);                     \
        *aux_stack_ptr = heap_arity + 2;                           \
        YENV = aux_stack_ptr;                                      \
        next_trie_instruction(node)



/* ---------------------------- **
**      trie_float_longint      **
** ---------------------------- */

#define stack_trie_float_longint_instr()                         \
        if (heap_arity) {                                        \
          YENV = ++aux_stack_ptr;                                \
          Bind_Global((CELL *) *aux_stack_ptr, t);               \
          *aux_stack_ptr = heap_arity - 1;                       \
          next_instruction(heap_arity - 1 || subs_arity, node);  \
        } else {                                                 \
          int i;                                                 \
          YENV = aux_stack_ptr;                                  \
          *aux_stack_ptr = 0;                                    \
          aux_stack_ptr += 2;                                    \
          *aux_stack_ptr = subs_arity - 1;                       \
          aux_stack_ptr += subs_arity;                           \
          Bind((CELL *) *aux_stack_ptr, t);                      \
          for (i = 0; i < vars_arity; i++) {                     \
            *aux_stack_ptr = *(aux_stack_ptr + 1);               \
            aux_stack_ptr++;                                     \
          }                                                      \
	  next_instruction(subs_arity - 1, node);                \
        }



/* --------------------------- **
**      Trie instructions      **
** --------------------------- */

  PBOp(trie_do_null, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;

    stack_trie_null_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_null)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_null, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    pop_trie_node();
    stack_trie_null_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_null)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_null, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    store_trie_node(TrNode_next(node));
    stack_trie_null_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_null)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_null, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    restore_trie_node(TrNode_next(node));
    stack_trie_null_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_null)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_null_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    stack_trie_null_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_null_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_null_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    pop_trie_node();
    stack_trie_null_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_null_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_null_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    store_trie_node(TrNode_next(node));
    stack_trie_null_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_null_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_null_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    restore_trie_node(TrNode_next(node));
    stack_trie_null_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_null_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_var, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    stack_trie_var_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_var)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_var, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    pop_trie_node();
    stack_trie_var_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_var)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_var, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    store_trie_node(TrNode_next(node));
    stack_trie_var_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_var)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_var, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    restore_trie_node(TrNode_next(node));
    stack_trie_var_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_var)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_var_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    stack_trie_var_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_var_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_var_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    pop_trie_node();
    stack_trie_var_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_var_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_var_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    store_trie_node(TrNode_next(node));
    stack_trie_var_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_var_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_var_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    restore_trie_node(TrNode_next(node));
    stack_trie_var_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_var_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_val, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    int var_index = VarIndexOfTableTerm(TrNode_entry(node));

    stack_trie_val_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_val)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_val, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    int var_index = VarIndexOfTableTerm(TrNode_entry(node));

    pop_trie_node();
    stack_trie_val_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_val)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_val, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    int var_index = VarIndexOfTableTerm(TrNode_entry(node));

    store_trie_node(TrNode_next(node));
    stack_trie_val_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_val)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_val, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    int var_index = VarIndexOfTableTerm(TrNode_entry(node));

    restore_trie_node(TrNode_next(node));
    stack_trie_val_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_val)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_val_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    int var_index = VarIndexOfTableTerm(TrNode_entry(node));

    stack_trie_val_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_val_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_val_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    int var_index = VarIndexOfTableTerm(TrNode_entry(node));

    pop_trie_node();
    stack_trie_val_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_val_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_val_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    int var_index = VarIndexOfTableTerm(TrNode_entry(node));

    store_trie_node(TrNode_next(node));
    stack_trie_val_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_val_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_val_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    int var_index = VarIndexOfTableTerm(TrNode_entry(node));

    restore_trie_node(TrNode_next(node));
    stack_trie_val_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_val_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_atom, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
#ifdef GLOBAL_TRIE
    int subs_arity = *(aux_stack_ptr + *aux_stack_ptr + 1);
    YENV = aux_stack_ptr = load_substitution_variable(TrNode_entry(node), aux_stack_ptr);
    next_instruction(subs_arity - 1 , node);
#else
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    stack_trie_atom_instr();
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_atom, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
#ifdef GLOBAL_TRIE
    int vars_arity = *(aux_stack_ptr);
    int subs_arity = *(aux_stack_ptr + vars_arity + 1);
#else
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
#endif /* GLOBAL_TRIE */
    pop_trie_node();
#ifdef GLOBAL_TRIE
    YENV = aux_stack_ptr = load_substitution_variable(TrNode_entry(node), aux_stack_ptr);
    next_instruction(subs_arity - 1 , node);
#else
    stack_trie_atom_instr();
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_atom, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
#ifdef GLOBAL_TRIE
    int vars_arity = *(aux_stack_ptr);
    int subs_arity = *(aux_stack_ptr + vars_arity + 1);
#else
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
#endif /* GLOBAL_TRIE */
    store_trie_node(TrNode_next(node));
#ifdef GLOBAL_TRIE
    YENV = aux_stack_ptr = load_substitution_variable(TrNode_entry(node), aux_stack_ptr);
    next_instruction(subs_arity - 1, node); 
#else
    stack_trie_atom_instr();
#endif /* GLOBAL_TRIE */    
  ENDPBOp();


  PBOp(trie_retry_atom, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
#ifdef GLOBAL_TRIE
    int vars_arity = *(aux_stack_ptr);
    int subs_arity = *(aux_stack_ptr + vars_arity + 1);
#else
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
#endif /* GLOBAL_TRIE */
    restore_trie_node(TrNode_next(node));
#ifdef GLOBAL_TRIE
    YENV = aux_stack_ptr = load_substitution_variable(TrNode_entry(node), aux_stack_ptr);
    next_instruction(subs_arity - 1, node); 
#else
    stack_trie_atom_instr();
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_atom_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    stack_trie_atom_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_atom_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_atom_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    pop_trie_node();
    stack_trie_atom_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_atom_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_atom_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    store_trie_node(TrNode_next(node));
    stack_trie_atom_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_atom_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_atom_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    restore_trie_node(TrNode_next(node));
    stack_trie_atom_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_atom_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_pair, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    stack_trie_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_pair)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_pair, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    pop_trie_node();
    stack_trie_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_pair)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_pair, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    store_trie_node(TrNode_next(node));
    stack_trie_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_pair)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_pair, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    restore_trie_node(TrNode_next(node));
    stack_trie_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_pair)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_struct, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    Functor func = (Functor) RepAppl(TrNode_entry(node));
    int func_arity = ArityOfFunctor(func);

    stack_trie_struct_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_struct)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_struct, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    Functor func = (Functor) RepAppl(TrNode_entry(node));
    int func_arity = ArityOfFunctor(func);

    pop_trie_node();
    stack_trie_struct_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_struct)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_struct, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    Functor func = (Functor) RepAppl(TrNode_entry(node));
    int func_arity = ArityOfFunctor(func);

    store_trie_node(TrNode_next(node));
    stack_trie_struct_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_struct)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_struct, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    Functor func = (Functor) RepAppl(TrNode_entry(node));
    int func_arity = ArityOfFunctor(func);

    restore_trie_node(TrNode_next(node));
    stack_trie_struct_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_struct)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_struct_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    Functor func = (Functor) RepAppl(TrNode_entry(node));
    int func_arity = ArityOfFunctor(func);

    stack_trie_struct_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_struct_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_struct_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    Functor func = (Functor) RepAppl(TrNode_entry(node));
    int func_arity = ArityOfFunctor(func);

    pop_trie_node();
    stack_trie_struct_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_struct_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_struct_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    Functor func = (Functor) RepAppl(TrNode_entry(node));
    int func_arity = ArityOfFunctor(func);

    store_trie_node(TrNode_next(node));
    stack_trie_struct_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_struct_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_struct_in_new_pair, e)
#if defined(TRIE_COMPACT_PAIRS) && !defined(GLOBAL_TRIE)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    Functor func = (Functor) RepAppl(TrNode_entry(node));
    int func_arity = ArityOfFunctor(func);

    restore_trie_node(TrNode_next(node));
    stack_trie_struct_in_new_pair_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_struct_in_new_pair)");
#endif /* TRIE_COMPACT_PAIRS && GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_extension, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;

    stack_trie_extension_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_extension)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_trust_extension, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    pop_trie_node();
    stack_trie_extension_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_extension)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_try_extension, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    store_trie_node(TrNode_next(node));
    stack_trie_extension_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_extension)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_retry_extension, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);

    restore_trie_node(TrNode_next(node));
    stack_trie_extension_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_extension)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  PBOp(trie_do_float, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    volatile Float dbl;
    volatile Term *t_dbl = (Term *)((void *) &dbl);
    Term t;

#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
    heap_arity -= 4;
    t_dbl[0] = *++aux_stack_ptr;
    ++aux_stack_ptr;  /* jump the float/longint extension mark */
    t_dbl[1] = *++aux_stack_ptr;
#else /* SIZEOF_DOUBLE == SIZEOF_INT_P */
    heap_arity -= 2;
    *t_dbl = *++aux_stack_ptr;
#endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */
    ++aux_stack_ptr;  /* jump the float/longint extension mark */
    t = MkFloatTerm(dbl);
    stack_trie_float_longint_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_float)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  BOp(trie_trust_float, e)
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_float)");
  ENDBOp();


  BOp(trie_try_float, e)
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_float)");
  ENDBOp();


  BOp(trie_retry_float, e)
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_float)");
  ENDBOp();


  PBOp(trie_do_long, e)
#ifndef GLOBAL_TRIE
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_stack_ptr = YENV;
    int heap_arity = *aux_stack_ptr;
    int vars_arity = *(aux_stack_ptr + heap_arity + 1);
    int subs_arity = *(aux_stack_ptr + heap_arity + 2);
    Term t;

    heap_arity -= 2;
    t = MkLongIntTerm(*++aux_stack_ptr);
    ++aux_stack_ptr;  /* jump the float/longint extension mark */
    stack_trie_float_longint_instr();
#else
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_long)");
#endif /* GLOBAL_TRIE */
  ENDPBOp();


  BOp(trie_trust_long, e)
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_long)");
  ENDBOp();


  BOp(trie_try_long, e)
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_long)");
  ENDBOp();


  BOp(trie_retry_long, e)
    Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_long)");
  ENDBOp();