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: stack organization      **
** ----------------------------------------------- **
           -------------------
           | 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    |    |
           -------------------  -- 
** ----------------------------------------------- */



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

#define copy_arity_stack()                                      \
        { int size = heap_arity + subs_arity + vars_arity + 3;  \
          YENV -= size;                                         \
          memcpy(YENV, aux_ptr, size * sizeof(CELL *));         \
          aux_ptr = YENV;                                       \
	}

#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_ptr++;                                   \
          Bind_Global((CELL *) *aux_ptr, AbsPair(H));  \
          *aux_ptr-- = (CELL) (H + 1);                 \
          *aux_ptr-- = (CELL) H;                       \
          *aux_ptr = heap_arity - 1 + 2;               \
          YENV = aux_ptr;                              \
        } else {                                       \
          int i;                                       \
          *aux_ptr-- = (CELL) (H + 1);                 \
          *aux_ptr-- = (CELL) H;                       \
          *aux_ptr = 2;                                \
          YENV = aux_ptr;                              \
          aux_ptr += 2 + 2;                            \
          *aux_ptr = subs_arity - 1;                   \
          aux_ptr += subs_arity;                       \
          Bind((CELL *) *aux_ptr, AbsPair(H));         \
          for (i = 0; i < vars_arity; i++) {           \
            *aux_ptr = *(aux_ptr + 1);                 \
            aux_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_ptr = heap_arity - 1;                             \
          var = *++aux_ptr;                                      \
          RESET_VARIABLE(var);                                   \
          for (i = 0; i < heap_arity - 1; i++) {                 \
            *aux_ptr = *(aux_ptr + 1);                           \
            aux_ptr++;                                           \
          }                                                      \
          *aux_ptr++ = vars_arity + 1;                           \
          *aux_ptr++ = subs_arity;                               \
          for (i = 0; i < subs_arity; i++) {                     \
            *aux_ptr = *(aux_ptr + 1);                           \
            aux_ptr++;                                           \
          }                                                      \
          *aux_ptr = var;                                        \
          next_instruction(heap_arity - 1 || subs_arity, node);  \
        } else {                                                 \
          *++aux_ptr = vars_arity + 1;                           \
          *++aux_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_ptr-- = (CELL) (H + 1);                           \
          *aux_ptr = heap_arity - 1 + 1;                         \
          YENV = aux_ptr;                                        \
          aux_ptr += 2;                                          \
          Bind_Global((CELL *) *aux_ptr, AbsPair(H));            \
          for (i = 0; i < heap_arity - 1; i++) {                 \
            *aux_ptr = *(aux_ptr + 1);                           \
            aux_ptr++;                                           \
          }                                                      \
          *aux_ptr++ = vars_arity + 1;                           \
          *aux_ptr++ = subs_arity;                               \
          for (i = 0; i < subs_arity; i++) {                     \
            *aux_ptr = *(aux_ptr + 1);                           \
            aux_ptr++;                                           \
          }                                                      \
          *aux_ptr = (CELL) H;                                   \
        } else {                                                 \
          *aux_ptr-- = (CELL) (H + 1);                           \
          *aux_ptr = 1;                                          \
          YENV = aux_ptr;                                        \
          aux_ptr += 2;                                          \
          *aux_ptr++ = vars_arity + 1;                           \
          *aux_ptr = subs_arity - 1;                             \
          aux_ptr += subs_arity;                                 \
          Bind((CELL *) *aux_ptr, AbsPair(H));                   \
          *aux_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, subs, *subs_ptr;				                      \
          YENV = ++aux_ptr;                                                           \
          subs_ptr = aux_ptr + heap_arity + 1 + subs_arity + vars_arity - var_index;  \
          aux = *aux_ptr;                                                             \
          subs = *subs_ptr;                                                           \
          if (aux > subs) {                                                           \
            Bind_Global((CELL *) aux, subs);                                          \
          } else {                                                                    \
            RESET_VARIABLE(aux);                                                      \
	    Bind_Local((CELL *) subs, aux);                                           \
            *subs_ptr = aux;                                                          \
          }                                                                           \
          *aux_ptr = heap_arity - 1;                                                  \
          next_instruction(heap_arity - 1 || subs_arity, node);                       \
        } else {                                                                      \
          CELL aux, subs, *subs_ptr;                                                  \
          int i;                                                                      \
          aux_ptr += 2;                                                               \
          *aux_ptr = subs_arity - 1;                                                  \
          aux_ptr += subs_arity;                                                      \
          subs_ptr = aux_ptr + vars_arity - var_index;                                \
          aux = *aux_ptr;                                                             \
          subs = *subs_ptr;                                                           \
          if (aux > subs) {                                                           \
	    if ((CELL *) aux <= H) {                                                  \
              Bind_Global((CELL *) aux, subs);                                        \
            } else if ((CELL *) subs <= H) {                                          \
              Bind_Local((CELL *) aux, subs);                                         \
            } else {                                                                  \
              Bind_Local((CELL *) subs, aux);                                         \
              *subs_ptr = aux;                                                        \
            }                                                                         \
          } else {                                                                    \
	    if ((CELL *) subs <= H) {                                                 \
              Bind_Global((CELL *) subs, aux);                                        \
              *subs_ptr = aux;                                                        \
            } else if ((CELL *) aux <= H) {                                           \
              Bind_Local((CELL *) subs, aux);                                         \
              *subs_ptr = aux;                                                        \
            } else {                                                                  \
              Bind_Local((CELL *) aux, subs);                                         \
            }                                                                         \
          }                                                                           \
          for (i = 0; i < vars_arity; i++) {                                          \
            *aux_ptr = *(aux_ptr + 1);                                                \
            aux_ptr++;                                                                \
          }                                                                           \
          next_instruction(subs_arity - 1, node);                                     \
        }

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



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

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

#ifdef TRIE_COMPACT_PAIRS
#define stack_trie_atom_in_new_pair_instr()                      \
        if (heap_arity) {                                        \
          aux_ptr++;		                                 \
          Bind_Global((CELL *) *aux_ptr, AbsPair(H));            \
          *aux_ptr = (CELL) (H + 1);                             \
        } else {                                                 \
          int i;                                                 \
          *aux_ptr-- = (CELL) (H + 1);                           \
          *aux_ptr = 1;                                          \
          YENV = aux_ptr;                                        \
          aux_ptr += 1 + 2;                                      \
          *aux_ptr = subs_arity - 1;                             \
          aux_ptr += subs_arity;                                 \
          Bind((CELL *) *aux_ptr, AbsPair(H));                   \
          for (i = 0; i < vars_arity; i++) {                     \
            *aux_ptr = *(aux_ptr + 1);                           \
            aux_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_ptr++;                                   \
          Bind_Global((CELL *) *aux_ptr, AbsPair(H));  \
          *aux_ptr = (CELL) H;                         \
	} else {                                       \
          int i;                                       \
          *aux_ptr-- = (CELL) H;                       \
          *aux_ptr = 1;                                \
          YENV = aux_ptr;                              \
          aux_ptr += 1 + 2;                            \
          *aux_ptr = subs_arity - 1;                   \
          aux_ptr += subs_arity;                       \
          Bind((CELL *) *aux_ptr, AbsPair(H));         \
          for (i = 0; i < vars_arity; i++) {           \
            *aux_ptr = *(aux_ptr + 1);                 \
            aux_ptr++;                                 \
          }                                            \
	}                                              \
        Bind_Global(H + 1, TermNil);                   \
        H += 2;                                        \
        next_trie_instruction(node)
#else
#define stack_trie_pair_instr()                        \
        if (heap_arity) {                              \
          aux_ptr++;                                   \
          Bind_Global((CELL *) *aux_ptr, AbsPair(H));  \
          *aux_ptr-- = (CELL) (H + 1);                 \
          *aux_ptr-- = (CELL) H;                       \
          *aux_ptr = heap_arity - 1 + 2;               \
          YENV = aux_ptr;                              \
        } else {                                       \
          int i;                                       \
          *aux_ptr-- = (CELL) (H + 1);                 \
          *aux_ptr-- = (CELL) H;                       \
          *aux_ptr = 2;                                \
          YENV = aux_ptr;                              \
          aux_ptr += 2 + 2;                            \
          *aux_ptr = subs_arity - 1;                   \
          aux_ptr += subs_arity;                       \
          Bind((CELL *) *aux_ptr, AbsPair(H));         \
          for (i = 0; i < vars_arity; i++) {           \
            *aux_ptr = *(aux_ptr + 1);                 \
            aux_ptr++;                                 \
          }                                            \
        }                                              \
        H += 2;                                        \
        next_trie_instruction(node)
#endif /* TRIE_COMPACT_PAIRS */



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

#define stack_trie_struct_instr()                          \
        if (heap_arity) {                                  \
          int i;                                           \
          aux_ptr++;                                       \
          Bind_Global((CELL *) *aux_ptr, AbsAppl(H));      \
          for (i = 0; i < func_arity; i++)                 \
            *aux_ptr-- = (CELL) (H + func_arity - i);      \
          *aux_ptr = heap_arity - 1 + func_arity;          \
          YENV = aux_ptr;                                  \
        } else {                                           \
          int i;                                           \
          for (i = 0; i < func_arity; i++)                 \
            *aux_ptr-- = (CELL) (H + func_arity - i);      \
          *aux_ptr = func_arity;                           \
          YENV = aux_ptr;                                  \
          aux_ptr += func_arity + 2;                       \
          *aux_ptr = subs_arity - 1;                       \
          aux_ptr += subs_arity;                           \
          Bind((CELL *) *aux_ptr, AbsAppl(H));             \
          for (i = 0; i < vars_arity; i++) {               \
            *aux_ptr = *(aux_ptr + 1);                     \
            aux_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_ptr++;		                           \
          Bind_Global((CELL *) *aux_ptr, AbsPair(H));      \
          *aux_ptr-- = (CELL) (H + 1);                     \
          for (i = 0; i < func_arity; i++)                 \
            *aux_ptr-- = (CELL) (H + 2 + func_arity - i);  \
          *aux_ptr = heap_arity - 1 + 1 + func_arity;      \
          YENV = aux_ptr;                                  \
        } else {                                           \
          int i;                                           \
          *aux_ptr-- = (CELL) (H + 1);                     \
          for (i = 0; i < func_arity; i++)                 \
            *aux_ptr-- = (CELL) (H + 2 + func_arity - i);  \
          *aux_ptr = 1 + func_arity;                       \
          YENV = aux_ptr;                                  \
          aux_ptr += 1 + func_arity + 2;                   \
          *aux_ptr = subs_arity - 1;                       \
          aux_ptr += subs_arity;                           \
          Bind((CELL *) *aux_ptr, AbsPair(H));             \
          for (i = 0; i < vars_arity; i++) {               \
            *aux_ptr = *(aux_ptr + 1);                     \
            aux_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_ptr-- = 0;  /* float/longint extension mark */  \
        *aux_ptr-- = TrNode_entry(node);                     \
        *aux_ptr = heap_arity + 2;                           \
        YENV = aux_ptr;                                      \
        next_trie_instruction(node)



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

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



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

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

    stack_trie_null_instr();
  ENDPBOp();


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

    pop_trie_node();
    stack_trie_null_instr();
  ENDPBOp();


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

    store_trie_node(TrNode_next(node));
    stack_trie_null_instr();
  ENDPBOp();


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

    restore_trie_node(TrNode_next(node));
    stack_trie_null_instr();
  ENDPBOp();


  PBOp(trie_do_null_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_trust_null_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_try_null_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_retry_null_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


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

    stack_trie_var_instr();
  ENDPBOp();


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

    pop_trie_node();
    stack_trie_var_instr();
  ENDPBOp();


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

    store_trie_node(TrNode_next(node));
    stack_trie_var_instr();
  ENDPBOp();


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

    restore_trie_node(TrNode_next(node));
    stack_trie_var_instr();
  ENDPBOp();


  PBOp(trie_do_var_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_trust_var_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_try_var_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_retry_var_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


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

    stack_trie_val_instr();
  ENDPBOp();


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

    pop_trie_node();
    stack_trie_val_instr();
  ENDPBOp();


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

    store_trie_node(TrNode_next(node));
    stack_trie_val_instr();
  ENDPBOp();


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

    restore_trie_node(TrNode_next(node));
    stack_trie_val_instr();
  ENDPBOp();


  PBOp(trie_do_val_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_trust_val_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_try_val_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_retry_val_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_do_atom, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_ptr + heap_arity + 2);

    stack_trie_atom_instr();
  ENDPBOp();


  PBOp(trie_trust_atom, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_ptr + heap_arity + 2);

    pop_trie_node();
    stack_trie_atom_instr();
  ENDPBOp();


  PBOp(trie_try_atom, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_ptr + heap_arity + 2);

    store_trie_node(TrNode_next(node));
    stack_trie_atom_instr();
  ENDPBOp();


  PBOp(trie_retry_atom, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_ptr + heap_arity + 2);

    restore_trie_node(TrNode_next(node));
    stack_trie_atom_instr();
  ENDPBOp();


  PBOp(trie_do_atom_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_trust_atom_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_try_atom_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_retry_atom_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


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

    stack_trie_pair_instr();
  ENDPBOp();


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

    pop_trie_node();
    stack_trie_pair_instr();
  ENDPBOp();


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

    store_trie_node(TrNode_next(node));
    stack_trie_pair_instr();
  ENDPBOp();


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

    restore_trie_node(TrNode_next(node));
    stack_trie_pair_instr();
  ENDPBOp();


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

    stack_trie_struct_instr();
  ENDPBOp();


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

    pop_trie_node();
    stack_trie_struct_instr();
  ENDPBOp();


  PBOp(trie_try_struct, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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();
  ENDPBOp();


  PBOp(trie_retry_struct, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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();
  ENDPBOp();


  PBOp(trie_do_struct_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_trust_struct_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_try_struct_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_retry_struct_in_new_pair, e)
#ifdef TRIE_COMPACT_PAIRS
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = (CELL *) (B + 1);
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 */
  ENDPBOp();


  PBOp(trie_do_extension, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;

    stack_trie_extension_instr();
  ENDPBOp();


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

    pop_trie_node();
    stack_trie_extension_instr();
  ENDPBOp();


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

    store_trie_node(TrNode_next(node));
    stack_trie_extension_instr();
  ENDPBOp();


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

    restore_trie_node(TrNode_next(node));
    stack_trie_extension_instr();
  ENDPBOp();


  PBOp(trie_do_float, e)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_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 = *++aux_ptr;
    ++aux_ptr;  /* jump the float/longint extension mark */
    *(t_dbl + 1) = *++aux_ptr;
#else /* SIZEOF_DOUBLE == SIZEOF_INT_P */
    heap_arity -= 2;
    *t_dbl = *++aux_ptr;
#endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */
    ++aux_ptr;  /* jump the float/longint extension mark */
    t = MkFloatTerm(dbl);
    stack_trie_float_longint_instr();
  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)
    register ans_node_ptr node = (ans_node_ptr) PREG;
    register CELL *aux_ptr = YENV;
    int heap_arity = *aux_ptr;
    int vars_arity = *(aux_ptr + heap_arity + 1);
    int subs_arity = *(aux_ptr + heap_arity + 2);
    Term t;

    heap_arity -= 2;
    t = MkLongIntTerm(*++aux_ptr);
    ++aux_ptr;  /* jump the float/longint extension mark */
    stack_trie_float_longint_instr();
  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();