diff --git a/CMakeLists.txt b/CMakeLists.txt
index e6fa787..7b7ad86 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -143,6 +143,14 @@
    set(INSTALL_TESTS_DIR   ${SWIPL_INSTALL_PREFIX}/test)
 endif()
 
+if(NOT SWIPL_PKG_NAME)
+  if(SWIPL_INSTALL_DIR STREQUAL "swi-prolog")
+    set(SWIPL_PKG_NAME ${SWIPL_INSTALL_DIR})
+  else()
+    set(SWIPL_PKG_NAME "swipl")
+  endif()
+endif()
+
 if(MSVC)
   add_compile_options(/W3)
 else()
diff --git a/VERSION b/VERSION
index e624caf..e72091d 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-8.1.29
+8.1.30
diff --git a/boot/bags.pl b/boot/bags.pl
index 20a0ff9..acee1fe 100644
--- a/boot/bags.pl
+++ b/boot/bags.pl
@@ -3,8 +3,9 @@
     Author:        Jan Wielemaker
     E-mail:        J.Wielemaker@vu.nl
     WWW:           http://www.swi-prolog.org
-    Copyright (c)  1985-2014, University of Amsterdam,
+    Copyright (c)  1985-2020, University of Amsterdam,
                               VU University Amsterdam
+                              CWI, Amsterdam
     All rights reserved.
 
     Redistribution and use in source and binary forms, with or without
@@ -180,11 +181,27 @@
     (   Vars == v
     ->  findall(Templ, Goal, List),
         List \== []
-    ;   findall(Vars-Templ, Goal, Answers),
-        bind_bagof_keys(Answers,_),
+    ;   alloc_bind_key_list(Vars, VDict),
+        findall(Vars-Templ, Goal, Answers),
+        bind_bagof_keys(Answers, VDict),
         keysort(Answers, Sorted),
         pick(Sorted, Vars, List)
     ).
+
+%!  alloc_bind_key_list(+Vars, -VDict) is det.
+%
+%   Pre-allocate the variable dictionary used   by bind_bagof_keys/2. By
+%   pre-allocating this list all variables  bound become references from
+%   the `Vars` of  each  answer  to  this   dictionary.  If  we  do  not
+%   preallocate we create a huge reference chain from VDict through each
+%   of the answers, causing serious slowdown in the subsequent keysort.
+%
+%   The slowdown was discovered by Jan Burse.
+
+alloc_bind_key_list(Vars, VDict) :-
+    functor(Vars, _, Count),
+    length(List, Count),
+    '$append'(List, _, VDict).
 
 %!  bind_bagof_keys(+VarsTemplPairs, -SharedVars)
 %
@@ -243,13 +260,14 @@
     ->  findall(Templ, Goal, Answers),
         Answers \== [],
         sort(Answers, List)
-    ;   findall(Vars-Templ, Goal, Answers),
+    ;   alloc_bind_key_list(Vars, VDict),
+        findall(Vars-Templ, Goal, Answers),
         (   ground(Answers)
-        ->  sort(Answers,Sorted),
-            pick(Sorted,Vars,List)
-        ;   bind_bagof_keys(Answers,_VDict),
+        ->  sort(Answers, Sorted),
+            pick(Sorted, Vars, List)
+        ;   bind_bagof_keys(Answers, VDict),
             sort(Answers, Sorted),
             pick(Sorted, Vars, Listu),
-            sort(Listu,List) % Listu ordering may be nixed by Vars
+            sort(Listu, List) % Listu ordering may be nixed by Vars
         )
     ).
diff --git a/boot/init.pl b/boot/init.pl
index cb16ed5..d949007 100644
--- a/boot/init.pl
+++ b/boot/init.pl
@@ -3761,6 +3761,11 @@
     ->  true
     ;   '$type_error'(callable, X)
     ).
+'$must_be'(acyclic, X) :- !,
+    (   acyclic_term(X)
+    ->  true
+    ;   '$domain_error'(acyclic_term, X)
+    ).
 '$must_be'(oneof(Type, Domain, List), X) :- !,
     '$must_be'(Type, X),
     (   memberchk(X, List)
diff --git a/boot/tabling.pl b/boot/tabling.pl
index 968c1dc..ace2f49 100644
--- a/boot/tabling.pl
+++ b/boot/tabling.pl
@@ -55,7 +55,9 @@
 
             start_tabling/3,            % +Closure, +Wrapper, :Worker
             start_subsumptive_tabling/3,% +Closure, +Wrapper, :Worker
-            moded_start_tabling/5,      % +Closure, +Wrapper, :Worker, :Variant, ?ModeArgs
+            start_abstract_tabling/3,   % +Closure, +Wrapper, :Worker
+            start_moded_tabling/5,      % +Closure, +Wrapper, :Worker,
+                                        % :Variant, ?ModeArgs
 
             '$tbl_answer'/4,            % +Trie, -Return, -ModeArgs, -Delay
 
@@ -74,7 +76,8 @@
     not_exists(0),
     tabled_call(0),
     start_tabling(+, +, 0),
-    start_tabling(+, +, 0, +, ?),
+    start_abstract_tabling(+, +, 0),
+    start_moded_tabling(+, +, 0, +, ?),
     current_table(:, -),
     abolish_table_subgoals(:),
     '$wfs_call'(0, :).
@@ -271,22 +274,18 @@
    prolog_listen(untable, untable_reconsult).
 
 
-%!  start_tabling(:Wrapper, :Implementation)
-%
-%   Execute Implementation using tabling. This  predicate should not
-%   be called directly. The table/1 directive  causes a predicate to
-%   be translated into a renamed implementation   and a wrapper that
-%   involves this predicate.
-%
-%   @compat This interface may change or disappear without notice
-%           from future versions.
-
 '$wrap_tabled'(Head, Options) :-
     get_dict(mode, Options, subsumptive),
     !,
     set_pattributes(Head, Options),
     '$wrap_predicate'(Head, table, Closure, Wrapped,
                       start_subsumptive_tabling(Closure, Head, Wrapped)).
+'$wrap_tabled'(Head, Options) :-
+    get_dict(subgoal_abstract, Options, _Abstract),
+    !,
+    set_pattributes(Head, Options),
+    '$wrap_predicate'(Head, table, Closure, Wrapped,
+                      start_abstract_tabling(Closure, Head, Wrapped)).
 '$wrap_tabled'(Head, Options) :-
     !,
     set_pattributes(Head, Options),
@@ -311,12 +310,28 @@
 tabled_attribute(dynamic).
 tabled_attribute(tshared).
 tabled_attribute(max_answers).
-tabled_attribute(abstract_subgoal).
+tabled_attribute(subgoal_abstract).
 tabled_attribute(answer_abstract).
 
+%!  start_tabling(:Closure, :Wrapper, :Implementation)
+%
+%   Execute Implementation using tabling. This   predicate should not be
+%   called directly. The table/1 directive  causes   a  predicate  to be
+%   translated into a renamed implementation and a wrapper that involves
+%   this predicate.
+%
+%   @arg Closure is the wrapper closure   to find the predicate quickly.
+%   It is also allowed to pass nothing.   In that cases the predicate is
+%   looked up using Wrapper.  We suggest to pass `0` in this case.
+%
+%   @compat This interface may change or disappear without notice
+%           from future versions.
 
 start_tabling(Closure, Wrapper, Worker) :-
     '$tbl_variant_table'(Closure, Wrapper, Trie, Status, Skeleton),
+    start_tabling_2(Closure, Wrapper, Worker, Trie, Status, Skeleton).
+
+start_tabling_2(Closure, Wrapper, Worker, Trie, Status, Skeleton) :-
     tdebug(deadlock, 'Got table ~p, status ~p', [Trie, Status]),
     (   Status == complete
     ->  trie_gen_compiled(Trie, Skeleton)
@@ -342,7 +357,6 @@
     tdebug(schedule, 'Leader ~p done, status = ~p', [Goal, LStatus]),
     done_leader(LStatus, Fresh, Skeleton, Clause).
 
-
 %!  restart_tabling(+Closure, +Wrapper, +Worker)
 %
 %   We were aborted due to a  deadlock.   Simply  retry. We sleep a very
@@ -357,8 +371,13 @@
     sleep(0.000001),
     start_tabling(Closure, Wrapper, Worker).
 
-
-%!  start_subsumptive_tabling(:Wrapper, :Implementation)
+restart_abstract_tabling(Closure, Wrapper, Worker) :-
+    tdebug(user_goal(Wrapper, Goal)),
+    tdebug(deadlock, 'Deadlock running ~p; retrying', [Goal]),
+    sleep(0.000001),
+    start_abstract_tabling(Closure, Wrapper, Worker).
+
+%!  start_subsumptive_tabling(:Closure, :Wrapper, :Implementation)
 %
 %   (*) We should __not__ use  trie_gen_compiled/2   here  as  this will
 %   enumerate  all  answers  while  '$tbl_answer_update_dl'/2  uses  the
@@ -404,6 +423,77 @@
            [GenSkeleton+Skeleton]).
 
 unify_subsumptive(X,X).
+
+%!  start_abstract_tabling(:Closure, :Wrapper, :Worker)
+%
+%   Deal with ``table p/1 as  subgoal_abstract(N)``.   This  is  a merge
+%   between  variant  and  subsumptive  tabling.  If  the  goal  is  not
+%   abstracted this is simple variant tabling. If the goal is abstracted
+%   we must solve the  more  general  goal   and  use  answers  from the
+%   abstract table.
+%
+%   Wrapper is e.g., user:p(s(s(s(X))),Y)
+%   Worker  is e.g., call(<closure>(p/2)(s(s(s(X))),Y))
+
+start_abstract_tabling(Closure, Wrapper, Worker) :-
+    '$tbl_abstract_table'(Closure, Wrapper, Trie, _Abstract, Status, Skeleton),
+    tdebug(abstract, 'Wrapper=~p, Worker=~p, Skel=~p',
+           [Wrapper, Worker, Skeleton]),
+    (   is_most_general_term(Skeleton)           % TBD: Fill and test Abstract
+    ->  start_tabling_2(Closure, Wrapper, Worker, Trie, Status, Skeleton)
+    ;   Status == complete
+    ->  '$tbl_answer_update_dl'(Trie, Skeleton)
+    ;   functor(Status, fresh, 2)
+    ->  '$tbl_table_status'(Trie, _, GenWrapper, GenSkeleton),
+        abstract_worker(Worker, GenWrapper, GenWorker),
+        catch(create_abstract_table(Trie, Status, Skeleton, GenSkeleton, GenWrapper,
+                                    GenWorker),
+              deadlock,
+              restart_abstract_tabling(Closure, Wrapper, Worker))
+    ;   Status == invalid
+    ->  '$tbl_table_status'(Trie, _, GenWrapper, GenSkeleton),
+        reeval(ATrie, GenWrapper, GenSkeleton),
+        Wrapper = GenWrapper,
+        '$tbl_answer_update_dl'(ATrie, Skeleton)
+    ;   shift(call_info(GenSkeleton, Skeleton, Status)),
+        unify_subsumptive(Skeleton, GenSkeleton)
+    ).
+
+create_abstract_table(Trie, Fresh, Skeleton, GenSkeleton, Wrapper, Worker) :-
+    tdebug(Fresh = fresh(SCC, WorkList)),
+    tdebug(wl_goal(WorkList, Goal, _)),
+    tdebug(schedule, 'Created component ~d for ~p', [SCC, Goal]),
+    setup_call_catcher_cleanup(
+        '$idg_set_current'(OldCurrent, Trie),
+        run_leader(GenSkeleton, Worker, Fresh, LStatus, _Clause),
+        Catcher,
+        finished_leader(OldCurrent, Catcher, Fresh, Wrapper)),
+    tdebug(schedule, 'Leader ~p done, status = ~p', [Goal, LStatus]),
+    Skeleton = GenSkeleton,
+    done_abstract_leader(LStatus, Fresh, GenSkeleton, Trie).
+
+abstract_worker(_:call(Term), _M:GenWrapper, call(GenTerm)) :-
+    functor(Term, Closure, _),
+    GenWrapper =.. [_|Args],
+    GenTerm =.. [Closure|Args].
+
+:- '$hide'((done_abstract_leader/4)).
+
+done_abstract_leader(complete, _Fresh, Skeleton, Trie) :-
+    !,
+    '$tbl_answer_update_dl'(Trie, Skeleton).
+done_abstract_leader(final, fresh(SCC, _Worklist), Skeleton, Trie) :-
+    !,
+    '$tbl_free_component'(SCC),
+    '$tbl_answer_update_dl'(Trie, Skeleton).
+done_abstract_leader(_,_,_,_).
+
+%!  done_leader(+Status, +Fresh, +Skeleton, -Clause)
+%
+%   Called on completion of a table. Possibly destroys the component and
+%   generates the answers from the complete  table. The last cases deals
+%   with leaders that are merged into a higher SCC (and thus no longer a
+%   leader).
 
 :- '$hide'((done_leader/4, finished_leader/4)).
 
@@ -507,7 +597,7 @@
             dependency(SrcSkeleton, Continuation, Skeleton, WorkList, AllDelays))
     ).
 
-%!  moded_start_tabling(+Closure, :Wrapper, :Implementation, +Variant, +ModeArgs)
+%!  start_moded_tabling(+Closure, :Wrapper, :Implementation, +Variant, +ModeArgs)
 %
 %   As start_tabling/2, but in addition separates the data stored in the
 %   answer trie in the Variant and ModeArgs.
@@ -516,12 +606,12 @@
     '$set_predicate_attribute'(Head, tabled, true),
     '$wrap_predicate'(Head, table, Closure, Wrapped,
                       (   ModeTest,
-                          moded_start_tabling(Closure, Head, Wrapped,
+                          start_moded_tabling(Closure, Head, Wrapped,
                                               WrapperNoModes, ModeArgs)
                       )).
 
 
-moded_start_tabling(Closure, Wrapper, Worker, WrapperNoModes, ModeArgs) :-
+start_moded_tabling(Closure, Wrapper, Worker, WrapperNoModes, ModeArgs) :-
     '$tbl_moded_variant_table'(Closure, WrapperNoModes, Trie, Status, Skeleton),
     (   Status == complete
     ->  moded_gen_answer(Trie, Skeleton, ModeArgs)
@@ -699,6 +789,8 @@
 %!  tnot(:Goal)
 %
 %   Tabled negation.
+%
+%   (*): Only variant tabling is allowed under tnot/1.
 
 tnot(Goal0) :-
     '$tnot_implementation'(Goal0, Goal),        % verifies Goal is tabled
@@ -713,7 +805,9 @@
         ;   negation_suspend(Goal, Skeleton, Status)
         )
     ;   tdebug(tnot, 'tnot: ~p: fresh', [Goal]),
-        (   call(Goal),
+        (   '$wrapped_implementation'(Goal, table, Implementation), % see (*)
+            functor(Implementation, Closure, _),
+            start_tabling(Closure, Goal, Implementation),
             fail
         ;   '$tbl_existing_variant_table'(_, Goal, Trie, NewStatus, NewSkeleton),
             tdebug(tnot, 'tnot: fresh ~p now ~p', [Goal, NewStatus]),
@@ -901,10 +995,13 @@
 abolish_table_subgoals(SubGoal0) :-
     '$tbl_implementation'(SubGoal0, M:SubGoal),
     !,
-    forall(( '$tbl_variant_table'(VariantTrie),
-             trie_gen(VariantTrie, M:SubGoal, Trie)
-           ),
-           '$tbl_destroy_table'(Trie)).
+    '$must_be'(acyclic, SubGoal),
+    (   '$tbl_variant_table'(VariantTrie),
+        trie_gen(VariantTrie, M:SubGoal, Trie),
+        '$tbl_destroy_table'(Trie),
+        fail
+    ;   true
+    ).
 abolish_table_subgoals(_).
 
 %!  abolish_module_tables(+Module) is det.
@@ -1015,11 +1112,13 @@
     system:term_expansion/2.
 
 wrappers(Spec, M) -->
-    { tabling_defaults([ table_incremental-(incremental=true),
-                         table_shared-(tshared=true),
-                         table_subsumptive-((mode)=subsumptive)
-                       ],
-                       #{}, Defaults)
+    { tabling_defaults(
+          [ (table_incremental=true)            - (incremental=true),
+            (table_shared=true)                 - (tshared=true),
+            (table_subsumptive=true)            - ((mode)=subsumptive),
+            call(subgoal_size_restraint(Level)) - (subgoal_abstract=Level)
+          ],
+          #{}, Defaults)
     },
     wrappers(Spec, M, Defaults).
 
@@ -1102,13 +1201,24 @@
 
 
 tabling_defaults([], Dict, Dict).
-tabling_defaults([Flag-(Opt=Value)|T], Dict0, Dict) :-
-    (   current_prolog_flag(Flag, true)
+tabling_defaults([Condition-(Opt=Value)|T], Dict0, Dict) :-
+    (   tabling_default(Condition)
     ->  Dict1 = Dict0.put(Opt,Value)
     ;   Dict1 = Dict0
     ),
     tabling_defaults(T, Dict1, Dict).
 
+tabling_default(Flag=FValue) :-
+    !,
+    current_prolog_flag(Flag, FValue).
+tabling_default(call(Term)) :-
+    call(Term).
+
+% Called from wrappers//2.
+
+subgoal_size_restraint(Level) :-
+    current_prolog_flag(max_table_subgoal_size_action, abstract),
+    current_prolog_flag(max_table_subgoal_size, Level).
 
 %!  table_options(+Options, +OptDictIn, -OptDictOut)
 %
@@ -1145,9 +1255,9 @@
 table_options(max_answers(Count), Opts0, Opts1) :-
     !,
     restraint(max_answers, Count, Opts0, Opts1).
-table_options(abstract_subgoal(Size), Opts0, Opts1) :-
-    !,
-    restraint(abstract_subgoal, Size, Opts0, Opts1).
+table_options(subgoal_abstract(Size), Opts0, Opts1) :-
+    !,
+    restraint(subgoal_abstract, Size, Opts0, Opts1).
 table_options(answer_abstract(Size), Opts0, Opts1) :-
     !,
     restraint(answer_abstract, Size, Opts0, Opts1).
diff --git a/cmake/PackageSelection.cmake b/cmake/PackageSelection.cmake
index fd66be7..286ae56 100644
--- a/cmake/PackageSelection.cmake
+++ b/cmake/PackageSelection.cmake
@@ -264,6 +264,7 @@
 endif()
 if(NOT MULTI_THREADED)
   swipl_del_package(swipl-win "requires multi-threading")
+  swipl_del_package(tipc      "requires multi-threading")
 endif()
 
 if(INSTALL_DOCUMENTATION)
diff --git a/library/apply.pl b/library/apply.pl
index 7f581c2..4527fd6 100644
--- a/library/apply.pl
+++ b/library/apply.pl
@@ -178,11 +178,23 @@
                  *          MAPLIST/2...        *
                  *******************************/
 
-%!  maplist(:Goal, ?List)
-%
-%   True if Goal can successfully  be   applied  on  all elements of
-%   List. Arguments are reordered to gain  performance as well as to
-%   make the predicate deterministic under normal circumstances.
+%!  maplist(:Goal, ?List1).
+%!  maplist(:Goal, ?List1, ?List2).
+%!  maplist(:Goal, ?List1, ?List2, ?List3).
+%!  maplist(:Goal, ?List1, ?List2, ?List3, ?List4).
+%
+%   True if Goal is successfully applied on all matching elements of the
+%   list. The maplist family of predicates is defined as:
+%
+%   ```
+%   maplist(P, [X11,...,X1n], ..., [Xm1,...,Xmn]) :-
+%       P(X11, ..., Xm1),
+%       ...
+%       P(X1n, ..., Xmn).
+%   ```
+%
+%   This family of predicates is deterministic iff Goal is deterministic
+%   and List1 is a proper list, i.e., a list that ends in `[]`.
 
 maplist(Goal, List) :-
     maplist_(List, Goal).
@@ -192,10 +204,6 @@
     call(Goal, Elem),
     maplist_(Tail, Goal).
 
-%!  maplist(:Goal, ?List1, ?List2)
-%
-%   As maplist/2, operating on pairs of elements from two lists.
-
 maplist(Goal, List1, List2) :-
     maplist_(List1, List2, Goal).
 
@@ -204,10 +212,6 @@
     call(Goal, Elem1, Elem2),
     maplist_(Tail1, Tail2, Goal).
 
-%!  maplist(:Goal, ?List1, ?List2, ?List3)
-%
-%   As maplist/2, operating on triples of elements from three lists.
-
 maplist(Goal, List1, List2, List3) :-
     maplist_(List1, List2, List3, Goal).
 
@@ -215,12 +219,6 @@
 maplist_([Elem1|Tail1], [Elem2|Tail2], [Elem3|Tail3], Goal) :-
     call(Goal, Elem1, Elem2, Elem3),
     maplist_(Tail1, Tail2, Tail3, Goal).
-
-
-%!  maplist(:Goal, ?List1, ?List2, ?List3, ?List4)
-%
-%   As maplist/2, operating on  quadruples   of  elements  from four
-%   lists.
 
 maplist(Goal, List1, List2, List3, List4) :-
     maplist_(List1, List2, List3, List4, Goal).
diff --git a/library/dialect/xsb/machine.pl b/library/dialect/xsb/machine.pl
index b892f08..b7ad5f4 100644
--- a/library/dialect/xsb/machine.pl
+++ b/library/dialect/xsb/machine.pl
@@ -3,7 +3,8 @@
     Author:        Jan Wielemaker
     E-mail:        J.Wielemaker@vu.nl
     WWW:           http://www.swi-prolog.org
-    Copyright (c)  2019, VU University Amsterdam
+    Copyright (c)  2019-2020, VU University Amsterdam
+                              CWI, Amsterdam
     All rights reserved.
 
     Redistribution and use in source and binary forms, with or without
@@ -37,6 +38,7 @@
             trimcore/0,
 
             abolish_table_info/0,
+            close_open_tables/1,          % ?
 
             str_cat/3,
 
@@ -79,6 +81,13 @@
 %   Undocumented in the XSB manual.
 
 abolish_table_info.
+
+%!  close_open_tables(?Arg)
+%
+%   Undocumented in the XSB manual. Tables are always closed on
+%   exceptions, so it is unclear what this should do?
+
+close_open_tables(_).
 
 %!  str_cat(+Atom1, +Atom2, -Atom3)
 
diff --git a/library/dialect/xsb/source.pl b/library/dialect/xsb/source.pl
index a1968a0..9d2c647 100644
--- a/library/dialect/xsb/source.pl
+++ b/library/dialect/xsb/source.pl
@@ -34,11 +34,10 @@
 */
 
 :- module(xsb_source, []).
-:- autoload(library(apply),[convlist/3,partition/4]).
-:- autoload(library(debug),[debug/3]).
-:- autoload(library(error),[instantiation_error/1]).
-:- autoload(library(lists),[append/3,flatten/2]).
-
+:- autoload(library(apply),  [convlist/3,partition/4]).
+:- autoload(library(debug),  [debug/3]).
+:- autoload(library(error),  [instantiation_error/1]).
+:- autoload(library(occurs), [sub_term/2]).
 
 /** <module> Support XSB source .P files
 
@@ -67,7 +66,7 @@
     file_name_extension(Path, 'P', File),
     include_options(File, Include),
     compiler_options(COptions),
-    append(Include, COptions, Extra),
+    '$append'(Include, COptions, Extra),
     xsb_directives(File, Directives),
     directive_exports(Directives, Public, Directives1),
     (   Public == []
@@ -81,15 +80,14 @@
              (:- use_module(library(tables)))
            | Out2
            ],
-    append(Extra, More, Out2),
+    '$append'(Extra, More, Out2),
     (   nonvar(Module)
     ->  setup_call_cleanup(
             '$set_source_module'(OldM, Module),
-            convlist(head_directive(File), Directives1, More0),
+            phrase(head_directives(Directives1, File), More),
             '$set_source_module'(OldM))
-    ;   convlist(head_directive(File), Directives1, More0)
+    ;   phrase(head_directives(Directives1, File), More)
     ),
-    flatten(More0, More),
     debug(xsb(header), '~p: directives: ~p', [File, More]).
 
 include_options(File, Option) :-
@@ -142,21 +140,64 @@
 export_decl(PI) -->
     [PI].
 
-%!  head_directive(+File, +Directive, -PrefixedDirective) is semidet.
-
-head_directive(File, import(from(Preds, From)),
-               (:- xsb_import(Preds, From))) :-
-    assertz(xsb:moved_directive(File, import(from(Preds, From)))).
-head_directive(File, table(Preds as XSBOptions), Clauses) :-
-    ignored_table_options(XSBOptions, Options),
-    (   Options == true
-    ->  expand_term((:- table(Preds)), Clauses)
-    ;   expand_term((:- table(Preds as Options)), Clauses)
-    ),
-    assertz(xsb:moved_directive(File, table(Preds as XSBOptions))).
-head_directive(File, table(Preds), Clauses) :-
-    expand_term((:- table(Preds)), Clauses),
-    assertz(xsb:moved_directive(File, table(Preds))).
+%!  head_directives(+Directives, +File)// is det.
+%!  head_directives_s(+Directives, +State)// is det.
+
+head_directives(Directives, File) -->
+    { current_prolog_flag(max_table_subgoal_size_action, Action),
+      (   current_prolog_flag(max_table_subgoal_size, Size)
+      ->  true
+      ;   Size = -1
+      )
+    },
+    head_directives_s(Directives,
+                      #{file: File,
+                        max_table_subgoal_size_action: Action,
+                        max_table_subgoal_size:Size
+                       }).
+
+
+head_directives_s([], _) --> [].
+head_directives_s([H|T], State0) -->
+    { update_state(H, State0, State) },
+    !,
+    head_directives_s(T, State).
+head_directives_s([H|T], State) -->
+    head_directive(H, State),
+    head_directives_s(T, State).
+
+update_state(set_prolog_flag(max_table_subgoal_size_action, Action),
+             State0, State) :-
+    State = State0.put(max_table_subgoal_size_action, Action).
+update_state(set_prolog_flag(max_table_subgoal_size, Size),
+             State0, State) :-
+    State = State0.put(max_table_subgoal_size, Size).
+
+%!  head_directive(+Directive, +State)// is det.
+
+head_directive(import(from(Preds, From)), State) -->
+    !,
+    { assertz(xsb:moved_directive(State.file, import(from(Preds, From))))
+    },
+    [ (:- xsb_import(Preds, From)) ].
+head_directive(table(Preds as XSBOptions), State) -->
+    !,
+    { ignored_table_options(XSBOptions, Options),
+      table_clauses(Preds, Options, Clauses, State),
+      assertz(xsb:moved_directive(State.file, table(Preds as XSBOptions)))
+    },
+    seq(Clauses).
+head_directive(table(Preds), State) -->
+    !,
+    { table_clauses(Preds, true, Clauses, State),
+      assertz(xsb:moved_directive(State.file, table(Preds)))
+    },
+    seq(Clauses).
+head_directive(_, _) -->
+    [].
+
+seq([]) --> [].
+seq([H|T]) --> [H], seq(T).
 
 ignored_table_options((A0,B0), Conj) :-
     !,
@@ -177,12 +218,30 @@
 supported_table_option(shared).
 supported_table_option(private).
 supported_table_option(max_answers(_)).
-supported_table_option(abstract_subgoal(_)).
+supported_table_option(subgoal_abstract(_)).
 supported_table_option(answer_abstract(_)).
 
 mkconj(true, X, X) :- !.
 mkconj(X, true, X) :- !.
 mkconj(X, Y, (X,Y)) :- !.
+
+table_clauses(Preds, Options0, Clauses, State) :-
+    add_defaults(Options0, Options, State),
+    (   Options == true
+    ->  expand_term((:- table(Preds)), Clauses)
+    ;   expand_term((:- table(Preds as Options)), Clauses)
+    ).
+
+add_defaults(Opts, Opts, _) :-
+    sub_term(subgoal_abstract(_), Opts),
+    !.
+add_defaults(Opts0, Opts, State) :-
+    #{max_table_subgoal_size_action:abstract,
+      max_table_subgoal_size:Size} :< State,
+    Size >= 0,
+    !,
+    mkconj(Opts0, subgoal_abstract(Size), Opts).
+add_defaults(Opts, Opts, _).
 
 %!  xsb_directives(+File, -Directives) is semidet.
 %
diff --git a/library/dialect/xsb/tables.pl b/library/dialect/xsb/tables.pl
index 6b027b7..2fd443e 100644
--- a/library/dialect/xsb/tables.pl
+++ b/library/dialect/xsb/tables.pl
@@ -269,6 +269,9 @@
 comma_list(tnot(M:G), M) -->
     !,
     [tnot(G)].
+comma_list(system:G, _) -->
+    !,
+    [G].
 comma_list(G, _) -->
     [G].
 
diff --git a/library/dialect/xsb/timed_call.pl b/library/dialect/xsb/timed_call.pl
index 7ec1c93..310b743 100644
--- a/library/dialect/xsb/timed_call.pl
+++ b/library/dialect/xsb/timed_call.pl
@@ -105,6 +105,7 @@
 
 '$timed_call_nested'(Goal, M:Options) :-
     memberchk(max(MaxInterval, MaxHandler), Options),
+    !,
     run_max_goal(Goal, MaxInterval, MaxHandler, M:Options).
 '$timed_call_nested'(Goal, M:Options) :-
     memberchk(repeating(RepInterval, RepHandler), Options),
diff --git a/library/dialect/xsb.pl b/library/dialect/xsb.pl
index 43508db..f5fc3cc 100644
--- a/library/dialect/xsb.pl
+++ b/library/dialect/xsb.pl
@@ -47,6 +47,7 @@
             compiler_options/1,			% +Options
 
             xsb_import/2,                       % +Preds, From
+            xsb_set_prolog_flag/2,              % +Flag, +Value
 
             fail_if/1,				% :Goal
 
@@ -179,6 +180,8 @@
 
 xsb_mapped_predicate(expand_file_name(File, Expanded),
                      xsb_expand_file_name(File, Expanded)).
+xsb_mapped_predicate(set_prolog_flag(Flag, Value),
+                     xsb_set_prolog_flag(Flag, Value)).
 xsb_mapped_predicate(abolish_module_tables(UserMod),
                      abolish_module_tables(user)) :-
     UserMod == usermod.
@@ -312,6 +315,21 @@
     !.
 map_module(XSB, Module) :-
     assertz(mapped__module(XSB, Module)).
+
+
+%!  xsb_set_prolog_flag(+Flag, +Value)
+%
+%   Map some XSB Prolog flags to their SWI-Prolog's equivalents.
+
+xsb_set_prolog_flag(unify_with_occurs_check, XSBVal) :-
+    !,
+    map_bool(XSBVal, Val),
+    set_prolog_flag(occurs_check, Val).
+xsb_set_prolog_flag(Flag, Value) :-
+    set_prolog_flag(Flag, Value).
+
+map_bool(on, true).
+map_bool(off, false).
 
 
 		 /*******************************
diff --git a/library/help.pl b/library/help.pl
index a21e2ca..f0a5134 100644
--- a/library/help.pl
+++ b/library/help.pl
@@ -168,13 +168,13 @@
 help_html(Matches, How, HTML) :-
     phrase(html(html([ head([]),
                        body([ \match_type(How),
-                              \man_pages(Matches,
-                                         [ no_manual(fail),
-                                           links(false),
-                                           link_source(false),
-                                           navtree(false),
-                                           server(false)
-                                         ])
+                              dl(\man_pages(Matches,
+                                            [ no_manual(fail),
+                                              links(false),
+                                              link_source(false),
+                                              navtree(false),
+                                              server(false)
+                                            ]))
                             ])
                      ])),
            Tokens),
diff --git a/library/listing.pl b/library/listing.pl
index de67871..081849f 100644
--- a/library/listing.pl
+++ b/library/listing.pl
@@ -52,7 +52,7 @@
 :- autoload(library(option),[option/2,option/3,meta_options/3]).
 :- autoload(library(prolog_clause),[clause_info/5]).
 
-:- set_prolog_flag(generate_debug_info, false).
+%:- set_prolog_flag(generate_debug_info, false).
 
 :- module_transparent
     listing/0.
@@ -663,23 +663,17 @@
         portray_body(Body, BodyIndent, indent, RightPri, Out, Options)
     ),
     full_stop(Out).
-do_portray_clause(Out, (:-use_module(File, Imports)), Options) :-
-    length(Imports, Len),
-    Len > 3,
-    !,
+do_portray_clause(Out, (:-Directive), Options) :-
+    wrapped_list_directive(Directive),
+    !,
+    Directive =.. [Name, Arg, List],
     option(indent(LeftMargin), Options, 0),
     indent(Out, LeftMargin),
-    ListIndent is LeftMargin+14,
-    format(Out, ':- use_module(~q,', [File]),
-    portray_list(Imports, ListIndent, Out, Options),
-    write(Out, ').\n').
-do_portray_clause(Out, (:-module(Module, Exports)), Options) :-
-    !,
-    option(indent(LeftMargin), Options, 0),
-    indent(Out, LeftMargin),
-    ModuleIndent is LeftMargin+10,
-    format(Out, ':- module(~q,', [Module]),
-    portray_list(Exports, ModuleIndent, Out, Options),
+    format(Out, ':- ~q(', [Name]),
+    line_position(Out, Indent),
+    format(Out, '~q,', [Arg]),
+    nlindent(Out, Indent),
+    portray_list(List, Indent, Out, Options),
     write(Out, ').\n').
 do_portray_clause(Out, (:-Directive), Options) :-
     !,
@@ -702,6 +696,9 @@
     '$put_token'(Out, '.'),
     nl(Out).
 
+wrapped_list_directive(module(_,_)).
+%wrapped_list_directive(use_module(_,_)).
+%wrapped_list_directive(autoload(_,_)).
 
 %!  portray_body(+Term, +Indent, +DoIndent, +Priority, +Out, +Options)
 %
@@ -959,7 +956,6 @@
     !,
     write(Out, []).
 portray_list(List, Indent, Out, Options) :-
-    nlindent(Out, Indent),
     write(Out, '[ '),
     EIndent is Indent + 2,
     portray_list_elements(List, EIndent, Out, Options),
diff --git a/library/prolog_colour.pl b/library/prolog_colour.pl
index 9a824a5..fe5e5f3 100644
--- a/library/prolog_colour.pl
+++ b/library/prolog_colour.pl
@@ -1959,14 +1959,14 @@
     valid_decl_option(Option, Which),
     !,
     functor(Option, Name, _),
-    colour_item(decl_option(Name), TB, Pos),
-    (   Pos = term_position(_,_,_,_,[ArgPos])
-    ->  (   arg(1, Option, Value),
+    (   Pos = term_position(_,_,FF,FT,[ArgPos])
+    ->  colour_item(decl_option(Name), TB, FF-FT),
+        (   arg(1, Option, Value),
             nonneg_or_false(Value)
         ->  colourise_term_arg(Value, TB, ArgPos)
         ;   colour_item(type_error(decl_option_value(Which)), TB, ArgPos)
         )
-    ;   true
+    ;   colour_item(decl_option(Name), TB, Pos)
     ).
 colourise_decl_options(_, Which, TB, Pos) :-
     colour_item(type_error(decl_option(Which)), TB, Pos).
diff --git a/library/prolog_deps.pl b/library/prolog_deps.pl
new file mode 100755
index 0000000..db9559b
--- /dev/null
+++ b/library/prolog_deps.pl
@@ -0,0 +1,510 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2020, VU University Amsterdam
+                         CWI, Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(prolog_deps,
+          [ file_autoload_directives/3,      % +File, -Directives, +Options
+            file_auto_import/2               % +File, +Options
+          ]).
+:- use_module(library(apply), [convlist/3, maplist/3]).
+:- use_module(library(filesex), [copy_file/2]).
+:- use_module(library(lists), [select/3, subtract/3, append/3, member/2]).
+:- use_module(library(option), [option/2, option/3]).
+:- use_module(library(pairs), [group_pairs_by_key/2]).
+:- use_module(library(pprint), [print_term/2]).
+:- use_module(library(prolog_code), [pi_head/2]).
+:- use_module(library(prolog_source),
+              [ file_name_on_path/2,
+                path_segments_atom/2,
+                prolog_open_source/2,
+                prolog_read_source_term/4,
+                prolog_close_source/1
+              ]).
+:- use_module(library(prolog_xref),
+              [ xref_source/1,
+                xref_module/2,
+                xref_called/4,
+                xref_defined/3,
+                xref_built_in/1
+              ]).
+:- use_module(library(readutil), [read_file_to_string/3]).
+:- use_module(library(solution_sequences), [distinct/2]).
+
+/** <module> Compute file dependencies
+
+This module computes  file  dependencies  for   _modules_  as  a  set of
+directives.
+*/
+
+
+%!  file_autoload_directives(+File, -Directives, +Options) is det.
+%
+%   Compute the dependencies as autoload/2 directives.  Options
+%
+%     - missing(+Bool)
+%       If `true` (default `false`), only generate directives
+%       for called predicates that are not already imported.
+%
+%     - directive(+Directive)
+%       Directive to use for adding dependencies.  Defined
+%	options are:
+%
+%       - use_autoload/2
+%         (Default).  This uses use_module/2 for files that
+%         cannot be imported using use_autoload/2.
+%       - use_autoload/1
+%         This uses use_module/1 for files that cannot be
+%	  imported using use_autoload/1.
+%       - use_module/2
+%       - use_module/1
+%
+%     - update(Old)
+%       Updated an existing set of directives.  The returned
+%       set of Directive starts with copies of Old.  If a
+%       member of Old is autoload/2 or use_module/2, new
+%       dependencies are added at the end of this list.
+%       New dependent files are added after the modified
+%       copies of Old.  Declared dependencies are never
+%       removed, even if no proof of usage is found.
+%
+%       If no directive(+Directive) option is provided a
+%       default is determined from the given directives.
+
+file_autoload_directives(File, Directives, Options) :-
+    xref_source(File),
+    findall(Head, distinct(Head, undefined(File, Head, Options)), Missing),
+    convlist(missing_autoload(File), Missing, Pairs),
+    keysort(Pairs, Pairs1),
+    group_pairs_by_key(Pairs1, Grouped),
+    directives(Grouped, Directives, Options).
+
+%!  undefined(+File, -Callable, +Options)
+%
+%   Callable is called in File, but no   definition can be found. If
+%   File is not a module file we   consider other files that are not
+%   module files.
+
+undefined(File, Undef, Options) :-
+    xref_module(File, _),
+    !,
+    xref_called_cond(File, Undef, Cond),
+    \+ (   available(File, Undef, How, Options),
+           How \== plain_file
+       ),
+    included_if_defined(Cond, Undef),
+    Undef \= (_:_).
+undefined(File, Undef, Options) :-
+    xref_called_cond(File, Undef, Cond),
+    \+ available(File, Undef, _, Options),
+    included_if_defined(Cond, Undef),
+    Undef \= (_:_).
+
+%!  included_if_defined(+Condition, +Callable) is semidet.
+
+included_if_defined(true, _)  :- !.
+included_if_defined(false, _) :- !, fail.
+included_if_defined(fail, _)  :- !, fail.
+included_if_defined(current_predicate(Name/Arity), Callable) :-
+    \+ functor(Callable, Name, Arity),
+    !.
+included_if_defined(\+ Cond, Callable) :-
+    !,
+    \+ included_if_defined(Cond, Callable).
+included_if_defined((A,B), Callable) :-
+    !,
+    included_if_defined(A, Callable),
+    included_if_defined(B, Callable).
+included_if_defined((A;B), Callable) :-
+    !,
+    (   included_if_defined(A, Callable)
+    ;   included_if_defined(B, Callable)
+    ).
+
+xref_called_cond(Source, Callable, Cond) :-
+    xref_called(Source, Callable, By, Cond),
+    By \= Callable.                 % recursive calls
+
+%!  available(+File, +Callable, -HowDefined, +Options)
+%
+%   True if Callable is available in File.
+
+available(File, Called, How, Options) :-
+    xref_defined(File, Called, How0),
+    (   How0 = imported(_)
+    ->  option(missing(true), Options)
+    ;   true
+    ),
+    !,
+    How = How0.
+available(_, Called, How, _) :-
+    built_in_predicate(Called),
+    !,
+    How = builtin.
+available(_, Called, How, _) :-
+    Called = _:_,
+    defined(_, Called),
+    !,
+    How = module_qualified.
+available(_, M:G, How, _) :-
+    defined(ExportFile, G),
+    xref_module(ExportFile, M),
+    !,
+    How = module_overruled.
+available(_, Called, How, _) :-
+    defined(ExportFile, Called),
+    \+ xref_module(ExportFile, _),
+    !,
+    How == plain_file.
+
+%!  built_in_predicate(+Callable)
+%
+%   True if Callable is a built-in
+
+built_in_predicate(Goal) :-
+    strip_module(Goal, _, Plain),
+    xref_built_in(Plain).
+
+%!  defined(?File, ?Callable)
+%
+%   True if Callable is defined in File and not imported.
+
+defined(File, Callable) :-
+    xref_defined(File, Callable, How),
+    How \= imported(_).
+
+
+		 /*******************************
+		 *       GENERATE OUTPUT	*
+		 *******************************/
+
+missing_autoload(_Src, Head, File-Head) :-
+    predicate_property(Head, autoload(File)),
+    !.
+missing_autoload(Src, Head, From-Head) :-
+    xref_defined(Src, Head, imported(From)),
+    !.
+missing_autoload(_Src, Head, _) :-
+    pi_head(PI, Head),
+    print_message(warning,
+                  error(existence_error(procedure, PI), _)),
+    fail.
+
+%!  directives(+FileAndHeads, -Directives, +Options) is det.
+%
+%   Assemble the final set of directives. Uses the option update(Old).
+
+directives(FileAndHeads, Directives, Options) :-
+    option(update(Old), Options, []),
+    phrase(update_directives(Old, FileAndHeads, RestDeps), Directives, Rest),
+    update_style(Old, Options, Options1),
+    maplist(directive(Options1), RestDeps, Rest0),
+    sort(Rest0, Rest).
+
+update_directives([], Deps, Deps) -->
+    [].
+update_directives([:-(H)|T], Deps0, Deps) -->
+    { update_directive(H, Deps0, Deps1, Directive) },
+    !,
+    [ :-(Directive) ],
+    update_directives(T, Deps1, Deps).
+update_directives([H|T], Deps0, Deps) -->
+    [ H ],
+    update_directives(T, Deps0, Deps).
+
+update_directive(Dir0, Deps0, Deps, Dir) :-
+    directive_file(Dir0, FileSpec),
+    absolute_file_name(FileSpec, File,
+                       [ file_type(prolog),
+                         file_errors(fail),
+                         access(read)
+                       ]),
+    select(DepFile-Heads, Deps0, Deps),
+    same_dep_file(DepFile, File),
+    !,
+    (   Dir0 =.. [Pred,File,Imports]
+    ->  maplist(pi_head, PIs, Heads),
+        subtract(PIs, Imports, New),
+        append(Imports, New, NewImports),
+        Dir =.. [Pred,File,NewImports]
+    ;   Dir = Dir0
+    ).
+
+directive_file(use_module(File),   File).
+directive_file(use_module(File,_), File).
+directive_file(autoload(File),     File).
+directive_file(autoload(File,_),   File).
+
+same_dep_file(File, File) :-
+    !.
+same_dep_file(Dep, _File) :-
+    exists_file(Dep),
+    !,
+    fail.
+same_dep_file(Dep, File) :-
+    user:prolog_file_type(Ext, prolog),
+    file_name_extension(Dep, Ext, DepFile),
+    same_file(DepFile, File),
+    !.
+
+
+%!  update_style(+OldDirectives, +Options0, -Options)
+%
+%   Determine  the  directive  to  use    for   new  dependencies.  This
+%   establishes a default based on existing dependencies.
+
+update_style(_Old, Options, Options) :-
+    option(directive(_), Options),
+    !.
+update_style(Old, Options, [directive(autoload/2)|Options]) :-
+    memberchk((:- autoload(_,_)), Old),
+    !.
+update_style(Old, Options, [directive(autoload/1)|Options]) :-
+    memberchk((:- autoload(_)), Old),
+    !.
+update_style(Old, Options, [directive(use_module/2)|Options]) :-
+    memberchk((:- use_module(_,_)), Old),
+    !.
+update_style(Old, Options, [directive(use_module/1)|Options]) :-
+    memberchk((:- use_module(_)), Old),
+    !.
+update_style(_, Options, Options).
+
+
+%!  directive(+Options, +FileAndHeads, -Directive)
+%
+%   Create a directive to import Heads from File.
+
+directive(Options, File-Heads, Directive) :-
+    file_name_extension(File, pl, LibFile),
+    file_name_on_path(LibFile, Lib0),
+    segments(Lib0, Lib),
+    maplist(pi_head, PIs, Heads),
+    make_directive(Lib, PIs, Directive, Options).
+
+segments(Term0, Term) :-
+    Term0 =.. [Alias,Atom],
+    path_segments_atom(Segments, Atom),
+    format(atom(Atom), '~q', [Segments]),
+    !,
+    Term =.. [Alias,Segments].
+segments(FilePL, File) :-
+    atom(FilePL),
+    file_name_extension(File, pl, FilePL),
+    !.
+segments(Term, Term).
+
+:- multifile
+    prolog:no_autoload_module/1.
+
+make_directive(Lib, Import, (:- use_module(Lib, Import)), Options) :-
+    option(directive(use_module/2), Options, use_autoload/2),
+    !.
+make_directive(Lib, _Import, (:- use_module(Lib)), Options) :-
+    option(directive(use_module/1), Options, use_autoload/2),
+    !.
+make_directive(Lib, _Import, (:- use_module(Lib)), Options) :-
+    option(directive(use_autoload/1), Options, use_autoload/2),
+    prolog:no_autoload_module(Lib),
+    !.
+make_directive(Lib, Import, (:- use_module(Lib, Import)), _) :-
+    prolog:no_autoload_module(Lib),
+    !.
+make_directive(Lib, _Import, (:- autoload(Lib)), Options) :-
+    option(directive(use_autoload/1), Options, use_autoload/2),
+    !.
+make_directive(Lib, Import, (:- autoload(Lib, Import)), _).
+
+
+		 /*******************************
+		 *           REPLACE		*
+		 *******************************/
+
+%!  file_auto_import(+File, +Options)
+%
+%   Update the autoload/2 directives for File. This predicate __modifies
+%   the file in place__. Defined options are:
+%
+%     - backup(+Extension)
+%       Create a backup of File using Extension.
+
+file_auto_import(File, Options) :-
+    absolute_file_name(File, Path,
+                       [ file_type(prolog),
+                         access(read)
+                       ]),
+    file_autoload_directives(Path, Directives, Options),
+    (   option(backup(Ext), Options)
+    ->  file_name_extension(Path, Ext, Old),
+        copy_file(Path, Old)
+    ;   true
+    ),
+    Edit = _{import:Directives, done:_},
+    (   has_import(Path)
+    ->  edit_file(Old, Path, Edit.put(replace,true))
+    ;   edit_file(Old, Path, Edit.put(new,true))
+    ).
+
+has_import(InFile) :-
+    setup_call_cleanup(
+        prolog_open_source(InFile, In),
+        (   repeat,
+            prolog_read_source_term(In, Term, _Expanded, []),
+            (   Term == end_of_file
+            ->  !
+            ;    true
+            )
+        ),
+        prolog_close_source(In)),
+    nonvar(Term),
+    import_directive(Term),
+    !.
+
+import_directive((:- use_module(_))).
+import_directive((:- use_module(_, _))).
+
+%!  rewrite_term(+In, -Keep, -OutList, +Options) is semidet.
+
+rewrite_term(Never,_,_,_) :-
+    never_rewrite(Never),
+    !,
+    fail.
+rewrite_term(Import,false,[],Options) :-
+    Options.done == true,
+    !,
+    import_directive(Import).
+rewrite_term(In,false,Directives,Options) :-
+    import_directive(In),
+    !,
+    append(Options.import, [nl], Directives),
+    Options.done = true.
+rewrite_term(In,true,Directives,Options) :-
+    In = (:- module(_,_)),
+    Options.get(new) == true,
+    !,
+    append(Options.import, [nl], Directives),
+    Options.done = true.
+
+never_rewrite((:- use_module(_, []))).
+
+edit_file(InFile, OutFile, Options) :-
+    read_file_to_string(InFile, String, []),
+    setup_call_cleanup(
+        prolog_open_source(InFile, In),
+        setup_call_cleanup(
+            open(OutFile, write, Out),
+            rewrite(In, Out, String, Options),
+            close(Out)),
+        prolog_close_source(In)).
+
+rewrite(In, Out, String, Options) :-
+    prolog_read_source_term(
+        In, Term, _Expanded,
+        [ term_position(StartPos),
+          subterm_positions(TermPos),
+          comments(Comments)
+        ]),
+    stream_position_data(char_count, StartPos, StartChar),
+    copy_comments(Comments, StartChar, String, Out),
+    (   Term == end_of_file
+    ->  true
+    ;   (   nonvar(Term),
+            rewrite_term(Term, Keep, List, Options)
+        ->  (   Keep == true
+            ->  copy_term_string(TermPos, String, Out)
+            ;   true
+            ),
+            forall(member(T, List),
+                   output_term(Out, T)),
+            (   append(_, [nl], List)
+            ->  skip_blanks(In)
+            ;   true
+            )
+        ;   copy_term_string(TermPos, String, Out)
+        ),
+        rewrite(In, Out, String, Options)
+    ).
+
+output_term(Out, nl) :-
+    !,
+    nl(Out).
+output_term(Out, Term) :-
+    print_term(Term, [output(Out)]),
+    format(Out, '.~n', []).
+
+copy_comments([Pos-H|T], StartChar, String, Out) :-
+    stream_position_data(char_count, Pos, Start),
+    Start < StartChar,
+    !,
+    string_length(H, Len),
+    sub_string(String, Start, Len, _, Comment),
+    End is Start+Len+1,
+    layout_after(End, String, Layout),
+    format(Out, '~s~s', [Comment, Layout]),
+    copy_comments(T, StartChar, String, Out).
+copy_comments(_, _, _, _).
+
+copy_term_string(TermPos, String, Out) :-
+    arg(1, TermPos, Start),
+    arg(2, TermPos, End),
+    Len is End - Start,
+    sub_string(String, Start, Len, _, TermString),
+    End1 is End + 1,
+    full_stop_after(End1, String, Layout),
+    format(Out, '~s~s', [TermString, Layout]).
+
+layout_after(Index, String, [H|T]) :-
+    string_code(Index, String, H),
+    code_type(H, space),
+    !,
+    Index2 is Index+1,
+    layout_after(Index2, String, T).
+layout_after(_, _, []).
+
+full_stop_after(Index, String, [H|T]) :-
+    string_code(Index, String, H),
+    Index2 is Index+1,
+    (   code_type(H, space)
+    ->  !, full_stop_after(Index2, String, T)
+    ;   H == 0'.
+    ->  !, layout_after(Index2, String, T)
+    ).
+full_stop_after(_, _, []).
+
+skip_blanks(In) :-
+    peek_code(In, C),
+    code_type(C, space),
+    !,
+    get_code(In, _),
+    skip_blanks(In).
+skip_blanks(_).
diff --git a/library/sandbox.pl b/library/sandbox.pl
index 6cea772..3379f47 100644
--- a/library/sandbox.pl
+++ b/library/sandbox.pl
@@ -563,6 +563,7 @@
 safe_primitive(copy_term(_,_)).
 safe_primitive(system:duplicate_term(_,_)).
 safe_primitive(system:copy_term_nat(_,_)).
+safe_primitive(system:size_abstract_term(_,_,_)).
 safe_primitive(numbervars(_,_,_)).
 safe_primitive(system:numbervars(_,_,_,_)).
 safe_primitive(subsumes_term(_,_)).
@@ -1235,6 +1236,10 @@
 % tabling
 safe_prolog_flag(max_answers_for_subgoal,_).
 safe_prolog_flag(max_answers_for_subgoal_action,_).
+safe_prolog_flag(max_table_answer_size,_).
+safe_prolog_flag(max_table_answer_size_action,_).
+safe_prolog_flag(max_table_subgoal_size,_).
+safe_prolog_flag(max_table_subgoal_size_action,_).
 
 
 %!  prolog:sandbox_allowed_expansion(:G) is det.
diff --git a/library/solution_sequences.pl b/library/solution_sequences.pl
index 6b8700b..14bdb75 100644
--- a/library/solution_sequences.pl
+++ b/library/solution_sequences.pl
@@ -271,15 +271,17 @@
 
 %!  order_by(+Spec, :Goal)
 %
-%   Order solutions according to Spec.  Spec   is  a  list of terms,
-%   where each element is one of. The  ordering of solutions of Goal
-%   that only differ in variables that are _not_ shared with Spec is
-%   not changed.
+%   Order solutions according to Spec. Spec is   a  list of terms, where
+%   each element is one of. The ordering  of solutions of Goal that only
+%   differ in variables that are _not_ shared with Spec is not changed.
 %
 %     - asc(Term)
 %     Order solution according to ascending Term
 %     - desc(Term)
 %     Order solution according to descending Term
+%
+%   This predicate is based on findall/3 and (thus) variables in answers
+%   are _copied_.
 
 order_by(Spec, Goal) :-
     must_be(list, Spec),
diff --git a/man/foreign.doc b/man/foreign.doc
index d27d61b..8792e87 100644
--- a/man/foreign.doc
+++ b/man/foreign.doc
@@ -779,6 +779,10 @@
 Returns non-zero if \arg{term} is a compound term using the list
 constructor.  See also PL_is_list() and PL_skip_list().
 
+    \cfunction{int}{PL_is_dict}{term_t}
+Returns non-zero if \arg{term} is a dict.  See also PL_put_dict()
+and PL_get_dict_key().
+
     \cfunction{int}{PL_is_atomic}{term_t}
 Returns non-zero if \arg{term} is atomic (not a variable or compound).
 
@@ -965,12 +969,19 @@
 If \arg{t} is an atom, the system will look up or create the
 corresponding module and assign an opaque pointer to it over {\em
 module}.
+
 \cfunction{int}{PL_get_arg}{size_t index, term_t +t, term_t -a}
 If \arg{t} is compound and index is between 1 and arity (inclusive),
 assign \arg{a} with a term reference to the argument.
+
 \cfunction{int}{_PL_get_arg}{size_t index, term_t +t, term_t -a}
 Same as PL_get_arg(), but no checking is performed, neither whether \arg{t}
 is actually a term nor whether \arg{index} is a valid argument index.
+
+\cfunction{int}{PL_get_dict_key}{atom_t key, term_t +dict, term_t -value}
+If \arg{dict} is a dict, get the associated value in \arg{value}. Fails
+silently if \arg{key} does not appear in \arg{dict} and with an
+exception if \arg{dict} is not a dict.
 \end{description}
 
 
@@ -1344,6 +1355,18 @@
 Note that \arg{l} can be redefined within a {\tt PL_cons_list} call as
 shown here because operationally its old value is consumed before its
 new value is set.
+
+\cfunction{int}{PL_put_dict}{term_t -h, atom_t tag, size_t len,
+			     const atom_t *keys, term_t values}
+Create a dict from a \arg{tag} and vector of atom-value pairs and put
+the result in \arg{h}.  The dict's key is set by \arg{tag}, which may
+be \const{0} to leave the tag unbound. The \arg{keys} vector is a vector
+of atoms of at least \arg{len} long. The \arg{values} is a term vector
+allocated using PL_new_term_refs() of at least \arg{len} long. This
+function returns \const{TRUE} on success, \const{FALSE} on a resource
+error (leaving a resource error exception in the environment),
+\const{-1} if some key or the \arg{tag} is invalid and \const{-2} if
+there are duplicate keys.
 \end{description}
 
 
@@ -2905,6 +2928,33 @@
 mp_set_memory_functions() in the GMP documentation. The action returns
 \const{FALSE} if there is no GMP support or GMP is already initialised.
 \end{description}
+
+\cfunction{unsigned int}{PL_version}{int key}
+Query version information.  This function may be called before
+PL_initialise().  If the key is unknown the function returns 0.
+See \secref{abi-versions} for a more in-depth discussion on
+binary compatibility.  Defined keys are:
+
+    \begin{description}
+	\termitem{PL_VERSION_SYSTEM}{}
+SWI-Prolog version as $10,000 \times major + 100 \times minor + patch$.
+	\termitem{PL_VERSION_FLI}{}
+Incremented if the foreign interface defined in this chapter changes in
+a way that breaks backward compatibility.
+	\termitem{PL_VERSION_REC}{}
+Incremented if the binary representation of terms as used by
+PL_record_external() and fast_write/2 changes.
+	\termitem{PL_VERSION_QLF}{}
+Incremented if the QLF file format changes.
+	\termitem{PL_VERSION_QLF_LOAD}{}
+Represents the oldest loadable QLF file format version.
+	\termitem{PL_VERSION_VM}{}
+A hash that represents the VM instructions and their arguments.
+	\termitem{PL_VERSION_BUILT_IN}{}
+A hash that represents the names, arities and properties of all
+built-in predicates defined in C.  If this function is called
+before PL_initialise() it returns 0.
+    \end{description}
 \end{description}
 
 \subsection{Querying Prolog}
diff --git a/man/main.doc b/man/main.doc
index 4c3bc22..ddb3368 100644
--- a/man/main.doc
+++ b/man/main.doc
@@ -59,9 +59,9 @@
 
 \newcommand{\vmajor}{8}
 \newcommand{\vminor}{1}
-\newcommand{\vpatch}{29}
+\newcommand{\vpatch}{30}
 \newcommand{\vtag}{}
-\newcommand{\vmonth}{April}
+\newcommand{\vmonth}{May}
 \newcommand{\vyear}{2020}
 
 #ifdef BOOK
diff --git a/man/overview.doc b/man/overview.doc
index 5e7022b..a958cab 100644
--- a/man/overview.doc
+++ b/man/overview.doc
@@ -351,6 +351,10 @@
     \cmdlineoptionitem{--version}{}
 When given as the only option, it summarises the version and the
 architecture identifier.  Also available as \cmdlineoption{-v}.
+
+    \cmdlineoptionitem{--abi_version}{}
+Print a key (string) that represents the binary compatibility on
+a number of aspects.  See \secref{abi-versions}.
 \end{description}
 
 
@@ -1182,6 +1186,11 @@
 
 
 \begin{description}
+    \prologflagitem{abi_version}{dict}{r}
+The flag value is a dict with keys that describe the version of
+the various Application Binary Interface (ABI) components.  See
+\secref{abi-versions} for details.
+
     \prologflagitem{access_level}{atom}{rw}
 This flag defines a normal `user' view (\const{user}, default) or a
 `system' view. In system view all system code is fully accessible as if
@@ -3502,3 +3511,66 @@
 start with a dollar (\chr{\$}) sign.
 
 \input{bit64.tex}
+
+\section{Binary compatibility}			\label{sec:abi-versions}
+
+\index{compatibility,binary}%
+\index{ABI,compatibility}%
+SWI-Prolog first of all attempts to maintain \jargon{source code}
+compatibility between versions. Data and programs can often be
+represented in binary form.  This touches a number of interfaces
+with varying degrees of compatibility.  The relevant version numbers
+and signatures are made available by PL_version(), the
+\cmdlineoption{abi_version} and the Prolog flag
+\prologflag{abi_version}.
+
+\begin{description}
+    \definition{Foreign extensions}
+Dynamically loadable foreign extensions have the usual dependencies on
+the architecture, ABI model of the (C) compiler, dynamic link library
+format, etc. They also depend on the backward compatibility of the PL_*
+API functions provided lib \file{libswipl}.
+
+A compatible API allows distribution of foreign extensions in binary
+form, notably for platforms on which compilation is complicated (e.g.,
+Windows). This compatibility is therefore high on the priority list, but
+must infrequently be compromised.
+
+PL_version(): \const{PL_VERSION_FLI}, \prologflag{abi_version} key:
+\const{foreign_interface}
+
+    \definition{Binary terms}
+Terms may be represented in binary format using PL_record_external() and
+fast_write/2. As these formats are used for storing binary terms in
+databases or communicate terms between Prolog processes in binary form,
+great care is taken to maintain compatibility.
+
+PL_version(): \const{PL_VERSION_REC}, \prologflag{abi_version} key:
+\const{record}
+
+    \definition{QLF files}
+QLF files (see qcompile/1) are binary representation of	Prolog file or
+module. They represent clauses as sequences of \jargon{virtual machine}
+(VM) instructions. Their compatibility relies on the QLF file format and
+the ABI of the VM.  Some care is taken to maintain compatibility.
+
+PL_version(): \const{PL_VERSION_QLF}, \const{PL_VERSION_QLF_LOAD} and
+\const{PL_VERSION_VM}, \prologflag{abi_version} key: \const{qlf},
+\const{qlf_min_load}, \const{vmi}
+
+    \definition{Saved states}
+Saved states (see \cmdlineoption{-c} and qsave_program/2) is a zip file
+that contains the entire Prolog database using the same representation
+as QLF files. A saved state may contain additional resources, such as
+foreign extensions, data files, etc.  In addition to the dependency
+concerns of QLF files, built-in and core library predicates may call
+\emph{internal} foreign predicates.  The interface between the public
+built-ins and internal foreign predicates changes frequently.  Patch
+level releases in the \emph{stable branch} will as much as possible
+maintain compatibility.
+
+The relevant ABI version keys are the same as for QLF files with one
+addition: PL_version(): \const{PL_VERSION_BUILT_IN}, \prologflag{abi_version}
+key: \const{built_in}
+\end{description}
+
diff --git a/man/tabling.doc b/man/tabling.doc
index bcfe676..de0eca1 100644
--- a/man/tabling.doc
+++ b/man/tabling.doc
@@ -840,7 +840,7 @@
 \subsection{Restraint subgoal size}
 \label{sec:tabling-restraint-subgoal}
 
-Using the \term{abstract_subgoal}{Size} attribute, a tabled subgoal that
+Using the \term{subgoal_abstract}{Size} attribute, a tabled subgoal that
 that is too large is \jargon{abstracted} by replacing compound subterms
 of the goal with variables. In a nutshell, a goal
 \term{p}{s(s(s(s(s(0)))))} is converted into the semantically equivalent
diff --git a/packages/clib/uri.c b/packages/clib/uri.c
index b53d722..0edf58d 100644
--- a/packages/clib/uri.c
+++ b/packages/clib/uri.c
@@ -917,6 +917,10 @@
 
 
 /** uri_query_components(+QueryString, -ValueList) is det.
+
+(*) We must malloc() because  the   individual  query components use the
+text ring buffer, so with more query   components then the ring size the
+original text gets corrupted.
 */
 
 static foreign_t
@@ -924,8 +928,10 @@
 { pl_wchar_t *s;
   size_t len;
 
-  if ( PL_get_wchars(string, &len, &s, CVT_ATOM|CVT_STRING|CVT_LIST) )
-  { return  unify_query_string_components(list, len, s);
+  if ( PL_get_wchars(string, &len, &s, CVT_ATOM|CVT_STRING|CVT_LIST|BUF_MALLOC) )
+  { int rc = unify_query_string_components(list, len, s);
+    PL_free(s);				/* See (*) */
+    return rc;
   } else if ( PL_is_list(list) )
   { term_t tail = PL_copy_term_ref(list);
     term_t head = PL_new_term_ref();
diff --git a/packages/http/CMakeLists.txt b/packages/http/CMakeLists.txt
index 9b5694f..88e1ba8 100644
--- a/packages/http/CMakeLists.txt
+++ b/packages/http/CMakeLists.txt
@@ -11,6 +11,8 @@
 	      ${JQUERYFILE}
 	      PATHS /usr/share/javascript/jquery
 	      NO_DEFAULT_PATH)
+    # Deal with snap creation
+    string(REPLACE "-sdk/current/" "/current/" JQUERYDIR "${JQUERYDIR}")
   endif()
 
   if(JQUERYDIR AND EXISTS ${JQUERYDIR}/${JQUERYFILE})
diff --git a/packages/jpl/CMakeLists.txt b/packages/jpl/CMakeLists.txt
index 53e28bc..0292d15 100644
--- a/packages/jpl/CMakeLists.txt
+++ b/packages/jpl/CMakeLists.txt
@@ -1,6 +1,7 @@
 cmake_minimum_required(VERSION 3.5)
 project(swipl-jpl)
 
+set(JPL_VERSION 7.6.0)
 
 #message(${CMAKE_CURRENT_SOURCE_DIR}) # <project>/packages/jpl
 #message(${PROJECT_SOURCE_DIR})  # <project>/packages/jpl
diff --git a/packages/jpl/docs/DeploymentLinux.md b/packages/jpl/docs/DeploymentLinux.md
index 768b1e8..c478e54 100644
--- a/packages/jpl/docs/DeploymentLinux.md
+++ b/packages/jpl/docs/DeploymentLinux.md
@@ -1,28 +1,77 @@
 # Deploying for users - on Linux
 
-Recall that to use JPL under linux one must have the following in place:
+To use JPL under Linux one must have the following in place (here showing the locations under Linux Mint distribution under packages `swi-prolog-nox` and `swi-prolog-java`):
 
-* C Native JPL Library `libjpl.so`, generally found at `/usr/lib/swi-prolog/lib/amd64/libjpl.so`
-* Java API Jar file `jpl.jar` in the Java `CLASSPATH`, generally accessible from `/usr/share/java/jpl.jar`.
-* Prolog API as an SWI source module `jpl.pl` at `$SWI_HOME_DIR/library`, generally accessible from `/usr/lib/swi-prolog/library/jpl.pl`
-
-JPL is **generally distributed with official Linux**. For example, in Ubuntu-based systems, JPL is provided via package `swi-prolog-java`. That package includes the C library `libjpl.so`, the Java API `jpl.jar`, the Prolog module `jpl.pl` as well as all documentation associated.
+* A SWIPL install containing the core SWI system, which includes:
+   * A SWIPL home directory (`SWI_HOME_DIR`), located at `/usr/lib/swi-prolog/` and containing the whole SWIPL core system, including a booting `.prc` file (`$SWI_HOME_DIR/boot64.prc`).
+       * The "home" of SWIPL can be queried via [`current_prolog_flag(home, H)`](https://www.swi-prolog.org/pldoc/man?predicate=current_prolog_flag/2)
+   * The C Native core SWIPL library `/usr/lib/libswipl.so`.
+   * The set of C Native SWIPL libraries for each package (files `.so`), located in `/usr/lib/swi-prolog/lib/amd64/`
+* The JPL package, which includes:
+   * The C Native JPL Library `libjpl.so` at `$SWI_HOME_DIR/lib/amd64/libjpl.so`.
+   * The Java API JAR file `jpl.jar` in `$SWI_HOME_DIR/lib/jpl.jar`.
+   * The Prolog API as an SWIPL source module `jpl.pl` at `$SWI_HOME_DIR/library`.
+   
+## Which SWIPL version to (not) use?
+  
+JPL is **generally distributed with official Linux**. For example, in Ubuntu-based systems, JPL is provided via package `swi-prolog-java`. That package includes the C library `libjpl.so`, the Java API `jpl.jar`, the Prolog module `jpl.pl` as well as all associated documentation.
 
 However, the **official packages are often out-of-date**. For Debian-based systems (Debian, Ubuntu, Mint, ...) you can get the latest stable and development versions via [this PPAs](http://www.swi-prolog.org/build/PPA.txt) provided directly by SWI-Prolog.
 
-To use JPL, use either SWI stable version 7.6.4 (available in standard Linux repos) or compile and install 8.1.x from SWI-devel repo. 
-* **Note:** The official stable SWI 8.0.x versions (as of Jan 2020) have issues with the `libswipl.so/dll/dylib` library and makes JPL crash; see [issue](https://github.com/ssardina-research/packages-jpl/issues/21). It has been fixed in the git repo but will only show up with versions 8.1.x.
+Use either SWIPL stable version 7.6.4 (available in standard Linux repos) or compile & install 8.1.x from [SWI-devel repo](https://github.com/SWI-Prolog/swipl-devel) using CMAKE.
+   * **Note:** The official stable SWI 8.0.x versions (as of Jan 2020) have issues with the `libswipl.so/dll/dylib` library and makes JPL crash; see [issue](https://github.com/ssardina-research/packages-jpl/issues/21). It has been fixed in the git repo but will only show up with versions 8.1.x.
+   
+## Configuring environment variables
 
-Finally, to be **able to use JPL** you may need to make sure that:
+When embeeding SWIPL into a Java, one may needs to "tell" the Java application the right information, via environment variables, so that SWIPL is initialized properly and can find all resources.
 
-* Extend environment library `LD_PRELOAD` for system to pre-load `libswipl.so`: 
-    * `export LD_PRELOAD=libswipl.so:$LD_PRELOAD`
-    * Check [this post](https://answers.ros.org/question/132411/unable-to-load-existing-owl-in-semantic-map-editor/) and [this one](https://blog.cryptomilk.org/2014/07/21/what-is-preloading/) about library preloading.
-    * Also, check [this](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=690734) and [this](https://github.com/yuce/pyswip/issues/10) posts.
-* Extend environment variable `LD_LIBRARY_PATH`  to point to the directory where `libjpl.so` is located:
-    * `export LD_LIBRARY_PATH=/usr/lib/swi-prolog/lib/amd64/`
-* Make sure `jpl.jar` is in your Java CLASSPATH. This is generally automatically done if environment variable `SWI_HOME_DIR` is correctly set to `/usr/lib/swi-prolog/`.
+In general, if the Java application will use the default executable of the system (i.e., the one that runs when executing `swipl`), then you only need to set-up `CLASSPATH` to include `jpl.jar` and possibly `LD_PRELOAD` to point to your active SWIPL `libswipl.so` library to avoid run-time errors. The executable has a pointer to the right information to initialize; see [here](https://www.swi-prolog.org/FAQ/FindResources.html).
 
-To install JPL from scratch (e.g., to compiling it in order to develop it further) please refer to the [Developing JPL](Developing-JPL) guide.
+However, if your Java application will use an SWIPL & JPL version that is _not_ the exectuable default.
+
+### Using stable distribution versions of SWIPL
+
+If the **Linux distribution install** of SWIPL & JPL is not the executable default but the one to be used, set-up the following environment variables:
+
+      SWI_HOME_DIR=/usr/lib/swi-prolog/   # if default binary not pointing to this version
+      LD_LIBRARY_PATH=/usr/lib/swi-prolog/lib/amd64/     # to find all .so, including libjpl.so
+      CLASSPATH=/usr/lib/swi-prolog/lib/jpl.jar
+      LD_PRELOAD=/usr/lib/libswipl.so  # see below for explanation
+
+or in one line (for IDE Run configurations, for example):
+
+    CLASSPATH=/usr/lib/swi-prolog/lib/jpl.jar;LD_LIBRARY_PATH=/usr/lib/swi-prolog/lib/amd64/;LD_PRELOAD=/usr/lib/libswipl.so;SWI_HOME_DIR=/usr/lib/swi-prolog/
+
+Notice that, in this case, library `libswipl.so` will be found automatically, as it is located in the standard system-wide library dir `/usr/lib`.
+
+### Using locally compiled and installed version of SWIPL
+
+Alternatively, if you have **compiled and installed** an SWIPL system, say, under directory `/usr/local/swipl-git/`, then the SWIPL home will be `/usr/local/swipl-git/lib/swipl/`, the executable binary will be `/usr/local/swipl-git/lib/swipl/bin/x86_64-linux/swipl` and the environment variables should be set-up as follows:
+
+      SWI_HOME_DIR=/usr/local/swipl-git/lib/swipl/  # if binary exec not pointing to this SWIPL
+      LD_LIBRARY_PATH=/usr/local/swipl-git/lib/swipl/lib/x86_64-linux/     # to find all .so, including libjpl.so
+      CLASSPATH=/usr/local/swipl-git/lib/swipl/lib/jpl.jar
+      LD_PRELOAD=/usr/local/swipl-git/lib/swipl/lib/x86_64-linux/libswipl.so  # see below for explanation
+
+or in one line (for IDE Run configurations, for example):
+
+    CLASSPATH=/usr/local/swipl-git/lib/swipl/lib/jpl.jar;LD_LIBRARY_PATH=/usr/local/swipl-git/lib/swipl/lib/x86_64-linux/;LD_PRELOAD=/usr/local/swipl-git/lib/swipl/lib/x86_64-linux/libswipl.so;SWI_HOME_DIR=/usr/local/swipl-git/lib/swipl/
+
+## Using the development tree of SWI+JPL that is yet not installed?
+
+If you want to run your application against a development tree of SWIPL & JPL that is not yet installed, then refer to [Developing JPL](TutorialDeveloping.md) guide.
+
 
 ## Troubleshooting
+
+### Pre-loading `libswipl.so`
+
+The [libray preloading](https://blog.cryptomilk.org/2014/07/21/what-is-preloading/) of `libswipl.so` is often necessary to avoid the following run-time error (check [this](https://answers.ros.org/question/132411/unable-to-load-existing-owl-in-semantic-map-editor/), [this](https://github.com/yuce/pyswip/issues/10) and [this](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=690734) posts):
+
+      ERROR: /usr/lib/swi-prolog/library/process.pl:53:
+         /usr/lib/swi-prolog/library/process.pl:53: Initialization goal raised exception:
+         '$open_shared_object'/3: /usr/lib/swi-prolog/lib/amd64/process.so: undefined symbol: Sfilefunctions
+
+###  [FATAL ERROR: Could not find system resources].
+
+It is not finding the correct `libswipl.so`. 
diff --git a/packages/jpl/docs/JavaApiOverview.md b/packages/jpl/docs/JavaApiOverview.md
index 17d51bb..b9c00e3 100644
--- a/packages/jpl/docs/JavaApiOverview.md
+++ b/packages/jpl/docs/JavaApiOverview.md
@@ -98,7 +98,7 @@
 
 `Term` instances are never changed by any activity within the Prolog engine: indeed; it doesn't know of their existence.
 
-The `Term` class is abstract, so it cannot be directly instantiated; to create a Term, create an instance of one of its subclasses.
+The `Term` class is abstract, so it cannot be directly instantiated; to create a Term, create an instance of one of its subclasses, which are the ones accounting for the various [data types in SWI-Prolog](https://www.swi-prolog.org/datatypes.html).
 
 ### Atoms 
 
@@ -235,30 +235,59 @@
 public Term arg0(int i);
 ```
 
-#### Lists as compound terms
-
-As usual in Prolog, lists are just compound terms with function `[|]` and two arguments: the _head_ element and the _tail_ list. For example:
-
-```prolog
-?- A = [1,2,3,4], A =.. [X|Y].
-A = [1, 2, 3, 4],
-X = '[|]',
-Y = [1, [2, 3, 4]].
-````
-
-We can build list compound terms in two ways. First, by converting an Array of terms (`Term[]`) into a Compound (list) term using utility `Util.termArrayToList`:
-
-```java
-Term list = Util.termArrayToList(new Term[] 
-        { new Integer(1), new Variable("B"), new Atom("c") });
+### Lists 
+
+In SWI-Prolog a list is either:
+
+* An empty list `[]`. In JPL, the empty list is the constant `JPL.LIST_NIL` and is a final object of class `Atom`. (Observe on the SWI side, from SWI-Prolog 7+, the empty list is not an atom but a reserved word.)
+* A `Compound` term with functor `[|]` and two arguments where the second one is itself a list. On the Prolog side:
+
+        ?- A = [1,2,3,4], A =.. [X|Y].
+        A = [1, 2, 3, 4],
+        X = '[|]',
+        Y = [1, [2, 3, 4]].
+
+While one can build non-empty lists by creating  `Compound` terms, it can become really cumbersome, as the second argument always has to be another lits.
+
+So, class `Term` provides several _static_ methods to conveniently build non-empty lists, namely:
+ 
+```java 
+public static Term textToTerm(String text)
+public static Term termArrayToList(Term[] terms) 
+public static Term stringArrayToList(String[] a)
+public static Term intArrayToList(int[] a) 
+public static Term intArrayArrayToList(int[][] a)
+```
+
+Method `textToTerm(String text)` can actually build _any_ term form its String representation, including list terms:
+
+```java
+Term list = Util.textToTerm("[1, B, [p(g), g(1)], c]");
+```
+
+A second tool is `termArrayToList(Term[])`, which builds a list from an Array of Terms (`Term[]`) (the corresponding functors `[|]` are added automatically). For example:
+
+```java
+Term list = Term.termArrayToList(new Term[]     // list [1, B, hello]
+        { new Integer(1), new Variable("B"), new Atom("hello") });
 ```        
 
-The second way is by converting a String representing a list into a term via `Util.textToTerm`:
-
-```java
-Term list = Util.textToTerm("[1, B, c]");
-```
-
+Finally, one can build specific data-type lists using:
+* `stringArrayToList(String[] a)`: builds a list of atoms from an Array of Strings;
+* `intArrayToList(int[] a)`: builds a list of integers;
+* `intArrayArrayToList(int[][] a)`: builds a list of lists of integers.
+
+On the other direction, the following methods in `Term` class transform a list Term into another Java type:
+
+```java
+public static String toString(Term t)       
+public static Term[] listToTermArray(Term t) 
+public static String[] atomListToStringArray(Term t)          	
+```
+
+When it comes to non-empty, compound, list terms, the behavior of `toString()` will depend on boolean `JPL.LIST_TOSTRING_TEXTUAL`:
+* If True, lists will be represented as String in the usual Prolog textual representation `[e1, e2, e3, ...., en]`. Note a space wil be added after each comma always.
+* If False, lists will be represented in infix notation with the list pair functor `[|]`, e.g.,  `[|](1, [|](2, [|](3, '[]')))` for list `[1, 2, 3]`.
 
 
 
@@ -348,6 +377,14 @@
 ```
 
 If the query has no solutions, this method returns `null`; otherwise, a non-null return indicates success. If the query is ground (i.e. contains no variables), the returned map will be empty (i.e. will contain no bindings).
+
+If the query is non-ground (i.e., it includes variables), then  bindings are retrieved by name, e.g.:
+
+```
+Map m = org.jpl7.Query.oneSolution("statistics(heap, X)");
+long heapsize = m.get("X");
+```
+
 
 ### Obtaining all solutions 
 
@@ -457,15 +494,6 @@
 
 ## Gotchas
 
-### Variables are named
-
-Instances of `org.jpl7.Variable` have names, and bindings are retrieved by name, e.g.
-
-```
-Map m = org.jpl7.Query.oneSolution("statistics(heap, X)");
-long heapsize = m.get("X");
-```
-
 ### Argument numbering
 
 The `Term[]` args of a `Compound` are indexed (like all Java arrays) from zero, whereas in Prolog the args of a structure are conventionally numbered from one.
diff --git a/packages/jpl/docs/ReleaseNotes.md b/packages/jpl/docs/ReleaseNotes.md
index 620ca28..4c60e4c 100644
--- a/packages/jpl/docs/ReleaseNotes.md
+++ b/packages/jpl/docs/ReleaseNotes.md
@@ -4,7 +4,11 @@
 
 * Version [JPL 7.x](https://jpl7.org/) uses SWI Prolog V7 and has modernise JPL's APIs significantly.
 
-    * Current version []7.4.0](https://jpl7.org/ReleaseNotes740.jsp) works with SWI versions V7.4.x to V7.7.x. It has a new implemention of JRefs as blobs to address Java objects from Prolog.
+    * Version [7.6.0](https://jpl7.org/ReleaseNotes760.jsp) works with SWI versions V8.1.x+. It adds Rationals as a data type and has several term methods refactored into class Term.
+        
+    * Version [7.5.0](https://jpl7.org/ReleaseNotes750.jsp) works with SWI versions V7.4.x to V7.7.x. It has a new implemention of iterators ans solution methods in Queries and better handling of quoted terms.
+
+    * Version [7.4.0](https://jpl7.org/ReleaseNotes740.jsp) works with SWI versions V7.4.x to V7.7.x. It has a new implemention of JRefs as blobs to address Java objects from Prolog.
     
 * Versions [JPL 3.x,y](http://www.swi-prolog.org/packages/jpl/) implemented many changes and worked with SWI V5.2.0 or later (it used multi-threading FLI calls not available in older versions) and Java 2 runtime.  It was tested with Microsoft Visual C/C++ 5 under Windows NT 4.0 (SP6a). 
 
diff --git a/packages/jpl/docs/ReleaseNotes750.md b/packages/jpl/docs/ReleaseNotes750.md
index a379fa9..8d0d8bb 100644
--- a/packages/jpl/docs/ReleaseNotes750.md
+++ b/packages/jpl/docs/ReleaseNotes750.md
@@ -15,8 +15,8 @@
 ## Versions up to 7.4
 
 - Complete overhawl from version 3.x
-- Check release notes for [7.4.0](https://jpl7.org/ReleaseNotes740.jsp).
-- Check release notes for [7.0.1](https://jpl7.org/ReleaseNotes701.jsp).
+- Check release notes for [7.4.0](ReleaseNotes740).
+- Check release notes for [7.0.1](ReleaseNotes701).
 
 
 
diff --git a/packages/jpl/docs/ReleaseNotes760.md b/packages/jpl/docs/ReleaseNotes760.md
new file mode 100644
index 0000000..19f5fe1
--- /dev/null
+++ b/packages/jpl/docs/ReleaseNotes760.md
@@ -0,0 +1,25 @@
+# Release Notes - 7.6.0
+
+- New `org.jpl7.Rational` type to handle [SWI rationals](https://www.swi-prolog.org/pldoc/man?section=rational).
+- Refactored several methods dealing with JPL terms, from `org.jpl7.Util` to `org.jpl7.Term`:
+    - `Term textToTerm(String text)`
+    - `String[] atomListToStringArray(Term t)` 
+    - `static Term intArrayArrayToList(int[][] a)`
+    - `Term intArrayToList(int[] a)`
+    - `boolean isList(Term term)`
+    - `int listToLength(Term term)`
+    - `Term[] listToTermArray(Term t)`
+    - `Term stringArrayToList(String[] a)`
+    - `Term termArrayToList(Term[] terms)`
+- Added a textual mode for `Term.toString()` to convert non-empty lists in Prolog textual style `[e2, e2, ..., en]` instead of the pre-fix functor-based style `'[|]'(e1, '[|]'(e2, '[|]'(...,'[|]'(en,'[]')..)`.
+    - This textual mode is used when `JPL.LIST_TOSTRING_TEXTUAL` is True (default is True); otherwise default pre-fix style is used.
+- Added specific section for lists in documentation.
+        
+## Internal
+
+- More direct and simpler `Term.textToTerm(String text)` without using 
+`getSolutionWithVarNames` and by renaming anonymous Variable terms to give them the textual name.
+- Migrated unit testing from JUnit3 to JUnit4. 
+    - Refactored the unit testing test suite; all test files subclass of `org.jpl7.java.test.junit.JPLTest`.
+- Modified init arguments and CMAKE configuration for SWI embeded engine unit testing to fix issue with engine not loading libraries. No more use of `libswipl.dll` as first argument; all packages available in unit tetsing now.
+- Added some static versions of instance methods in class `Term`.
\ No newline at end of file
diff --git a/packages/jpl/docs/TutorialDeveloping.md b/packages/jpl/docs/TutorialDeveloping.md
index ac3e218..bec0b93 100644
--- a/packages/jpl/docs/TutorialDeveloping.md
+++ b/packages/jpl/docs/TutorialDeveloping.md
@@ -178,3 +178,55 @@
 [ssardina@Thinkpad-X1 build]$ 
 ```
 
+
+## Using non-installed development tree of SWIPL & JPL in Java application
+
+Suppose you are developing JPL as above, in this case at `/home/ssardina/git/soft/prolog/swipl-devel.git`
+
+However, you have a Java application X  besides JPL itself and want to test that application under the current SWIPL+JPL development. There are several things that need to be set-up for your application to correctly access the SWIPL+JPL under development. 
+
+First, we need to **setup various environment variables** so that the correct SWIPL+JPL is initialized and used:
+
+	SWI_HOME_DIR=/home/ssardina/git/soft/prolog/swipl-devel.git/build/home
+	SWI_EXEC_FILE=/home/ssardina/git/soft/prolog/swipl-devel.git/build/src/swipl
+	SWIPL_BOOT_FILE=/home/ssardina/git/soft/prolog/swipl-devel.git/build/home/boot.prc
+	LD_LIBRARY_PATH=/home/ssardina/git/soft/prolog/swipl-devel.git/build/packages/jpl
+	LD_PRELOAD=/home/ssardina/git/soft/prolog/swipl-devel.git/build/src/libswipl.so
+	CLASSPATH=/home/ssardina/git/soft/prolog/swipl-devel.git/packages/jpl/out/artifacts/jpl_jar/
+
+The `CLASSPATH` needs to point to the `jpl.jar` file that needs to be us used in case `jpl.pl` requires it (to access JAVA from Prolog).
+
+In one line (to copy into the usual Run-configuration of IDE):
+
+	LD_LIBRARY_PATH=/home/ssardina/git/soft/prolog/swipl-devel.git/build/packages/jpl;SWI_HOME_DIR=/home/ssardina/git/soft/prolog/swipl-devel.git/build/home;SWIPL_BOOT_FILE=/home/ssardina/git/soft/prolog/swipl-devel.git/build/home/boot.prc;CLASSPATH=/home/ssardina/git/soft/prolog/swipl-devel.git/packages/jpl/out/artifacts/jpl_jar/;LD_PRELOAD=/home/ssardina/git/soft/prolog/swipl-devel.git/build/src/libswipl.so;SWI_EXEC_FILE=/home/ssardina/git/soft/prolog/swipl-devel.git/build/src/swipl
+
+
+Second, we need to tell our applicatoin X development to use the development JPL Java, and NOT any other `jpl.jar`  that may be in the system (e.g., due to a distribution installation). In our example, under IntelliJ, we define a library `jpl` in the project of the application pointing to directory:
+
+	/home/ssardina/git/soft/prolog/swipl-devel.git/packages/jpl/out/production/jpl
+
+where all the classes for the currente devel JPL are located (if we are using IntelliJ). Then provded that library to use for your application/module for compilation and runtime.
+
+Third, and finally, you need to explicitly initialize the SWIPL JPL engine in your Java application to with the right home, executable, and most importantly `-F swipl` so that the initialization file `swipl.rc` in charge of setting up all the search paths:
+
+```java
+String init_swi_config =
+	String.format("%s -x %s -F swipl --home=%s -g true -q",
+		System.getenv("SWI_EXEC_FILE"), 	# irrelevant for Windows
+		System.getenv("SWIPL_BOOT_FILE"), 	
+		System.getenv("SWI_HOME_DIR"));
+JPL.setDefaultInitArgs(init_swi_config.split("\\s+"));	# initialize SWIPL engine
+JPL.init()
+```
+
+Because SWIPL tries to "guess" the location of the binary and boot file, in most cases, it also suffies to do:
+
+```java
+String init_swi_config =
+	String.format("dummy --home=%s -g true -q",
+		System.getenv("SWI_HOME_DIR"));
+JPL.setDefaultInitArgs(init_swi_config.split("\\s+"));	# initialize SWIPL engine
+```
+
+
+
diff --git a/packages/jpl/docs/TutorialGettingStarted.md b/packages/jpl/docs/TutorialGettingStarted.md
index 63403b5..65ba1f2 100644
--- a/packages/jpl/docs/TutorialGettingStarted.md
+++ b/packages/jpl/docs/TutorialGettingStarted.md
@@ -14,9 +14,47 @@
 You may wish to load this database into an interactive Prolog session to experiment with the predicates in this database before experimenting with JPL.
 
 
-## Initializing The Prolog engine
+## Initializing the Prolog engine
 
-Although the `org.jpl7.JPL` class provides a number of methods for initializing the Prolog engine from within Java, their use is not usually necessary: Prolog will be automatically initialised with default parameters at the first attempt to use it.
+Although the `org.jpl7.JPL` class provides a number of methods for initializing the Prolog engine from within Java, their use is not usually necessary: Prolog will be _automatically initialised_ with default parameters at the first attempt to use it.
+
+By default, the SWIPL install accessible via the _default executable_ (i.e., the one that runs when one types `swipl`) will be initialized. If one, instead, _requires to use another install_ of SWIPL+JPL (e.g., the one under development or an alternative one installed in `/usr/local`), then we need to set-up a few variables to make sure the intended SWIPL resources are found. For example, suppose we intend that our Java-based application uses the SWIPL framework locally installed in `/usr/local/swipl/`. Then:
+
+	SWI_HOME_DIR=/usr/local/swipl-git/lib/swipl/	# root of SWIPL install
+	LD_LIBRARY_PATH=/usr/local/swipl-git/lib/swipl/lib/x86_64-linux/ # all .so nativ libs
+	LD_PRELOAD=/usr/local/swipl-git/lib/swipl/lib/x86_64-linux/libswipl.so
+	CLASSPATH=/usr/local/swipl-git/lib/swipl/lib/jpl.jar
+
+From here, [SWIPL will try to find/guess the resources](https://www.swi-prolog.org/FAQ/FindResources.html) and set-up the engine correctly. 
+
+Note also that you need to tell your development environment (e.g., IntelliJ or ECLIPSE) to use the correct `jpl.jar` (rather than one coming with the default active SWIPL system) or even the place where the JPL compiled classes are located if you intend to use a development (but uninstall) version of JPL. 
+
+Sometimes one needs to _explicitly initialize_ the engine (before a query triggers defaul initialization); for example, if one wants to use an SWIPL & JPL under a development tree that is not yet installed. Assuming that development is happening under `/home/ssardina/git/soft/prolog/swipl-devel.git`, the following code template will perform a comprehensive, and quiety, initialization (before any query is performed) (see [CLI options](https://www.swi-prolog.org/pldoc/man?section=cmdline) available):
+
+```java
+String init_swi_config =
+	String.format("%s -x %s -F swipl --home=%s -g true -q",
+		System.getenv("SWI_EXEC_FILE"), 	# irrelevant for Windows
+		System.getenv("SWIPL_BOOT_FILE"), 	
+		System.getenv("SWI_HOME_DIR"));
+JPL.setDefaultInitArgs(init_swi_config.split("\\s+"));	# initialize SWIPL engine
+JPL.init()
+```
+
+The option `-F swipl` will cause the script `$SWI_HOME_DIR/swipl.rc` to be loaded which will set-up all the search paths relative to the install. The above code will require the following environment variables:
+
+	SWI_HOME_DIR=/home/ssardina/git/soft/prolog/swipl-devel.git/build/home
+	SWI_EXEC_FILE=/home/ssardina/git/soft/prolog/swipl-devel.git/build/src/swipl
+	SWIPL_BOOT_FILE=/home/ssardina/git/soft/prolog/swipl-devel.git/build/home/boot.prc
+	
+Because SWIPL tries to "guess" the location of the binary and boot file, in most cases, it also suffies to do:
+
+```java
+String init_swi_config =
+	String.format("dummy --home=%s -g true -q",
+		System.getenv("SWI_HOME_DIR"));
+JPL.setDefaultInitArgs(init_swi_config.split("\\s+"));	# initialize SWIPL engine
+```
 
 
 
diff --git a/packages/jpl/docs/TutorialMultithreaded.md b/packages/jpl/docs/TutorialMultithreaded.md
index 2280e62..a2c8205 100644
--- a/packages/jpl/docs/TutorialMultithreaded.md
+++ b/packages/jpl/docs/TutorialMultithreaded.md
@@ -72,7 +72,7 @@
      // process solution...
  }
  while (query1.hasMoreSolutions()) { // finish processing query1
-     Map<String, Term> solution = query2.nextSolution();
+     Map<String, Term> solution = query1.nextSolution();
      // process solution...
  }
 ```
@@ -149,6 +149,6 @@
 
 [Queries from multi-threaded applications](https://jpl7.org/JavaApiOverview#queries-from-multi-threaded-applications)
 
-as well in this related issue at Github: https://github.com/SWI-Prolog/packages-jpl/issues/15
+as well in this related [issue #15](https://github.com/SWI-Prolog/packages-jpl/issues/15) at Github: 
 
 
diff --git a/packages/jpl/docs/index.md b/packages/jpl/docs/index.md
index d147566..e184084 100644
--- a/packages/jpl/docs/index.md
+++ b/packages/jpl/docs/index.md
@@ -22,6 +22,14 @@
 * minimum impact deployability: runtime support for Prolog+Java apps must be a position-independent, self-sufficient filestore tree, requiring no changes to registries, system libraries, system configuration files etc;
 * minimum dependency deployability: as with JVMs, the Prolog+Java runtime support must depend upon nothing which cannot be taken for granted in healthy OS installations; and
 * minimum vulnerability deployability: the Prolog+Java runtime support must be immune to legitimate variations in its environment (PATH settings, other applications and libraries including other Prolog+Java apps, etc.).
+
+### Historical perspective
+
+JPL was originally dreamed to be independent of Prolog implementation, mapping only the classic Prolog term model to and from Java, and its Java-side implementation deliberately resisted adoption of post Java 1.4 features (some nice, but none irresistible), thereby maintaining compatibility with (now very) old JVMs which some deployment environments might be stuck with.
+
+Innovations in SWI Prolog 7 prompted a JPL overhaul (from 3.0.3 to 7.0.1) which changed the public API and warranted a rebrand (as "JPL7", in a nod to SWIPL7).
+
+(Summary taken from discussion in [this issue](https://github.com/SWI-Prolog/packages-jpl/issues/46).)
 
 
 ## About this page
diff --git a/packages/jpl/examples/java/Test/Test.java b/packages/jpl/examples/java/Test/Test.java
index b4e87f0..d18fedd 100644
--- a/packages/jpl/examples/java/Test/Test.java
+++ b/packages/jpl/examples/java/Test/Test.java
@@ -178,7 +178,7 @@
 		Term Y = solutions[0].get("Y");
 		if (X != Y) {
 			System.out.println(t7 + " failed:");
-			System.out.println(Util.toString(solutions[0]));
+			System.out.println(Util.subsToString(solutions[0]));
 			System.out.println("\tThe variables to which X and Y are bound in the first solution should be identical.");
 			// System.exit(1);
 		}
@@ -186,13 +186,13 @@
 		Y = solutions[1].get("Y");
 		if (X == Y) {
 			System.out.println(t7 + " failed:");
-			System.out.println(Util.toString(solutions[1]));
+			System.out.println(Util.subsToString(solutions[1]));
 			System.out.println("\tThe variables to which X and Y are bound in the second solution should be distinct.");
 			// System.exit(1);
 		}
 		if (X.equals(Y)) {
 			System.out.println(t7 + " failed:");
-			System.out.println(Util.toString(solutions[1]));
+			System.out.println(Util.subsToString(solutions[1]));
 			System.out.println("\tThe variables to which X and Y are bound in the second solution should not be \"equal\".");
 			// System.exit(1);
 		}
@@ -215,7 +215,7 @@
 	}
 
 	// corresponds with Prolog List: [a-a,a-b]
-	static Term test_9_solution = Util.termArrayToList(new Term[] { new Compound("-", new Term[] { a, a }), new Compound("-", new Term[] { a, b }) });
+	static Term test_9_solution = Term.termArrayToList(new Term[] { new Compound("-", new Term[] { a, a }), new Compound("-", new Term[] { a, b }) });
 
 	static void test_9() {
 		System.out.print("test 9...");
diff --git a/packages/jpl/jpl.pl b/packages/jpl/jpl.pl
index ad4aecd..febc5e0 100644
--- a/packages/jpl/jpl.pl
+++ b/packages/jpl/jpl.pl
@@ -1218,7 +1218,7 @@
 %
 %  ==
 %  ?- jpl_pl_lib_version(V).
-%  V = '7.4.0-alpha'.
+%  V = '7.6.0-alpha'.
 %  ==
 
 jpl_pl_lib_version(VersionString) :-
@@ -1240,7 +1240,7 @@
 %  Status = alpha.
 %  ==
 
-jpl_pl_lib_version(7, 4, 0, alpha).  % jref as blob
+jpl_pl_lib_version(7, 6, 0, alpha).  % jref as blob
 
 %! jpl_c_lib_version(-Version)
 %
diff --git a/packages/jpl/src/c/jpl.c b/packages/jpl/src/c/jpl.c
index 74a0a08..53bddee 100644
--- a/packages/jpl/src/c/jpl.c
+++ b/packages/jpl/src/c/jpl.c
@@ -55,9 +55,9 @@
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 /* update this to distinguish releases of this C library: */
-#define JPL_C_LIB_VERSION        "7.4.0-alpha"
+#define JPL_C_LIB_VERSION        "7.6.0-alpha"
 #define JPL_C_LIB_VERSION_MAJOR  7
-#define JPL_C_LIB_VERSION_MINOR  4
+#define JPL_C_LIB_VERSION_MINOR  6
 #define JPL_C_LIB_VERSION_PATCH  0
 #define JPL_C_LIB_VERSION_STATUS "alpha"
 
diff --git a/packages/jpl/src/java/CMakeLists.txt b/packages/jpl/src/java/CMakeLists.txt
index 66f729b..fb87284 100644
--- a/packages/jpl/src/java/CMakeLists.txt
+++ b/packages/jpl/src/java/CMakeLists.txt
@@ -89,9 +89,12 @@
   set(CMAKE_JAVA_COMPILE_FLAGS)
 endif()
 
+
 add_jar(jpl_jar
 	SOURCES ${CLS} ${FLI}
-	OUTPUT_NAME jpl)
+	OUTPUT_NAME jpl
+	MANIFEST META-INF/MANIFEST.MF
+	VERSION ${JPL_VERSION}) # VERSION creates jar with the -<version>jar format and a symblic to it.
 
 if(JUNIT_JAR)
 add_jar(jpltest
diff --git a/packages/jpl/src/java/META-INF/MANIFEST.MF b/packages/jpl/src/java/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..5627584
--- /dev/null
+++ b/packages/jpl/src/java/META-INF/MANIFEST.MF
@@ -0,0 +1,4 @@
+Name: org.jpl7
+Implementation-Title: JPL
+Implementation-Version: 7.6.0
+Implementation-Vendor: SWI-Prolog
diff --git a/packages/jpl/src/java/org/jpl7/Atom.java b/packages/jpl/src/java/org/jpl7/Atom.java
index 17bcbca..2656df9 100644
--- a/packages/jpl/src/java/org/jpl7/Atom.java
+++ b/packages/jpl/src/java/org/jpl7/Atom.java
@@ -177,7 +177,7 @@
 	 * @return string representation of an Atom
 	 */
 	public String toString() {
-		return (JPL.isSimpleName(name) ? name : "'" + name + "'");
+		return (JPL.isSimpleName(name) || isListNil() ? name : "'" + name + "'");
 	}
 
 	/**
diff --git a/packages/jpl/src/java/org/jpl7/Compound.java b/packages/jpl/src/java/org/jpl7/Compound.java
index e642be2..accb4ef 100644
--- a/packages/jpl/src/java/org/jpl7/Compound.java
+++ b/packages/jpl/src/java/org/jpl7/Compound.java
@@ -227,6 +227,10 @@
 
 	/**
 	 * whether this Term denotes (syntax-specifically) a list cell
+	 * see this does not check the shape of the second argument to check if it is a list
+	 *
+	 * So a list pair may not be a list itself and hence isList() will return false
+	 * as the second argument many not be a list
 	 *
 	 * @return whether this Term denotes (syntax-specifically) a list cell
 	 */
@@ -281,16 +285,38 @@
 	}
 
 
-
-	/**
-	 * a prefix functional representation of a Compound of the form name(arg1,...), where 'name' is quoted iff necessary
-	 * (to be valid Prolog soutce text) and each argument is represented according to its toString() method.
+	/**
+	 *
+	 * a prefix functional representation of a Compound of the form name(arg1,...),
+	 * where 'name' is quoted iff necessary
+	 * (to be valid Prolog source text) and each argument is represented according to its
+	 * toString() method.
+	 *
+	 * Lists are represented depending on JPL.LIST_TOSTRING_TEXTUAL
 	 *
 	 * @return string representation of an Compound
 	 */
 	public String toString() {
-		return JPL.quotedName(name) + (args.length > 0 ? "(" + Term.toString(args) + ")" : "");
-	}
+		if (isListPair() && JPL.LIST_TOSTRING_TEXTUAL) { // output nice Prolog [.,.,.,.,] format, not prefix format
+			String head_str = arg(1).toString();	// must be at least 1 arg in compound
+			String tail_str;
+			if (arg(2).isListNil()) {
+				return String.format("[%s]", head_str);
+			}  else {
+				tail_str = arg(2).toString();
+				StringBuilder builder = new StringBuilder(tail_str);
+				if (arg(2).isListPair()) {
+					builder.deleteCharAt(builder.length()-1);	// remove closing ]
+					builder.deleteCharAt(0);	// remove opening [
+				}
+				return String.format("[%s, %s]", head_str, builder.toString());
+			}
+		}	// just return lists in pre-fix as '[|]'(head, '[|]'(head, '[|]'(head, .....)
+		return JPL.quotedName(name) +
+					(args.length > 0 ? "(" + Term.toString(args) + ")" : "");
+	}
+
+
 
 	/**
 	 * the type of this term, as jpl.fli.Prolog.COMPOUND
diff --git a/packages/jpl/src/java/org/jpl7/JPL.java b/packages/jpl/src/java/org/jpl7/JPL.java
index a97cef8..9cebbd6 100644
--- a/packages/jpl/src/java/org/jpl7/JPL.java
+++ b/packages/jpl/src/java/org/jpl7/JPL.java
@@ -76,6 +76,8 @@
 	public static String LIST_PAIR = LIST_PAIR_MODERN; // default unless/until
 														// setTraditional() is
 														// called successfully
+	// whether we want lists to be printed in pre-fix '[|]'(head, tails) or textual [....] format
+	public static boolean LIST_TOSTRING_TEXTUAL = true;
 
 	private static String nativeLibraryName = "jpl";
 	private static String nativeLibraryDir = null;
diff --git a/packages/jpl/src/java/org/jpl7/Query.java b/packages/jpl/src/java/org/jpl7/Query.java
index 962a841..6a3d169 100644
--- a/packages/jpl/src/java/org/jpl7/Query.java
+++ b/packages/jpl/src/java/org/jpl7/Query.java
@@ -166,7 +166,7 @@
      * @throws JPLException  if term provided is not of right sort Atom or Compound
      */
     public Query(String text) {
-        this(Util.textToTerm(text));
+        this(Term.textToTerm(text));
     }
 
 
@@ -205,7 +205,7 @@
      *            the arguments of this Query's goal
      */
 	private static Term buildQueryTerm(String text, Term[] args) {
-		Term t = Util.textToTerm(text);
+		Term t = Term.textToTerm(text);
 		if (t instanceof Atom) {
 			return new Compound(text, args);
 		} else {
@@ -436,7 +436,7 @@
 				Term exception_term = Term.getTerm(new HashMap<term_t, Variable>(), exception_term_t);
 				close();
 				throw new PrologException(exception_term);
-			} else {
+			} else {	// no more solution, close the query
 				close();
 				return false;
 			}
@@ -456,7 +456,7 @@
 
 	/**
 	 * Used to be used only by Utils.textToTerm but code has been integrated there already
-	 * @return
+	 * @return a substituion from variable names to terms
 	 */
 	@Deprecated
 	public final Map<String, Term> getSubstWithNameVars() {
@@ -563,7 +563,7 @@
 			String BindingVarName = ((Variable) BindingVarTerm).name; // its textual name ("Bindings" in example)
 
 			Term TermVar = args[args.length - 2]; // the Query's last arg: a variable binding list; type Variable
-			String TermVarName = ((Variable) TermVar).name; // its textual name ("Bindings" in example)
+//			String TermVarName = ((Variable) TermVar).name; // its textual name ("Bindings" in example)
 
 			// SECOND, we store what B was bound to as JPL Compound list instance BindingVarValue
 			//	If B was bound to ['X' = _1, 'Y' = _2] in the current solution
diff --git a/packages/jpl/src/java/org/jpl7/Term.java b/packages/jpl/src/java/org/jpl7/Term.java
index 58900e0..c358c68 100644
--- a/packages/jpl/src/java/org/jpl7/Term.java
+++ b/packages/jpl/src/java/org/jpl7/Term.java
@@ -60,7 +60,7 @@
 	 * returns the i-th (1+) argument of a Term;
 	 *
 	 * defined only for Compound
-     *
+	 *
 	 * @param i the index of argument to return
 	 * @return the i-th argument of a (Compound) Term
 	 * @throws JPLException if Term is not a Compound
@@ -105,10 +105,24 @@
 		throw new JPLException("atomType() is undefined for " + this.typeName());
 	}
 
-
-	/**
-	 * Converts a Prolog source text to a corresponding JPL Term (in which each Variable has the appropriate name from
-	 * the source text).
+	/**
+	 * The name of an Atom, Compound or Variable.
+	 *
+	 * @return the name of an Atom, Compound or Variable.
+	 * @throws JPLException
+	 *             if this Term is not an Atom, Compound or Variable.
+	 */
+	public String name() { // overridden in Atom, Compound, Variable
+		throw new JPLException("name() is undefined for " + this.typeName());
+	}
+
+	public void setName(String name) {
+		throw new JPLException("name() is undefined for " + this.typeName());
+	}
+
+	/**
+	 * Converts a Prolog source text to a corresponding JPL Term
+	 * (in which each Variable has the appropriate name from the source text).
 	 *
 	 * @param text A Prolog source text denoting a term
 	 * @return Term a JPL Term equivalent to the given source text
@@ -131,12 +145,9 @@
 		// it might be better to use PL_chars_to_term()
 		Query q = new Query(new Compound("atom_to_term",
 				new Term[] { new Atom(text), new Variable("T"), new Variable("NVdict") }));
+
 		q.open();
-
-		// quer is open, check if there is a solution
 		if (q.hasMoreSolutions()) {
-			// cannot use  this bc it gives anonymous vars, we lose the names
-			// If we use this we will get T mmapped to Term mother(maria, _1, _2) but we want mother(maria, X, Y)
 			Map<String, Term> s = q.nextSolution();
 
 			// New way of doing it (April 2020)
@@ -148,23 +159,65 @@
 			//		Since the Term bound to T will use exactl the Variables _1, _2, etc, by changing their names
 			//			the term T will now use Variables X, Y, etc as wanted!
 			//Term T = s.get("T");
-			Term[] VarsMapList = Util.listToTermArray(s.get("NVdict"));	// this is a Compound list of mappings
+			Term[] VarsMapList = Term.listToTermArray(s.get("NVdict"));	// this is a Compound list of mappings
 			for (Term map : VarsMapList) { // map represents 'X' = _1
-				String VarName = map.arg(1).name();		// extract the symbolic name
-				Variable Var = (Variable) map.arg(2);					// extract Variable object
-				Var.setName(VarName);
+				String VarName = map.arg(1).name();		// extract the symbolic name of the variable
+				Variable Var = (Variable) map.arg(2);	// extract the Variable object
+				Var.setName(VarName);					// set the name of the Variable object to the symbolic name
 			}
 
 			// Old way of doing it (before April 2020) - extremely involved!
 			//Map<String, Term> s = q.getSolutionWithVarNames();
 
+
+			// We MUST close the query explicitly or otherwise it will remain at the top of stack because we
+			// just did q.nextSolution() and there may be more
 			q.close();
+
 			return (Term) s.get("T");
 		} else {
+			q.close();	// redundant as q.hasMoreSolutions() would have closed it, but ....
 			return null;
 		}
 	}
 
+	/**
+	 * Converts a Prolog source text to a corresponding JPL Term (in which each Variable has the appropriate name from
+	 * the source text), replacing successive occurrences of ? in the text by the corresponding element of Term[]
+	 * params. (New in JPL 3.0.4)
+	 *
+	 * Throws PrologException containing error(syntax_error(_),_) if text is invalid.
+	 *
+	 * @param text A Prolog source text denoting a term
+	 * @param params parameters to be injected in each ?
+	 * @return Term a JPL Term equivalent to the given source text
+	 */
+	public static Term textParamsToTerm(String text, Term[] params) {
+		return Term.textToTerm(text).putParams(params);
+	}
+
+
+	/**
+	 * returns the value (as an int) of an Integer or Float
+	 *
+	 * @return the value (as an int) of an Integer or Float
+	 * @throws JPLException
+	 *             if this Term is a Compound, Atom or Variable
+	 */
+	public int intValue() {
+		throw new JPLException("intValue() is undefined for " + this.typeName());
+	}
+
+	/**
+	 * The (long) value of a Float or Integer.
+	 *
+	 * @return the (long) value of a Float or Integer.
+	 * @throws JPLException
+	 *             if this Term is not a Float or Integer.
+	 */
+	public long longValue() { // overridden in Integer, GFloat
+		throw new JPLException("longValue() is undefined for " + this.typeName());
+	}
 
 	/**
 	 * the value (as a java.math.BigInteger) of an Integer, whether or not it is big
@@ -199,47 +252,6 @@
 		throw new JPLException("floatValue() is undefined for " + this.typeName());
 	}
 
-	/**
-	 * This method computes a substitution from a Term (the current object).
-	 * The bindings Map varnames_to_Terms maps names of Variables to Terms.
-	 * Thus, a substitution is as it is in mathematical logic, a sequence of the form \sigma = {t_0/x_0, ..., t_n/x_n}.
-	 * Once the substitution is computed, the substitution should satisfy
-	 *
-	 * \sigma T = t
-	 *
-	 * where T is the Term from which the substitution is computed, and t is the term_t which results from the Prolog
-	 * query.
-	 * <p>
-	 *
-	 * A second Map, vars_to_Vars, is required: this table holds the Variables that occur (thus far) in the unified term.
-	 * 	The Variable instances in this table are guaranteed to be unique and are keyed on Strings which are Prolog internal
-	 * representations of the variables.
-	 *
-	 * @param varnames_to_Terms
-	 *            table holding Term substitutions, keyed on names of Variables.
-	 * @param vars_to_Vars
-	 *            A Map holding the Variables that occur thus far in the term; keyed by internal (Prolog) string rep.
-	 */
-	protected void getSubst(Map<String, Term> varnames_to_Terms, Map<term_t, Variable> vars_to_Vars) {
-		// overridden in Compound, Variable
-	}
-
-	/**
-	 * Just calls computeSubstitution for each Term in the array.
-	 *
-	 * @param varnames_to_Terms
-	 *            a Map from variable names to Terms (what each variable string is to be replaced by)
-	 * @param vars_to_Vars
-	 *            a Map from Prolog variables (which may be bounded in the engine) to JPL Variables (which are Java objects)
-	 * @param args
-	 *            an array of Terms to which the substitution is to be applied
-	 */
-	protected static void getSubsts(Map<String, Term> varnames_to_Terms, Map<term_t, Variable> vars_to_Vars,
-			Term[] args) {
-		for (int i = 0; i < args.length; ++i) {
-			args[i].getSubst(varnames_to_Terms, vars_to_Vars);
-		}
-	}
 
 	/**
 	 * create and return a org.jpl7.Term representation of the given Prolog term
@@ -256,89 +268,89 @@
 		Int64Holder hInt64;
 		ObjectHolder hObject;
 		switch (Prolog.term_type(term)) {
-		case Prolog.VARIABLE: // 1
-			for (Iterator<term_t> i = vars_to_Vars.keySet().iterator(); i.hasNext();) {
-				term_t varX = (term_t) i.next(); // a previously seen Prolog
-													// variable
-				if (Prolog.compare(varX, term) == 0) { // identical Prolog
-														// variables?
-					return (Term) vars_to_Vars.get(varX); // return the
-															// associated JPL
-															// Variable
+			case Prolog.VARIABLE: // 1
+				for (Iterator<term_t> i = vars_to_Vars.keySet().iterator(); i.hasNext();) {
+					term_t varX = (term_t) i.next(); // a previously seen Prolog
+					// variable
+					if (Prolog.compare(varX, term) == 0) { // identical Prolog
+						// variables?
+						return (Term) vars_to_Vars.get(varX); // return the
+						// associated JPL
+						// Variable
+					}
 				}
-			}
-			// otherwise, the Prolog variable in term has not been seen before
-			Variable Var = new Variable(); // allocate a new (sequentially
-											// named) Variable to represent it
-			Var.term_ = term; // this should become redundant...
-			vars_to_Vars.put(term, Var); // use Hashtable(var,null), but only
-											// need set(var)
-			return Var;
-		case Prolog.ATOM: // 2
-			hString = new StringHolder();
-			Prolog.get_atom_chars(term, hString); // ignore return val; assume
-													// success...
-			return new Atom(hString.value, "text");
-		case Prolog.STRING: // 5
-			hString = new StringHolder();
-			Prolog.get_string_chars(term, hString); // ignore return val; assume
-													// success...
-			return new Atom(hString.value, "string");
-		case Prolog.INTEGER: // 3
-			hInt64 = new Int64Holder();
-			if (Prolog.get_integer(term, hInt64)) { // assume it fails if Prolog
-													// integer is bigger than a
-													// Java long...
-				return new org.jpl7.Integer(hInt64.value);
-			} else {
+				// otherwise, the Prolog variable in term has not been seen before
+				Variable Var = new Variable(); // allocate a new (sequentially
+				// named) Variable to represent it
+				Var.term_ = term; // this should become redundant...
+				vars_to_Vars.put(term, Var); // use Hashtable(var,null), but only
+				// need set(var)
+				return Var;
+			case Prolog.ATOM: // 2
 				hString = new StringHolder();
-				if (Prolog.get_integer_big(term, hString)) {
+				Prolog.get_atom_chars(term, hString); // ignore return val; assume
+				// success...
+				return new Atom(hString.value, "text");
+			case Prolog.STRING: // 5
+				hString = new StringHolder();
+				Prolog.get_string_chars(term, hString); // ignore return val; assume
+				// success...
+				return new Atom(hString.value, "string");
+			case Prolog.INTEGER: // 3
+				hInt64 = new Int64Holder();
+				if (Prolog.get_integer(term, hInt64)) { // assume it fails if Prolog
+					// integer is bigger than a
+					// Java long...
+					return new org.jpl7.Integer(hInt64.value);
+				} else {
+					hString = new StringHolder();
+					if (Prolog.get_integer_big(term, hString)) {
+						// System.out.println("bigint = " + hString.value);
+						return new org.jpl7.Integer(new java.math.BigInteger(hString.value));
+					} else {
+						return new org.jpl7.Integer(-3); // arbitrary
+					}
+				}
+			case Prolog.RATIONAL: // 4
+				hString = new StringHolder();
+				if (Prolog.get_rational(term, hString)) {
 					// System.out.println("bigint = " + hString.value);
-					return new org.jpl7.Integer(new java.math.BigInteger(hString.value));
+					return new org.jpl7.Rational(hString.value);
 				} else {
 					return new org.jpl7.Integer(-3); // arbitrary
 				}
-			}
-		case Prolog.RATIONAL: // 4
-			hString = new StringHolder();
-			if (Prolog.get_rational(term, hString)) {
-				// System.out.println("bigint = " + hString.value);
-				return new org.jpl7.Rational(hString.value);
-			} else {
-				return new org.jpl7.Integer(-3); // arbitrary
-			}
-		case Prolog.FLOAT: // 5
-			DoubleHolder hFloatValue = new DoubleHolder();
-			Prolog.get_float(term, hFloatValue); // assume it succeeds...
-			return new org.jpl7.Float(hFloatValue.value);
-		case Prolog.COMPOUND: // 6
-		case Prolog.LIST_PAIR: // 9
-			hString = new StringHolder();
-			hInt = new IntHolder();
-			Prolog.get_name_arity(term, hString, hInt); // assume it succeeds
-			Term args[] = new Term[hInt.value];
-			// term_t term1 = Prolog.new_term_refs(hArity.value);
-			for (int i = 1; i <= hInt.value; i++) {
-				term_t termi = Prolog.new_term_ref();
-				Prolog.get_arg(i, term, termi);
-				args[i - 1] = Term.getTerm(vars_to_Vars, termi);
-			}
-			return new Compound(hString.value, args);
-		case Prolog.LIST_NIL: // 7
-			return JPL.LIST_NIL;
-		case Prolog.BLOB: // 8
-			hObject = new ObjectHolder();
-			if (Prolog.get_jref_object(term, hObject)) {
-				if (hObject.value == null) {
-					return JPL.JNULL;
+			case Prolog.FLOAT: // 5
+				DoubleHolder hFloatValue = new DoubleHolder();
+				Prolog.get_float(term, hFloatValue); // assume it succeeds...
+				return new org.jpl7.Float(hFloatValue.value);
+			case Prolog.COMPOUND: // 6
+			case Prolog.LIST_PAIR: // 9
+				hString = new StringHolder();
+				hInt = new IntHolder();
+				Prolog.get_name_arity(term, hString, hInt); // assume it succeeds
+				Term args[] = new Term[hInt.value];
+				// term_t term1 = Prolog.new_term_refs(hArity.value);
+				for (int i = 1; i <= hInt.value; i++) {
+					term_t termi = Prolog.new_term_ref();
+					Prolog.get_arg(i, term, termi);
+					args[i - 1] = Term.getTerm(vars_to_Vars, termi);
+				}
+				return new Compound(hString.value, args);
+			case Prolog.LIST_NIL: // 7
+				return JPL.LIST_NIL;
+			case Prolog.BLOB: // 8
+				hObject = new ObjectHolder();
+				if (Prolog.get_jref_object(term, hObject)) {
+					if (hObject.value == null) {
+						return JPL.JNULL;
+					} else {
+						return new JRef(hObject.value);
+					}
 				} else {
-					return new JRef(hObject.value);
+					throw new JPLException("unsupported blob type passed from Prolog");
 				}
-			} else {
-				throw new JPLException("unsupported blob type passed from Prolog");
-			}
-		default: // should never happen
-			throw new JPLException("unknown term type=" + Prolog.term_type(term));
+			default: // should never happen
+				throw new JPLException("unknown term type=" + Prolog.term_type(term));
 		}
 	}
 
@@ -358,7 +370,7 @@
 	 *             if this Term is a Variable
 	 */
 	public boolean hasFunctor(String name, int arity) { // overridden in
-														// Atom, Compound
+		// Atom, Compound
 		return false;
 	}
 
@@ -413,16 +425,7 @@
 		return false;
 	}
 
-	/**
-	 * returns the value (as an int) of an Integer or Float
-	 *
-	 * @return the value (as an int) of an Integer or Float
-	 * @throws JPLException
-	 *             if this Term is a Compound, Atom or Variable
-	 */
-	public int intValue() {
-		throw new JPLException("intValue() is undefined for " + this.typeName());
-	}
+
 
 	/**
 	 * whether this Term is an Atom (of any type)
@@ -543,34 +546,7 @@
 		return false;
 	}
 
-	/**
-	 * Tests whether this Term denotes an empty list within the current syntax ("traditional" or "modern").
-	 *
-	 * @return whether this Term denotes an empty list within the current syntax ("traditional" or "modern").
-	 * @see org.jpl7.JPL#getSyntax()
-	 */
-	public boolean isListNil() { // overridden in Atom
-		return false;
-	}
-
-	/**
-	 * Tests whether this Term is a list pair within the current syntax ("traditional" or "modern").
-	 *
-	 * @return whether this Term is a list pair within the current syntax ("traditional" or "modern").
-	 */
-	public boolean isListPair() { // overridden in Compound
-		return false;
-	}
-
-
-	/**
-	 * Tests whether this Term is a list (empty or list pair)
-	 *
-	 * @return whether this Term is a list, empty or list pair
-	 */
-	public boolean isList() { // overridden in Compound
-		return (isListNil() || isListPair());
-	}
+
 
 	/**
 	 * Tests whether this Term is a Variable.
@@ -581,58 +557,8 @@
 		return this instanceof Variable;
 	}
 
-	/**
-	 * @return the Object which this JRef references
-	 * @deprecated Use {@link JRef#object()}
-	 */
-	@Deprecated
-	public Object jrefToObject() { // overridden in Compound and JRef
-		throw new JPLException("term is neither a JRef nor a Compound representing @(null)");
-	}
-
-	/**
-	 * The length of this list, iff it is one, else an exception is thrown.
-	 *
-	 * @throws JPLException if the term is not a list
-	 * @return the length (as an int) of this list, iff it is one.
-	 * @deprecated Use {@link Util#listToLength(Term)}
-	 */
-    @Deprecated
-	public final int listLength() {
-		if (this.isListPair()) { // was .hasFunctor(".", 2)
-			return 1 + this.arg(2).listLength(); // TODO eliminate recursion
-		} else if (this.isListNil()) { // was .hasFunctor("[]", 0)
-			return 0;
-		} else {
-			throw new JPLException("term is not a list");
-		}
-	}
-
-	/**
-	 * The (long) value of a Float or Integer.
-	 *
-	 * @return the (long) value of a Float or Integer.
-	 * @throws JPLException
-	 *             if this Term is not a Float or Integer.
-	 */
-	public long longValue() { // overridden in Integer, GFloat
-		throw new JPLException("longValue() is undefined for " + this.typeName());
-	}
-
-	/**
-	 * The name of an Atom, Compound or Variable.
-	 *
-	 * @return the name of an Atom, Compound or Variable.
-	 * @throws JPLException
-	 *             if this Term is not an Atom, Compound or Variable.
-	 */
-	public String name() { // overridden in Atom, Compound, Variable
-		throw new JPLException("name() is undefined for " + this.typeName());
-	}
-
-	public void setName(String name) {
-		throw new JPLException("name() is undefined for " + this.typeName());
-	}
+
+
 	/**
 	 * The Object which this org.jpl7.JRef refers to, iff this Term is a JRef or just JPL.JNULL.
 	 *
@@ -641,21 +567,21 @@
 	 */
 	public Object object() { // overridden in JRef
 		if (this == JPL.JNULL)
-		    return null;
-        else
-            throw new JPLException("this term is not a JRef");
-	}
-
-	/**
-     * Returns the JREF term for an object
-     *
-     * @param object object of interest
+			return null;
+		else
+			throw new JPLException("this term is not a JRef");
+	}
+
+	/**
+	 * Returns the JREF term for an object
+	 *
+	 * @param object object of interest
 	 * @return a new JRef which references object, or @(null) if object == null.
 	 * @throws JPLException
 	 *             if object is a String.
 	 * @deprecated Use {@link JPL#newJRef}
 	 */
-    @Deprecated
+	@Deprecated
 	public static final Term objectToJRef(Object object) {
 		if (object == null) {
 			return JPL.JNULL;
@@ -733,18 +659,18 @@
 
 	protected Term putParams1(IntHolder next, Term[] ps) {
 		switch (this.type()) {
-		case Prolog.COMPOUND:
-			return new Compound(this.name(), putParams2(this.args(), next, ps));
-		case Prolog.ATOM:
-			if (!this.name().equals("?")) {
+			case Prolog.COMPOUND:
+				return new Compound(this.name(), putParams2(this.args(), next, ps));
+			case Prolog.ATOM:
+				if (!this.name().equals("?")) {
+					return this;
+				} else if (next.value >= ps.length) {
+					throw new JPLException("fewer actual params than formal params");
+				} else {
+					return ps[next.value++];
+				}
+			default:
 				return this;
-			} else if (next.value >= ps.length) {
-				throw new JPLException("fewer actual params than formal params");
-			} else {
-				return ps[next.value++];
-			}
-		default:
-			return this;
 		}
 	}
 
@@ -800,31 +726,19 @@
 	 *             if this Term is not a JRef
 	 * @deprecated Use {@link JRef#object()}
 	 */
-    @Deprecated
+	@Deprecated
 	public Object ref() { // overridden in JRef
 		throw new JPLException("this Term is not a JRef");
 	}
 
-	/**
-	 * returns an array of Terms whose elements are the respective members of this list, iff it is a list.
-	 *
-	 * @throws JPLException
-	 *             if this Term is not a proper list.
-	 * @return an array of Terms whose elements are the respective members of this list, iff it is a list.
-	 */
-	public final Term[] toTermArray() {
-		try {
-			int len = Util.listToLength(this); // exception if not a well formed list
-			Term[] ts = new Term[len];
-			Term t = this;
-			for (int i = 0; i < len; i++) { // no need to check functor (it's a list)
-				ts[i] = t.arg(1);
-				t = t.arg(2);
-			}
-			return ts;
-		} catch (JPLException e) {
-			throw new JPLException("term is not a proper list");
-		}
+
+	/**
+	 * @return the Object which this JRef references
+	 * @deprecated Use {@link JRef#object()}
+	 */
+	@Deprecated
+	public Object jrefToObject() { // overridden in Compound and JRef
+		throw new JPLException("term is neither a JRef nor a Compound representing @(null)");
 	}
 
 	// ==================================================================/
@@ -841,6 +755,49 @@
 	// Variable with which the term was unified.
 	// ==================================================================/
 
+
+	/**
+	 * This method computes a substitution from a Term (the current object).
+	 * The bindings Map varnames_to_Terms maps names of Variables to Terms.
+	 * Thus, a substitution is as it is in mathematical logic, a sequence of the form \sigma = {t_0/x_0, ..., t_n/x_n}.
+	 * Once the substitution is computed, the substitution should satisfy
+	 *
+	 * \sigma T = t
+	 *
+	 * where T is the Term from which the substitution is computed, and t is the term_t which results from the Prolog
+	 * query.
+	 * <p>
+	 *
+	 * A second Map, vars_to_Vars, is required: this table holds the Variables that occur (thus far) in the unified term.
+	 * 	The Variable instances in this table are guaranteed to be unique and are keyed on Strings which are Prolog internal
+	 * representations of the variables.
+	 *
+	 * @param varnames_to_Terms
+	 *            table holding Term substitutions, keyed on names of Variables.
+	 * @param vars_to_Vars
+	 *            A Map holding the Variables that occur thus far in the term; keyed by internal (Prolog) string rep.
+	 */
+	protected void getSubst(Map<String, Term> varnames_to_Terms, Map<term_t, Variable> vars_to_Vars) {
+		// overridden in Compound, Variable
+	}
+
+	/**
+	 * Just calls computeSubstitution for each Term in the array.
+	 *
+	 * @param varnames_to_Terms
+	 *            a Map from variable names to Terms (what each variable string is to be replaced by)
+	 * @param vars_to_Vars
+	 *            a Map from Prolog variables (which may be bounded in the engine) to JPL Variables (which are Java objects)
+	 * @param args
+	 *            an array of Terms to which the substitution is to be applied
+	 */
+	protected static void getSubsts(Map<String, Term> varnames_to_Terms, Map<term_t, Variable> vars_to_Vars,
+									Term[] args) {
+		for (int i = 0; i < args.length; ++i) {
+			args[i].getSubst(varnames_to_Terms, vars_to_Vars);
+		}
+	}
+
 	/**
 	 * This method is used (by Compound.equals) to determine whether two Term arrays are pairwise equal, where two
 	 * Terms are equal if they satisfy the equals predicate (defined differently in each Term subclass).
@@ -896,4 +853,213 @@
 	 */
 	public abstract String typeName();
 
-}
+
+
+
+
+	// ==================================================================/
+	// LIST METHODS
+	//
+	// All tools to deal specifically with lists that could be either
+	// empty list JPL.LIST_NIL or Compound terms with functor [|].
+	// ==================================================================/
+
+	/**
+	 * Tests whether this Term denotes an empty list within the current syntax ("traditional" or "modern").
+	 *
+	 * @return whether this Term denotes an empty list within the current syntax ("traditional" or "modern").
+	 * @see org.jpl7.JPL#getSyntax()
+	 */
+	public boolean isListNil() { // overridden in Atom
+		return false;
+	}
+
+	/**
+	 * Tests whether this Term is a list pair within the current
+	 * syntax ("traditional" or "modern").
+	 *
+	 * Note that a list pair may not be a list itself and hence isList() will return false
+	 * as the second argument many not be a list
+	 *
+	 * @return whether this Term is a list pair within the current syntax ("traditional" or "modern").
+	 */
+	public boolean isListPair() { // overridden in Compound
+		return false;
+	}
+
+	/**
+	 * whether the Term represents a proper list
+	 *
+	 * @return whether the Term represents a proper list
+	 */
+	public final boolean isList() {
+		return isList(this);
+	}
+
+	/**
+	 * whether the Term represents a proper list
+	 *
+	 * @param term the term to check if it is a list
+	 * @return whether the Term represents a proper list
+	 */
+	public static final boolean isList(Term term) {
+		return listLength(term) >= 0;
+	}
+
+
+
+	/**
+	 * @param term any Term
+	 * @return the length of the proper list which the Term represents, else -1
+	 */
+	public static int listLength(Term term) {
+		int length = 0;
+		Term head = term;
+		while (head.isListPair()) {
+			length++;
+			head = head.arg(2);
+		}
+		return (head.isListNil() ? length : -1);
+	}
+
+	/**
+	 * @return the length of the proper list which the Term represents, else -1
+	 */
+	public int listLength() {
+		return Term.listLength(this);
+	}
+
+	/**
+	 * Converts an array of String to a corresponding JPL list of atoms
+	 *
+	 * @param a An array of String objects
+	 * @return Term a JPL list of atoms corresponding to the given String array
+	 */
+	public static Term stringArrayToList(String[] a) {
+		Term list = JPL.LIST_NIL;
+		for (int i = a.length - 1; i >= 0; i--) {
+			list = new Compound(JPL.LIST_PAIR, new Term[] { new Atom(a[i]), list });
+		}
+		return list;
+	}
+
+	/**
+	 * Converts an array of int to a corresponding JPL list
+	 *
+	 * @param a
+	 *            An array of int values
+	 * @return Term a JPL list corresponding to the given int array
+	 */
+	public static Term intArrayToList(int[] a) {
+		Term list = JPL.LIST_NIL; // was new Atom("[]");
+		for (int i = a.length - 1; i >= 0; i--) {
+			list = new Compound(JPL.LIST_PAIR, new Term[] { new org.jpl7.Integer(a[i]), list });
+		}
+		return list;
+	}
+
+	/**
+	 * Converts an array of arrays of int to a corresponding JPL list of lists
+	 *
+	 * @param a
+	 *            An array of arrays of int values
+	 * @return Term a JPL list of lists corresponding to the given int array of arrays
+	 */
+	public static Term intArrayArrayToList(int[][] a) {
+		Term list = JPL.LIST_NIL; // was new Atom("[]");
+		for (int i = a.length - 1; i >= 0; i--) {
+			list = new Compound(JPL.LIST_PAIR, new Term[] { intArrayToList(a[i]), list });
+		}
+		return list;
+	}
+
+
+	/**
+	 * Converts an array of Terms to a JPL representation of a Prolog list of terms whose members correspond to the
+	 * respective array elements.
+	 *
+	 * @param terms
+	 *            An array of Term
+	 * @return Term a list of the array elements
+	 */
+	public static Term termArrayToList(Term[] terms) {
+		Term list = JPL.LIST_NIL; // was new Atom("[]")
+		for (int i = terms.length - 1; i >= 0; --i) {
+			list = new Compound(JPL.LIST_PAIR, new Term[] { terms[i], list });
+		}
+		return list;
+	}
+
+
+	/**
+	 * Converts a term representing a list of atoms into an array of Strings, each element
+	 * in the array being a String for the corresponding atom
+	 * 	e.g., [a, b, 1
+	 *
+	 *
+	 * @param t a term representing a list of atoms
+	 * @return an array of Strings, each element, null if t is not a list of atoms
+	 */
+	public static String[] atomListToStringArray(Term t) {
+		int n = Term.listLength(t);
+		String[] a;
+		if (n < 0) {
+			return null;
+		} else {
+			a = new String[n];
+		}
+		int i = 0;
+		Term head = t;
+		while (head.isListPair()) {
+			Term x = head.arg(1);
+			if (x.isAtom()) {
+				a[i++] = x.name();
+			} else {
+				return null;
+			}
+			head = head.arg(2);
+		}
+		return (head.isListNil() ? a : null);
+	}
+
+
+
+	/**
+	 * converts a proper list to an array of terms, else throws an exception
+	 *
+	 * @throws JPLException if the term passed is not itself a Prolog list term
+	 * @return an array of terms whose successive elements are the corresponding members of the list (if it is a list)
+	 */
+	public static Term[] listToTermArray(Term t) {
+		int len = Term.listLength(t); // exception if not a well formed list
+		if (len < 0) {
+			throw new JPLException("term is not a proper list");
+		}
+		Term[] ts = new Term[len];
+		for (int i = 0; i < len; i++) { // no need to check functor (it's a list)
+			ts[i] = t.arg(1);
+			t = t.arg(2);
+		}
+		return ts;
+	}
+
+	/**
+	 * converts a proper list to an array of terms, else throws an exception
+	 *
+	 * @throws JPLException if the term passed is not itself a Prolog list term
+	 * @return an array of terms whose successive elements are the corresponding members of the list (if it is a list)
+	 */
+	public final Term[] listToTermArray() {
+		return Term.listToTermArray(this);
+	}
+
+	/**
+	 * @deprecated Use org.jpl7.Term.termArrayToList(Term[] terms)
+	 */
+	@Deprecated
+	public final Term[] toTermArray() {
+		return listToTermArray();
+	}
+
+
+}
\ No newline at end of file
diff --git a/packages/jpl/src/java/org/jpl7/Util.java b/packages/jpl/src/java/org/jpl7/Util.java
index 92623e0..c3f6f0f 100644
--- a/packages/jpl/src/java/org/jpl7/Util.java
+++ b/packages/jpl/src/java/org/jpl7/Util.java
@@ -46,13 +46,11 @@
 	 * @param terms
 	 *            An array of Term
 	 * @return Term a list of the array elements
-	 */
+	 * @deprecated Use org.jpl7.Term.termArrayToList(Term[] terms)
+	 */
+	@Deprecated
 	public static Term termArrayToList(Term[] terms) {
-		Term list = JPL.LIST_NIL; // was new Atom("[]")
-		for (int i = terms.length - 1; i >= 0; --i) {
-			list = new Compound(JPL.LIST_PAIR, new Term[] { terms[i], list });
-		}
-		return list;
+		return Term.termArrayToList(terms);
 	}
 
 	/**
@@ -62,7 +60,7 @@
 	 *            A Map from variable names to Terms.
 	 * @return String A String representation of the variable bindings
 	 */
-	public static String toString(Map<String, Term> varnames_to_Terms) {
+	public static String subsToString(Map<String, Term> varnames_to_Terms) {
 		if (varnames_to_Terms == null) {
 			return "[no solution]";
 		} else {
@@ -74,6 +72,14 @@
 			}
 			return s;
 		}
+	}
+
+	/**
+	 * @deprecated Use org.jpl7.Util.subsToString(Map<String, Term>)
+	 */
+	@Deprecated
+	public static String toString(Map<String, Term> varnames_to_Terms) {
+		return subsToString(varnames_to_Terms);
 	}
 
 	/**
@@ -94,31 +100,25 @@
 				// the cast to Variable is necessary to access the (protected)
 				// .term_ field
 				vars_to_Vars.put(((Variable) nvs.arg(1).arg(2)).term_, new Variable(nvs.arg(1).arg(1).name())); // map
-																												// the
-																												// Prolog
-																												// variable
-																												// to
-																												// a
-																												// new,
-																												// named
-																												// Variable
+				// the
+				// Prolog
+				// variable
+				// to
+				// a
+				// new,
+				// named
+				// Variable
 				nvs = nvs.arg(2); // advance to next list cell
 			}
 			// maybe oughta check that nvs is [] ?
 			return vars_to_Vars;
 		} catch (java.lang.ClassCastException e) { // nvs is not of the expected
-													// structure
+			// structure
 			return null;
 		}
 	}
 
 	/**
-	 * Converts a Prolog source text to a corresponding JPL Term (in which each Variable has the appropriate name from
-	 * the source text).
-	 *
-	 * @param text A Prolog source text denoting a term
-	 * @return Term a JPL Term equivalent to the given source text
-	 * @throws PrologException containing error(syntax_error(_),_) if text is invalid as a term.
 	 * @deprecated Use org.jpl7.Term.textToTerm(String text)
 	 */
 	@Deprecated
@@ -142,84 +142,55 @@
 	}
 
 	/**
-	 * Converts an array of String to a corresponding JPL list
-	 *
-	 * @param a
-	 *            An array of String objects
-	 * @return Term a JPL list corresponding to the given String array
-	 */
+	 * @deprecated Use org.jpl7.Term.stringArrayToList(String[] a)
+	 */
+	@Deprecated
 	public static Term stringArrayToList(String[] a) {
-		Term list = JPL.LIST_NIL;
-		for (int i = a.length - 1; i >= 0; i--) {
-			list = new Compound(JPL.LIST_PAIR, new Term[] { new Atom(a[i]), list });
-		}
-		return list;
-	}
-
-	/**
-	 * Converts an array of int to a corresponding JPL list
-	 *
-	 * @param a
-	 *            An array of int values
-	 * @return Term a JPL list corresponding to the given int array
-	 */
+		return Term.stringArrayToList(a);
+	}
+
+	/**
+	 * @deprecated Use org.jpl7.Term.intArrayToList(int[] a)
+	 */
+	@Deprecated
 	public static Term intArrayToList(int[] a) {
-		Term list = JPL.LIST_NIL; // was new Atom("[]");
-		for (int i = a.length - 1; i >= 0; i--) {
-			list = new Compound(JPL.LIST_PAIR, new Term[] { new org.jpl7.Integer(a[i]), list });
-		}
-		return list;
-	}
-
-	/**
-	 * Converts an array of arrays of int to a corresponding JPL list of lists
-	 *
-	 * @param a
-	 *            An array of arrays of int values
-	 * @return Term a JPL list of lists corresponding to the given int array of arrays
-	 */
+		return Term.intArrayToList(a);
+	}
+
+	/**
+	 * @deprecated Use org.jpl7.Term.intArrayArrayToList(int[][] a)
+	 */
+	@Deprecated
 	public static Term intArrayArrayToList(int[][] a) {
-		Term list = JPL.LIST_NIL; // was new Atom("[]");
-		for (int i = a.length - 1; i >= 0; i--) {
-			list = new Compound(JPL.LIST_PAIR, new Term[] { intArrayToList(a[i]), list });
-		}
-		return list;
-	}
-
-	/**
-	 * whether the Term represents a proper list
-	 *
-	 * @param term the term to check if it is a list
-	 * @return whether the Term represents a proper list
-	 */
+		return Term.intArrayArrayToList(a);
+	}
+
+	/**
+	 * @deprecated Use {@link Term#isList(Term)}
+	 */
+	@Deprecated
 	public static final boolean isList(Term term) {
-		return listToLength(term) >= 0;
-	}
+		return Term.isList(term);
+	}
+
 
 	/**
 	 * @param term any Term
 	 * @return the length of the proper list which the Term represents, else -1
-	 */
+	 * @deprecated Use {@link Term#listLength(Term)}
+	 */
+	@Deprecated
 	public static int listToLength(Term term) {
-		int length = 0;
-		Term head = term;
-		while (head.isListPair()) {
-			length++;
-			head = head.arg(2);
-		}
-		return (head.isListNil() ? length : -1);
-	}
-
-	/**
-	 * converts a proper list to an array of terms, else throws an exception
-	 *
-	 * @param t  a list term
-	 * @throws JPLException if the term passed is not itself a Prolog list term
-	 * @return an array of terms whose successive elements are the corresponding members of the list (if it is a list)
-	 */
+		return Term.listLength(term);
+	}
+
+	/**
+	 * @deprecated Use {@link Term#listToTermArray(Term)}
+	 */
+	@Deprecated
 	public static Term[] listToTermArray(Term t) {
 		try {
-			int len = Util.listToLength(t); // exception if not a list
+			int len = Term.listLength(t); // exception if not a list
 			Term[] ts = new Term[len];
 			for (int i = 0; i < len; i++) {
 				ts[i] = t.arg(1);
@@ -231,8 +202,12 @@
 		}
 	}
 
+	/**
+	 * @deprecated Use {@link Term#atomListToStringArray(Term)}
+	 */
+	@Deprecated
 	public static String[] atomListToStringArray(Term t) {
-		int n = listToLength(t);
+		int n = Term.listLength(t);
 		String[] a;
 		if (n < 0) {
 			return null;
diff --git a/packages/jpl/src/java/org/jpl7/Version.java b/packages/jpl/src/java/org/jpl7/Version.java
index 20a39a2..f82d937 100644
--- a/packages/jpl/src/java/org/jpl7/Version.java
+++ b/packages/jpl/src/java/org/jpl7/Version.java
@@ -3,7 +3,7 @@
 
 class Version {
 	public final int major = 7;
-	public final int minor = 4; // jref as blob
+	public final int minor = 6; // jref as blob
 	public final int patch = 0;
 	public final String status = "alpha";
 }
diff --git a/packages/jpl/src/java/org/jpl7/test/junit/DataManagement.java b/packages/jpl/src/java/org/jpl7/test/junit/DataManagement.java
index e01c8a5..febf7e5 100644
--- a/packages/jpl/src/java/org/jpl7/test/junit/DataManagement.java
+++ b/packages/jpl/src/java/org/jpl7/test/junit/DataManagement.java
@@ -30,7 +30,7 @@
     public static void setUp() {
 
         setUpClass();
-        Query.hasSolution(String.format("consult('%s/test_quoted_module.pl')", test_dir)); // only because we call e.g. jpl_pl_syntax/1 below
+        Query.hasSolution(String.format("consult('%s/test_quoted_module.pl')", test_dir)); // .pl file to be used
     }
 
 
@@ -62,7 +62,7 @@
         name = "existence_error(procedure, '/'(pepe, 1))";
 //        name = "'/'(pepe, 1)";
         name = "'$c_call_prolog'";
-        t = Util.textToTerm(name);
+        t = Term.textToTerm(name);
         assertEquals("matching text-term", name, t.toString());
     }
 
@@ -166,7 +166,7 @@
     public void testUtilListToTermArray1() {
         String goal = "T = [a,b,c]";
         Term list = Query.oneSolution(goal).get("T");
-        Term[] array = Util.listToTermArray(list);
+        Term[] array = Term.listToTermArray(list);
         assertTrue(array[2].isAtom() && array[2].name().equals("c"));
     }
 
@@ -174,7 +174,7 @@
     public void testTermToTermArray1() {
         String goal = "T = [a,b,c]";
         Term list = Query.oneSolution(goal).get("T");
-        Term[] array = list.toTermArray();
+        Term[] array = list.listToTermArray();
         assertTrue(array[2].isAtom() && array[2].name().equals("c"));
     }
 
@@ -183,7 +183,7 @@
     @Test
     public void testTextToTerm1() {
         String text = "fred(B,p(A))";
-        Term t = Util.textToTerm(text);
+        Term t = Term.textToTerm(text);
         assertTrue("Util.textToTerm() converts \"fred(B,p(A))\" to a corresponding Term",
                 t.hasFunctor("fred", 2) && t.arg(1).isVariable() && t.arg(1).name().equals("B")
                         && t.arg(2).hasFunctor("p", 1) && t.arg(2).arg(1).isVariable()
@@ -196,9 +196,9 @@
     public void testTextToTerm2() {
         String text1 = "fred(?,2,?)";
         String text2 = "[first(x,y),A]";
-        Term plist = Util.textToTerm(text2);
-        Term[] ps = plist.toTermArray();
-        Term t = Util.textToTerm(text1).putParams(ps);
+        Term plist = Term.textToTerm(text2);
+        Term[] ps = plist.listToTermArray();
+        Term t = Term.textToTerm(text1).putParams(ps);
         assertTrue("fred(?,2,?) .putParams( [first(x,y),A] )",
                 t.hasFunctor("fred", 3) && t.arg(1).hasFunctor("first", 2) && t.arg(1).arg(1).hasFunctor("x", 0)
                         && t.arg(1).arg(2).hasFunctor("y", 0) && t.arg(2).hasFunctor(2, 0) && t.arg(3).isVariable()
diff --git a/packages/jpl/src/java/org/jpl7/test/junit/ListTest.java b/packages/jpl/src/java/org/jpl7/test/junit/ListTest.java
index 21dd1c3..51bf393 100644
--- a/packages/jpl/src/java/org/jpl7/test/junit/ListTest.java
+++ b/packages/jpl/src/java/org/jpl7/test/junit/ListTest.java
@@ -2,8 +2,6 @@
 
 import org.jpl7.*;
 import org.jpl7.Integer;
-import org.jpl7.fli.Prolog;
-import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
@@ -51,76 +49,26 @@
     ///////////////////////////////////////////////////////////////////////////////
 
 
+    private static Term[] terms_pair_integers = new Term[]{new Integer(1), new Integer(2)};
+    private static Term[] terms_integers = new Term[]{new Integer(1), new Integer(2), new Integer(3)};
+    private static Term[] terms_atoms = new Term[]{new Atom("a"), new Atom("b"), new Atom("c")};
+
+    // Several list terms of numbers
+    private static Term list_empty = Term.textToTerm("[]");
+    private static Term list_unit = Term.textToTerm("[1]");
+    private static Term list_unit_complex = Term.textToTerm("[[1,2,3]]");
+    private static Term list_simple = Term.textToTerm("[1,2,3]");
+    private static Term list_complex = Term.textToTerm("[1, [1,2,3], 3]");
+
+    private static Term[] lists_many = new Term[]{list_empty, list_unit, list_unit_complex, list_simple, list_complex};
+    private static Term[] lists_many_noempty = new Term[]{list_unit, list_unit_complex, list_simple, list_complex};
+
+
 
     ///////////////////////////////////////////////////////////////////////////////
     // TESTS
     ///////////////////////////////////////////////////////////////////////////////
 
-
-    @Test
-    public void testArrayToList1() {
-        Term l2 = Util.termArrayToList(
-                new Term[]{new Atom("a"), new Atom("b"), new Atom("c"), new Atom("d"), new Atom("e")});
-        Query q9 = new Query(new Compound("append", new Term[]{new Variable("Xs"), new Variable("Ys"), l2}));
-        assertTrue("append(Xs,Ys,[a,b,c,d,e]) has 6 solutions", q9.allSolutions().length == 6);
-    }
-
-    @Test
-    public void testArrayToList2() {
-        String goal = "append(Xs,Ys,[a,b,c,d,e])";
-        assertTrue(goal + " has 6 solutions", Query.allSolutions(goal).length == 6);
-    }
-
-    @Test
-    public void testArrayToList3() {
-        final String[] expectedSolutions = { "a", "b", "c", "d", "e"};
-
-        Term l2 = Util.termArrayToList(
-                new Term[] { new Atom("a"), new Atom("b"), new Atom("c"), new Atom("d"), new Atom("e") });
-        Query query = new Query(new Compound("member", new Term[] { new Variable("X"), l2 }));
-
-        Map<String, Term>[] sol = query.allSolutions();
-        for (int i = 0; i < sol.length; i++) {
-            assertEquals(expectedSolutions[i], sol[i].get("X").toString());
-        }
-    }
-
-    @Test
-    public void testArrayToList4() {
-        final String[] expectedSolutionsX = { "[]", "[a]", "[a, b]", "[a, b, c]"};
-        final String[] expectedSolutionsY = { "[a, b, c]", "[b, c]", "[c]", "[]"};
-
-        Term l2 = Util.termArrayToList(
-                new Term[] { new Atom("a"), new Atom("b"), new Atom("c") });
-        Query query = new Query(new Compound("append", new Term[] { new Variable("X"), new Variable("Y"), l2 }));
-
-        Map<String, Term>[] sol = query.allSolutions();
-        for (int i = 0; i < sol.length; i++) {
-
-            String ListX = Arrays.toString(Util.atomListToStringArray(sol[i].get("X")));
-            String ListY = Arrays.toString(Util.atomListToStringArray(sol[i].get("Y")));
-
-
-            assertEquals("Bad X in append(X, Y, [a, b, c])", expectedSolutionsX[i], ListX);
-            assertEquals("Bad Y in append(X, Y, [a, b, c])", expectedSolutionsY[i], ListY);
-
-        }
-    }
-
-
-
-
-
-
-
-    @Test
-    public void testLength1() {
-        Query q5 = new Query(new Compound("length", new Term[]{new Variable("Zs"), new Integer(2)}));
-        Term zs = q5.oneSolution().get("Zs");
-        assertTrue("length(Zs,2) binds Zs to a list of two distinct variables " + zs.toString(),
-                zs.isListPair() && zs.arg(1).isVariable() && zs.arg(2).isListPair() && zs.arg(2).arg(1).isVariable()
-                        && zs.arg(2).arg(2).isListNil() && !zs.arg(1).name().equals(zs.arg(2).arg(1).name()));
-    }
 
     @Test
     public void testListNil1() {
@@ -134,6 +82,71 @@
         }
     }
 
+
+    @Test
+    public void testListNil2() {
+        Term x;
+
+        x = Query.oneSolution("X = []").get("X");
+        assertTrue("term should be empty list", x.isListNil());
+        assertTrue("Util.isList on empty list", Term.isList(x));
+        assertTrue("term is not a ListPair", !x.isListPair());
+
+        x = Query.oneSolution("X = [1, 2, 3]").get("X");
+        assertTrue("term should NOT be empty list", !x.isListNil());
+        assertTrue("Util.isList on non-empty list", Term.isList(x));
+        assertTrue("term is not a ListPair", x.isListPair());
+    }
+
+    @Test
+    public void testIsList() {
+        final String[] options = { "[]", "[1]", "[1,2,3]", "[1, [a, b, c], 2]", "[[1,2,3]]"};
+
+        Term x;
+        for (String opt : options) {
+            x = Query.oneSolution(String.format("X = %s", opt)).get("X");
+            assertTrue("term should be empty list - Util", Term.isList(x));
+            assertTrue("term should be empty list - Util", x.isList());
+        }
+    }
+
+
+
+    @Test
+    public void testIsPairList() {
+        final String[] options = { "[]", "[1]", "[1,2,3]", "[1, [a, b, c], 2]", "[[1,2,3]]"};
+
+        Term t;
+        for (Term t2 : lists_many_noempty) {
+            String msg = String.format("term %s should be a pair list", t2.toString());
+            assertTrue(msg, t2.isListPair());
+        }
+
+        t = new Compound(JPL.LIST_PAIR, terms_pair_integers);
+        assertTrue("term is a pair list (even though second arg is not a list)", t.isListPair());
+
+
+        assertTrue("empty list term is not a list pair", !JPL.LIST_NIL.isListPair());
+
+        t = new Compound(JPL.LIST_PAIR, terms_integers);
+        assertTrue("term is not a pair list, has more than two arguments", !t.isListPair());
+
+        t = new Compound("hello", terms_integers);
+        assertTrue("term is not a pair list, not JPL.PAIR_LIST functor", !t.isListPair());
+
+    }
+
+    @Test
+    public void testIsPairList2() {
+        Term t = new Compound(JPL.LIST_PAIR,
+                new Term[]{new Integer(1), new Integer(2)});
+
+        String msg = String.format("term %s should be a pair list", t.toString());
+        assertTrue(msg, t.isListPair());
+
+        assertEquals("[1, 2]", t.toString());
+    }
+
     @Test
     public void testListCons1() {
         Term x = Query.oneSolution("X = [a]").get("X");
@@ -142,6 +155,83 @@
         } else {
             assertTrue("list constructor is [|]/2", x.isCompound() && x.name().equals("[|]"));
         }
+    }
+
+
+
+
+
+    @Test
+    public void testArrayToList1() {
+        Term l = Term.termArrayToList(
+                new Term[]{new Atom("a"), new Atom("b"), new Atom("c"),
+                        new Atom("d"), new Atom("e")});
+        Query q = new Query(new Compound("append",
+                new Term[]{new Variable("Xs"), new Variable("Ys"), l}));
+
+        assertTrue("append(Xs,Ys,[a,b,c,d,e]) has 6 solutions", q.allSolutions().length == 6);
+    }
+
+
+    @Test
+    public void testArrayToList2() {
+        final String[] expectedSolutions = { "a", "b", "c", "d", "e"};
+
+        Term l = Term.termArrayToList(
+                new Term[] { new Atom("a"), new Atom("b"), new Atom("c"),
+                        new Atom("d"), new Atom("e") });
+        Query query = new Query(new Compound("member",
+                new Term[] { new Variable("X"), l }));
+
+        Map<String, Term>[] sol = query.allSolutions();
+        for (int i = 0; i < sol.length; i++) {
+            assertEquals(expectedSolutions[i], sol[i].get("X").toString());
+        }
+    }
+
+    @Test
+    public void testArrayToList3() {
+        final String[] expectedSolutionsX = { "[]", "[a]", "[a, b]", "[a, b, c]"};
+        final String[] expectedSolutionsY = { "[a, b, c]", "[b, c]", "[c]", "[]"};
+
+        Term l = Term.termArrayToList(
+                new Term[] { new Atom("a"), new Atom("b"), new Atom("c") });
+        Query q = new Query(new Compound("append",  // append(X, Y, [a, b, c])
+                new Term[] { new Variable("X"), new Variable("Y"), l }));
+
+        Map<String, Term>[] sol = q.allSolutions();
+        for (int i = 0; i < sol.length; i++) {
+
+            String ListX = Arrays.toString(Term.atomListToStringArray(sol[i].get("X")));
+            String ListY = Arrays.toString(Term.atomListToStringArray(sol[i].get("Y")));
+
+
+            assertEquals("Bad X in append(X, Y, [a, b, c])", expectedSolutionsX[i], ListX);
+            assertEquals("Bad Y in append(X, Y, [a, b, c])", expectedSolutionsY[i], ListY);
+
+        }
+    }
+
+
+    @Test
+    public void testStringToList() {
+        String goal = "append(Xs,Ys,[a,b,c,d,e])";
+        assertTrue(goal + " has 6 solutions", Query.allSolutions(goal).length == 6);
+    }
+
+
+
+
+
+    @Test
+    public void testLength1() {
+        Query q5 = new Query(new Compound("length", new Term[]{new Variable("Zs"), new Integer(2)}));
+        Term zs = q5.oneSolution().get("Zs");
+        assertTrue("length(Zs,2) binds Zs to a list of two distinct variables " + zs.toString(),
+                zs.isListPair() && zs.arg(1).isVariable() &&
+                        zs.arg(2).isListPair() && zs.arg(2).arg(1).isVariable()
+                        && zs.arg(2).arg(2).isListNil() &&
+                        !zs.arg(1).name().equals(zs.arg(2).arg(1).name()));
     }
 
     @Test
@@ -188,4 +278,30 @@
     // }
 
 
+    @Test
+    public void test_textToTerm_and_toString() {
+        final String[] options = { "[]", "[1,2,3]", "[1]", "[1,g(2,3,5),[1,2,3],abc,[1],a,[],b]", "[[1,2,3]]" };
+        final String[] options2 = { "[]", "[1, 2, 3]", "[1]", "[1, g(2, 3, 5), [1, 2, 3], abc, [1], a, [], b]", "[[1, 2, 3]]" };
+
+        Term t;
+        Term s;
+        String msg;
+        String opt, opt2;
+        for (int i = 0; i < options.length; i++) {
+            opt = options[i];
+            msg = String.format("test Term.textToTerm on: %s", opt);
+
+            t = Term.textToTerm(opt);
+            s = Query.oneSolution(String.format("X = %s", opt)).get("X");
+            assertTrue(msg, t.isList());
+            assertEquals(t, s);
+
+            opt2 = options2[i];
+            msg = String.format("test Term.toString() on: %s", opt);
+            assertEquals(msg, opt2, s.toString());
+
+        }
+    }
+
+
 }
diff --git a/packages/jpl/src/java/org/jpl7/test/junit/QueryBuilder.java b/packages/jpl/src/java/org/jpl7/test/junit/QueryBuilder.java
index aa057b5..49dd107 100644
--- a/packages/jpl/src/java/org/jpl7/test/junit/QueryBuilder.java
+++ b/packages/jpl/src/java/org/jpl7/test/junit/QueryBuilder.java
@@ -55,7 +55,7 @@
 
     @Test
     public void testTerm1() {
-        Term args = Util.textToTerm("[1,2,3,4,5]");
+        Term args = Term.textToTerm("[1,2,3,4,5]");
         Term t = new Compound("member", new Term[] { new Integer(1), args } );
         Query q = new Query(t);
         assertTrue("Query should have succeded, but it did not!", q.hasSolution());
@@ -99,7 +99,7 @@
 
     @Test
     public void testString3() {
-        Term[] args = new Term[] { new Integer(1), Util.textToTerm("[1,2,3,4,5]") };
+        Term[] args = new Term[] { new Integer(1), Term.textToTerm("[1,2,3,4,5]") };
 
         Query q = new Query("member(?, ?)", args);
         assertTrue("Query should have succeded, but it did not!", q.hasSolution());
@@ -107,7 +107,7 @@
 
     @Test
     public void testString4() {
-        Term[] args = new Term[] { new Integer(1), Util.textToTerm("[1,2,3,4,5]") };
+        Term[] args = new Term[] { new Integer(1), Term.textToTerm("[1,2,3,4,5]") };
 
         Query q = new Query("member", args);
         assertTrue("Query should have succeded, but it did not!", q.hasSolution());
@@ -154,7 +154,7 @@
     // Error in number of placeholder matching arguments (too many terms)
     @Test
     public void testStringErr3() {
-        Term[] args = new Term[] { new Integer(1), Util.textToTerm("[1,2,3,4,5]") };
+        Term[] args = new Term[] { new Integer(1), Term.textToTerm("[1,2,3,4,5]") };
 
         try {
             Query q = new Query("member(?, ?, ?)", args);
@@ -170,7 +170,7 @@
     // Error in number of placeholder matching arguments (too many terms)
     @Test
     public void testStringErr4() {
-        Term[] args = new Term[] { new Integer(1), Util.textToTerm("[1,2,3,4,5]") };
+        Term[] args = new Term[] { new Integer(1), Term.textToTerm("[1,2,3,4,5]") };
 
         try {
             Query q = new Query("member(?)", args);
diff --git a/packages/pengines/pengines_io.pl b/packages/pengines/pengines_io.pl
index 1cbda43..4ead632 100644
--- a/packages/pengines/pengines_io.pl
+++ b/packages/pengines/pengines_io.pl
@@ -529,8 +529,15 @@
 
 list_clauses([]).
 list_clauses([H|T]) :-
-    portray_clause(H),
+    (   system_undefined(H)
+    ->  true
+    ;   portray_clause(H)
+    ),
     list_clauses(T).
+
+system_undefined((undefined :- tnot(undefined))).
+system_undefined((answer_count_restraint :- tnot(answer_count_restraint))).
+system_undefined((radial_restraint :- tnot(radial_restraint))).
 
 dict_bindings(Dict, Bindings) :-
     dict_pairs(Dict, _Tag, Pairs),
diff --git a/packages/semweb/doc/rdfdb.md b/packages/semweb/doc/rdfdb.md
index 53ec4d6..31770d7 100644
--- a/packages/semweb/doc/rdfdb.md
+++ b/packages/semweb/doc/rdfdb.md
@@ -70,7 +70,6 @@
   * [[rdf_retractall/3]]
   * [[rdf_retractall/4]]
   * [[rdf_update/4]]
-  * [[rdf_update/5]]
 
 ## Update view, transactions and snapshots {#semweb-update-view}
 
diff --git a/packages/semweb/rdf11.pl b/packages/semweb/rdf11.pl
index 26ae83f..c30b0ef 100644
--- a/packages/semweb/rdf11.pl
+++ b/packages/semweb/rdf11.pl
@@ -364,7 +364,7 @@
 %!  rdf_update(+S, +P, +O, ++Action) is det.
 %!  rdf_update(+S, +P, +O, +G, ++Action) is det.
 %
-%   Replaces one of  the  three  fields   on  the  matching  triples
+%   Replaces one of the three  (four)   fields  on  the matching triples
 %   depending on Action:
 %
 %     * subject(Resource)
@@ -376,14 +376,14 @@
 %     literal(Value).
 %     * graph(Graph)
 %     Moves the triple from its current named graph to Graph.
-%     This only works with rdf_update/4 and will throw an error when
-%     used with rdf_update/3.
-%
-%   The argument matching  the  action  must   be  ground.  If  this
-%   argument is equivalent to  the  current   value,  no  action  is
-%   performed. Otherwise, the requested action   is performed on all
-%   matching triples.  For example, all resources typed `rdfs:Class`
-%   can be changed to `owl:Class` using
+%     This only works with rdf_update/5 and throws an error when
+%     used with rdf_update/4.
+%
+%   The argument matching Action must  be   ground.  If this argument is
+%   equivalent to the current value, no  action is performed. Otherwise,
+%   the requested action is  performed  on   all  matching  triples. For
+%   example,  all  resources  typed  `rdfs:Class`   can  be  changed  to
+%   `owl:Class` using
 %
 %     ```
 %     ?- rdf_update(_, rdf:type, rdfs:'Class',
diff --git a/packages/semweb/rdf_db.pl b/packages/semweb/rdf_db.pl
index 59cf290..cb1845b 100644
--- a/packages/semweb/rdf_db.pl
+++ b/packages/semweb/rdf_db.pl
@@ -567,9 +567,10 @@
 %   useful to remove all triples coming from a loaded file. See also
 %   rdf_unload/1.
 
-%!  rdf_update(+Subject, +Predicate, +Object, +Action) is det.
-%
-%   Replaces one of  the  three  fields   on  the  matching  triples
+%!  rdf_update(+Subject, +Predicate, +Object, ++Action) is det.
+%!  rdf_update(+Subject, +Predicate, +Object, +Graph, ++Action) is det
+%
+%   Replaces one of the three  (four)   fields  on  the matching triples
 %   depending on Action:
 %
 %     * subject(Resource)
@@ -581,10 +582,8 @@
 %     literal(Value).
 %     * graph(Graph)
 %     Moves the triple from its current named graph to Graph.
-
-%!  rdf_update(+Subject, +Predicate, +Object, +Graph, +Action) is det
-%
-%   As rdf_update/4 but allows for specifying the graph.
+%     This only works with rdf_update/5 and throws an error when
+%     used with rdf_update/4.
 
 
                  /*******************************
diff --git a/packages/sgml/parser.c b/packages/sgml/parser.c
index bb2a0c1..8f1d402 100644
--- a/packages/sgml/parser.c
+++ b/packages/sgml/parser.c
@@ -3,8 +3,9 @@
     Author:        Jan Wielemaker
     E-mail:        J.Wielemaker@vu.nl
     WWW:           http://www.swi-prolog.org
-    Copyright (c)  2000-2015, University of Amsterdam
+    Copyright (c)  2000-2020, University of Amsterdam
                               VU University Amsterdam
+			      CWI, Amsterdam
     All rights reserved.
 
     Redistribution and use in source and binary forms, with or without
@@ -2727,8 +2728,8 @@
 validate_completeness(dtd_parser *p, sgml_environment *env)
 { if ( !complete(env) )
   { wchar_t buf[MAXNMLEN+50];
-
-    swprintf(buf, MAXNMLEN+50, L"Incomplete element: <%s>",
+    buf[MAXNMLEN+49] = 0;
+    swprintf(buf, MAXNMLEN+49, L"Incomplete element: <%s>",
 	     env->element->name->name);
 
     gripe(p, ERC_VALIDATE, buf);		/* TBD: expected */
@@ -5481,12 +5482,13 @@
 static wchar_t *
 format_location(wchar_t *s, size_t len, dtd_srcloc *l)
 { int first = TRUE;
-  wchar_t *e = &s[len];
-
+  wchar_t *e = &s[len-1];
+
+  assert(len > 0);
   if ( !l || l->type == IN_NONE || len == 0 )
     return s;
 
-  e[-1] = L'\0';
+  *e = L'\0';
   for( ; l && l->type != IN_NONE;
          l = l->parent, first = FALSE )
   { if ( !first )
@@ -5587,6 +5589,7 @@
   int dtdmode = FALSE;
   void *freeme = NULL;
 
+  buf[MAX_MESSAGE_LEN] = 0;
   va_start(args, e);
 
   memset(&error, 0, sizeof(error));
diff --git a/packages/swipl-win/Preferences.cpp b/packages/swipl-win/Preferences.cpp
index a41216b..4fd3a34 100644
--- a/packages/swipl-win/Preferences.cpp
+++ b/packages/swipl-win/Preferences.cpp
@@ -51,10 +51,12 @@
 /** get configured values, with reasonable defaults
  */
 Preferences::Preferences(QObject *parent) :
-    QSettings("SWI-Prolog", "pqConsole", parent)
+    QSettings("swi-prolog", "pqConsole", parent)
 {   qDebug() << "Loading preferences from " << fileName();
 
-    console_font = value("console_font", QFont("courier", 12)).value<QFont>();
+    QFont default_font("Monospace");
+    default_font.setStyleHint(QFont::Monospace);
+    console_font = value("console_font", default_font).value<QFont>();
     wrapMode = static_cast<ConsoleEditBase::LineWrapMode>(value("wrapMode", ConsoleEditBase::WidgetWidth).toInt());
 
     console_out_fore = value("console_out_fore", 0).toInt();
diff --git a/packages/xpce/Defaults.user b/packages/xpce/Defaults.user
index 30908eb..7f57a14 100644
--- a/packages/xpce/Defaults.user
+++ b/packages/xpce/Defaults.user
@@ -76,9 +76,15 @@
 ! to use tabs (@on).  PceEmacs detects body_indentation and
 ! indent_tabs from the first clause when editing an existing file.
 
-!emacs_prolog_mode.body_indentation: 4
-!emacs_prolog_mode.cond_indentation: 4
-!emacs_prolog_mode.indent_tabs:	     @off
+!emacs_prolog_mode.body_indentation:     4
+!emacs_prolog_mode.cond_indentation:     4
+!emacs_prolog_mode.indent_tabs:	         @off
+
+! How to add a new set of dependencies for ->update_dependencies
+! (^c^d).  Possible values are autoload/1, autoload/2, use_module/1
+! and use_module/2.
+
+!emacs_prolog_mode.dependency_directive: autoload/2
 
 ! Comment column for M-; This may be refined by mode (e.g. emacs_prolog_mode,
 ! etc.)
diff --git a/packages/xpce/INFO b/packages/xpce/INFO
deleted file mode 100644
index 85eda34..0000000
--- a/packages/xpce/INFO
+++ /dev/null
@@ -1,75 +0,0 @@
-			XPCE: a portable GUI toolkit
-			============================
-
-Author:
-=======
-
-	Jan Wielemaker		jan@swi.psy.uva.nl
-	Anjo Anjewierden	anjo@swi.psy.uva.nl
-	SWI,
-	University of Amsterdam
-	Roetersstraat 15
-	1018 WB  Amsterdam
-	The Netherlands
-	http://www.swi.psy.uva.nl
-
-URL:
-====
-
-	xpce-bugs@swi.psy.uva.nl		Bug reports
-	xpce-request@swi.psy.uva.nl		General info and mailing list
-	xpce@swi.psy.uva.nl			Mailing list
-	http://swi-prolog.org/packages/xpce	Project Home Page
-	ftp://swi.psy.uva.nl/xpce		Various public resources
-
-OS Platforms:
-=============
-
-	Unix/X11 (most brands, including 64-bit platforms)
-	Win32    (Windows 95/98/ME, NT/2000/XP, Intel)
-	
-Hosting languages
-=================
-
-	SWI-Prolog	http://www.swi-prolog.org
-
-	Ports to the following have existed and are in not too bad
-	shape.
-
-	Quintus Prolog	http://www.sics.se/quintus/
-	SICStus Prolog  http://www.sics.se/
-	
-	Considering the costs of maintaining portable Prolog
-	code given the current status of the standard, we will only
-	produce versions for other Prolog systems if this situation
-	improves or we get hold of sufficient resources to maintain
-	portability.
-
-Documentation
-=============
-
-	# Programming in XPCE/Prolog
-	Userguide to get you started.  Explains the interface, object
-	model as well as creating new classes.  Provides `technique'
-	sections, explaining how commonly encountered problems may
-	be solved using XPCE.
-
-	# Course Notes
-	Document explaining roughly the same material as ``Programming
-	in XPCE/Prolog'' in a condensed form.
-
-	# Reference Manual
-	Available using the built-in online help-system.  Includes
-	various fully dynamic viewpoints to the reference material.
-
-
-Licenses
-========
-
-	* XPCE is distributed as free software with sufficient escapes
-	to generate non-free applications.  The license conditions are
-	in the source-files.  An overall discussion on the license
-	issues can be found with SWI-Prolog, which is distributed under
-	exactly these conditions.  For details, see:
-
-		http://www.swi-prolog.org/license.html
diff --git a/packages/xpce/INSTALL.md b/packages/xpce/INSTALL.md
deleted file mode 100644
index 99fb56d..0000000
--- a/packages/xpce/INSTALL.md
+++ /dev/null
@@ -1,232 +0,0 @@
-# Installing XPCE/Prolog from source
-
-Normally, xpce is provided as `packages/xpce` in the SWI-Prolog sources.
-It     is     build      as      part       of      SWI-Prolog.      See
-http://www.swi-prolog.org/build/index.txt for building   SWI-Prolog  and
-xpce.
-
-The documentation below is in part out of date, but left as a reference.
-Configuration, compilation and installation is based on the GNU autoconf
-package.
-
-## Required tools
-
-	- GNU-Make
-	Non-gnu versions of make will fail.
-
-	- GCC or clang
-	Necessary on most machines, though you might get away with
-	another ANSI C compiler.
-
-	- libXpm
-	The X11 XPM (XPixMap) format libary for handling coloured and
-	masked images.  For any popular Unix platform you should be
-	able to find this package.  For the Windows built we provide
-	a port at https://github.com/SWI-Prolog/libXpm.git
-
-	- libjpeg
-	The JPEG group library for handling JPEG images.
-
-	- Freetype
-	Not really required, but if present the system will use the
-	Freetype library to realise scalable and antialiased fonts.
-	Its presence is detected by looking for the program xft-config,
-	which is also used to determine compile and link flags.  If
-	you want to build WITHOUT XFT and you have the library installed,
-	set the environment variable XFTCONFIG=false.
-
-
-For all other required tools, both the   GNU,  BSD and System-V versions
-are supposed to work properly.
-
-## Bluffers Installation Guide
-
-To install XPCE/SWI-Prolog from the sources:
-
-	1. Build SWI-Prolog according to the instructions and install it.
-	2. Determine an installation prefix (normally use the same as for
-	   SWI-Prolog, we use `linux' in this example).
-	3. Run the following commands
-
-		% mkdir linux
-		% cd linux
-		% ../src/configure
-		% make
-		% make install
-
-# Detailed Installation Guide
-
-We start at the SWI-Prolog  installation,   as  this  needs some special
-considerations on some platforms.
-
-
-## Choosing the build-directory
-
-You can place the directory for   building  XPCE/Prolog anywhere. A good
-choice is /usr/local/src or, if you are   installing  as a private user,
-$HOME/src. Unpack the Prolog and XPCE archives from the same directory:
-
-	% gunzip < pl-<version>.tar.gz | tar xvfB -
-	% gunzip < xpce-<version>.tar.gz | tar xvfB -
-
-NOTES:
-
-	- Some versions of tar hate reading from a pipe.  In that case
-	use `gunzip file.tar.gz' followed by `tar xvf file.tar' to extract
-	the archives
-
-	- If you are using GNU-tar, `tar zxvf file.tar.gz' is easier.
-
-
-## Choosing a build sub-directory
-
-For easy cleanup or building for   multiple directories, both SWI-Prolog
-and XPCE are normally built in a   directory  next to the src directory.
-The name is not important. Good examples  are `sunos' `linux', etc. In
-the examples below, we use `linux'.
-
-
-## The Destination Prefix (configure --prefix=dir)
-
-GNU autoconf-based packages accept the   flag  --prefix=<dir> to specify
-the destination. The installation will use the following subdirectories:
-
-```
-	bin			For making *links* to the executables
-	man/man1		For installing the manual pages
-	include			For installing the SWI-Prolog.h header file
-	lib/pl-<version>	For installing libs, executables, etc.
-	lib			For installing public shared objects (if any)
-```
-
-The default prefix is /usr/local.  If   you  choose  another one (assume
-/home/projects/bigmoney), do (if the  directory   structure  is  not yet
-available):
-
-	% cd /home/projects/bigmoney
-	% mkdir bin man man/man1 include lib
-
-Make sure the binary directory is in your PATH!
-
-## Preparing SWI-Prolog
-
-	% cd pl-<version>
-	% mkdir linux
-	% cd linux
-	% ../src/configure
-
-## Shared libraries or not?
-
-By default, the installation atempts to   build SWI-Prolog and load xpce
-as a shared object (.so file on   most  Unix machines) into Prolog. This
-installation is better to maintain and   prepares SWI-Prolog for loading
-custom extensions written in C in a well supported manner.
-
-Now, shared libraries are  used  on  all   systems  and  the  the static
-alternative is no longer actively maintained. When  porting to a new OS,
-please check the shared library facilities   of the SWI-Prolog plld tool
-and make sure it runs on your environment.
-
-## Preparing XPCE
-
-XPCE extracts most information about  the configuration from SWI-Prolog,
-so it is generally much easier. Most of the configure run is simple, but
-configure needs to find out where the   X11  libraries and include files
-are  and  you  may  have   multiple.    Normally,   it  will  first  try
-/usr/include/X11 and /usr/lib. If  you  have   only  one  version of X11
-around, generally configure will be able to find it.
-
-If you have multiple copies of X11 around,   you have to decide which to
-use. If you are compiling for local  usage,   use  the  one most of your
-local packages use to improve resource   sharing. Otherwise, use the one
-distributed with the OS or known to be most commonly in use by your user
-community. For example, our system has the   MIT X11R6 libs and includes
-in  /usr/lib  and  /usr/include/X11  and  the  OpenWindows  versions  in
-/usr/openwin/lib  and  /usr/openwin/include/X11.  For  local  usage,  we
-configure without options to use the X11R6  version, used by most of the
-other X11 software we run locally. For distribution, we configure using:
-
-	--x-includes=/usr/openwin/include --x-libraries=/usr/openwin/lib
-
-## Checking Program versions
-
-Just to make sure your programs are accessible and of the right version,
-try:
-
-	% swipl -v
-	SWI-Prolog version 5.3.9 for i686-linux
-	% make -v
-	GNU Make 3.80
-	...
-	% gcc -v
-	gcc -v
-	Reading specs from /usr/lib/gcc-lib/i586-suse-linux/3.3.1/specs
-	...
-	gcc version 3.3.1 (SuSE Linux)
-
-Now, run configure:
-
-	% cd xpce-<version>
-	% mkdir linux
-	% ../src/configure <options>
-
-## Building the library
-
-Now, make the XPCE library:
-
-	% make xpce
-
-If you have configured for using shared libraries, the -fPIC flag should
-be passed to the compiler. If this is  not the case, please look closely
-at the steps above. If all goes well, the compilation should finish with
-few warnings, resulting in the library libXPCE.a
-
-
-## Building the interface:
-
-With write premission to the Prolog home directory, now do the following
-to make the interface.
-
-	% make pl-itf
-
-This command will run  either  `make   pl-shared'  or  `make pl-static',
-depending on whether SWI-Prolog handles shared objects. The first builds
-the pl2xpce.so shared object, and the   second builds an XPCE executable
-holding both the Prolog kernel and the XPCE library called `xpce'.
-
-Both versions will put various things   in the SWI-Prolog home directory
-to make XPCE known to Prolog:
-
-	* A link to the xpce build-directory
-	* A swipl.rc script to register the xpce library
-	* A Makefile to recompile the XPCE/Prolog quick-load-files
-
-## Testing XPCE
-
-Now, if you have build  for  a   shared  object,  xpce  is a dynamically
-loadable Prolog library, so to test it simply do:
-
-	% swipl
-	?- manpce.
-
-which should start the manual tools.
-
-## Installing the XPCE library
-
-Finally, to install the XPCE libraries, do:
-
-	% make install
-
-Which will:
-
-	- Create a directory xpce-<version> in the Prolog home and
-	copy the Prolog libraries, manual data and other resources
-	into this directory.
-
-	- In the Prolog home, make a link from xpce to xpce-<version>
-
-	- run `make' in the Prolog home directory to make quick-load
-	versions of some large and frequently used library packages.
-
-	- in $exec_prefix/bin, make links to the xpce and xpce-client
-	executables
diff --git a/packages/xpce/cmake/XPCESources.cmake b/packages/xpce/cmake/XPCESources.cmake
index 76eb82a..378c357 100644
--- a/packages/xpce/cmake/XPCESources.cmake
+++ b/packages/xpce/cmake/XPCESources.cmake
@@ -193,7 +193,8 @@
     javascript_mode.pl language_mode.pl latex_mode.pl logtalk_mode.pl
     man_mode.pl outline_mode.pl prolog_mode.pl prompt.pl rdf_mode.pl
     script_mode.pl server.pl sgml_mode.pl shell.pl swi_prolog.pl
-    text_mode.pl turtle_mode.pl window.pl yaml_mode.pl cmake_mode.pl)
+    text_mode.pl turtle_mode.pl window.pl yaml_mode.pl cmake_mode.pl
+    help_buffer.pl)
 
 set(XPCE_DATA_prolog_lib_english pce_messages.pl)
 
@@ -386,4 +387,4 @@
 set(XPCE_QLF_emacs emacs/window.pl emacs/buffer.pl emacs/application.pl
     emacs/buffer_menu.pl emacs/server.pl emacs/history.pl
     emacs/fundamental_mode.pl emacs/language_mode.pl emacs/outline_mode.pl
-    emacs/bookmarks.pl)
+    emacs/bookmarks.pl emacs/help_buffer.pl)
diff --git a/packages/xpce/install-sh b/packages/xpce/install-sh
deleted file mode 100755
index ab74c88..0000000
--- a/packages/xpce/install-sh
+++ /dev/null
@@ -1,238 +0,0 @@
-#!/bin/sh
-#
-# install - install a program, script, or datafile
-# This comes from X11R5.
-#
-# Calling this script install-sh is preferred over install.sh, to prevent
-# `make' implicit rules from creating a file called install from it
-# when there is no Makefile.
-#
-# This script is compatible with the BSD install script, but was written
-# from scratch.
-#
-
-
-# set DOITPROG to echo to test this script
-
-# Don't use :- since 4.3BSD and earlier shells don't like it.
-doit="${DOITPROG-}"
-
-
-# put in absolute paths if you don't have them in your path; or use env. vars.
-
-mvprog="${MVPROG-mv}"
-cpprog="${CPPROG-cp}"
-chmodprog="${CHMODPROG-chmod}"
-chownprog="${CHOWNPROG-chown}"
-chgrpprog="${CHGRPPROG-chgrp}"
-stripprog="${STRIPPROG-strip}"
-rmprog="${RMPROG-rm}"
-mkdirprog="${MKDIRPROG-mkdir}"
-
-tranformbasename=""
-transform_arg=""
-instcmd="$mvprog"
-chmodcmd="$chmodprog 0755"
-chowncmd=""
-chgrpcmd=""
-stripcmd=""
-rmcmd="$rmprog -f"
-mvcmd="$mvprog"
-src=""
-dst=""
-dir_arg=""
-
-while [ x"$1" != x ]; do
-    case $1 in
-	-c) instcmd="$cpprog"
-	    shift
-	    continue;;
-
-	-d) dir_arg=true
-	    shift
-	    continue;;
-
-	-m) chmodcmd="$chmodprog $2"
-	    shift
-	    shift
-	    continue;;
-
-	-o) chowncmd="$chownprog $2"
-	    shift
-	    shift
-	    continue;;
-
-	-g) chgrpcmd="$chgrpprog $2"
-	    shift
-	    shift
-	    continue;;
-
-	-s) stripcmd="$stripprog"
-	    shift
-	    continue;;
-
-	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
-	    shift
-	    continue;;
-
-	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
-	    shift
-	    continue;;
-
-	*)  if [ x"$src" = x ]
-	    then
-		src=$1
-	    else
-		# this colon is to work around a 386BSD /bin/sh bug
-		:
-		dst=$1
-	    fi
-	    shift
-	    continue;;
-    esac
-done
-
-if [ x"$src" = x ]
-then
-	echo "install:	no input file specified"
-	exit 1
-else
-	true
-fi
-
-if [ x"$dir_arg" != x ]; then
-	dst=$src
-	src=""
-	
-	if [ -d $dst ]; then
-		instcmd=:
-	else
-		instcmd=mkdir
-	fi
-else
-
-# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
-# might cause directories to be created, which would be especially bad 
-# if $src (and thus $dsttmp) contains '*'.
-
-	if [ -f $src -o -d $src ]
-	then
-		true
-	else
-		echo "install:  $src does not exist"
-		exit 1
-	fi
-	
-	if [ x"$dst" = x ]
-	then
-		echo "install:	no destination specified"
-		exit 1
-	else
-		true
-	fi
-
-# If destination is a directory, append the input filename; if your system
-# does not like double slashes in filenames, you may need to add some logic
-
-	if [ -d $dst ]
-	then
-		dst="$dst"/`basename $src`
-	else
-		true
-	fi
-fi
-
-## this sed command emulates the dirname command
-dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
-
-# Make sure that the destination directory exists.
-#  this part is taken from Noah Friedman's mkinstalldirs script
-
-# Skip lots of stat calls in the usual case.
-if [ ! -d "$dstdir" ]; then
-defaultIFS='	
-'
-IFS="${IFS-${defaultIFS}}"
-
-oIFS="${IFS}"
-# Some sh's can't handle IFS=/ for some reason.
-IFS='%'
-set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
-IFS="${oIFS}"
-
-pathcomp=''
-
-while [ $# -ne 0 ] ; do
-	pathcomp="${pathcomp}${1}"
-	shift
-
-	if [ ! -d "${pathcomp}" ] ;
-        then
-		$mkdirprog "${pathcomp}"
-	else
-		true
-	fi
-
-	pathcomp="${pathcomp}/"
-done
-fi
-
-if [ x"$dir_arg" != x ]
-then
-	$doit $instcmd $dst &&
-
-	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
-	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
-	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
-	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
-else
-
-# If we're going to rename the final executable, determine the name now.
-
-	if [ x"$transformarg" = x ] 
-	then
-		dstfile=`basename $dst`
-	else
-		dstfile=`basename $dst $transformbasename | 
-			sed $transformarg`$transformbasename
-	fi
-
-# don't allow the sed command to completely eliminate the filename
-
-	if [ x"$dstfile" = x ] 
-	then
-		dstfile=`basename $dst`
-	else
-		true
-	fi
-
-# Make a temp file name in the proper directory.
-
-	dsttmp=$dstdir/#inst.$$#
-
-# Move or copy the file name to the temp name
-
-	$doit $instcmd $src $dsttmp &&
-
-	trap "rm -f ${dsttmp}" 0 &&
-
-# and set any options; do chmod last to preserve setuid bits
-
-# If any of these fail, we abort the whole thing.  If we want to
-# ignore errors from any of these, just make sure not to ignore
-# errors from the above "$doit $instcmd $src $dsttmp" command.
-
-	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
-	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
-	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
-	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
-
-# Now rename the file to the real destination.
-
-	$doit $rmcmd -f $dstdir/$dstfile &&
-	$doit $mvcmd $dsttmp $dstdir/$dstfile 
-
-fi &&
-
-
-exit 0
diff --git a/packages/xpce/man/reference/class/application.doc b/packages/xpce/man/reference/class/application.doc
index 06d6df6..0f36966 100644
Binary files a/packages/xpce/man/reference/class/application.doc and b/packages/xpce/man/reference/class/application.doc differ
diff --git a/packages/xpce/newversion b/packages/xpce/newversion
deleted file mode 100755
index ef7671a..0000000
--- a/packages/xpce/newversion
+++ /dev/null
@@ -1,45 +0,0 @@
-#!/bin/sh
-
-function confirm ()
-{ while true; do
-    echo -n "$1 "
-    read answer
-    case "$answer" in
-          y*)   return 0
-                ;;
-          n*)   return 1
-                ;;
-          *)
-                echo "Please answer yes or no"
-                ;;
-    esac
-  done
-}
-
-version=`cat VERSION`
-versiondate=`date +"%B %Y"`
-major=`echo $version | sed 's/\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)/\1/'`
-minor=`echo $version | sed 's/\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)/\2/'`
-patch=`echo $version | sed 's/\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)/\3/'`
-
-tmp=.tmp$$
-
-f=src/Makefile.in
-sed "s/^PCEVERSIONDATE=.*/PCEVERSIONDATE=$versiondate/" $f > $tmp
-if cmp $f $tmp; then
-    rm -f $tmp
-else
-    cp $tmp $f
-    echo "Updated PCEVERSIONDATE in $f"
-fi
-
-f=src/h/interface.h
-sed "s/^#define PCE_VERSION.*/#define PCE_VERSION "\""$version, $versiondate"\"/ $f > $tmp
-if cmp $f $tmp; then
-    rm -f $tmp
-else
-    cp $tmp $f
-    echo "Updated #define PCE_VERSION in $f"
-fi
-
-rm -f $tmp
diff --git a/packages/xpce/prolog/lib/doc/html.pl b/packages/xpce/prolog/lib/doc/html.pl
index 406adcd..8734726 100644
--- a/packages/xpce/prolog/lib/doc/html.pl
+++ b/packages/xpce/prolog/lib/doc/html.pl
@@ -3,7 +3,7 @@
     Author:        Jan Wielemaker and Anjo Anjewierden
     E-mail:        jan@swi.psy.uva.nl
     WWW:           http://www.swi.psy.uva.nl/projects/xpce/
-    Copyright (c)  2000-2011, University of Amsterdam
+    Copyright (c)  2000-2020, University of Amsterdam
     All rights reserved.
 
     Redistribution and use in source and binary forms, with or without
@@ -104,7 +104,9 @@
       @br
     ].
 element(div, A, C) -->                  % <DIV>
-    element(p, A, C).               % TBD: Should force clearance of
+    element(p, A, C).                   % TBD: Should force clearance of
+element(span, _, C) -->
+    seq(C).
                                         % shape-graphicals!
 element(br, _, _) -->                   % <BR>
     [ @br,
@@ -326,7 +328,8 @@
         ]
     ).
 element(a, Attr, Content) -->           % <A NAME=<Label>> ... </A>
-    { memberchk(name=Label, Attr)
+    { memberchk(id=Label, Attr)
+    ; memberchk(name=Label, Attr)
     },
     !,
     [ \anchor(Label, Content)
@@ -360,7 +363,7 @@
 %       Preformatted output
 
 element(pre, _, Content) -->            % <PRE>
-    [ @br,
+    [ \parskip,
       \group([ \setfont(fixed, @on),
                \pre(Content)
              ]),
@@ -381,6 +384,8 @@
 element(meta, _, _) -->                 % <META>
     [].
 element(link, _, _) -->                 % <LINK>
+    [].
+element(script, _, _) -->               % <SCRIPT>
     [].
 element(body, Attributes, Content) -->  % <BODY>
     [ \body(Attributes)
@@ -539,6 +544,9 @@
     catch(number_chars(Num, Chars), _, fail),
     Frac is Num/100.
 
+seq([])    --> [].
+seq([H|T]) --> [H], seq(T).
+
                  /*******************************
                  *            MESSAGES          *
                  *******************************/
diff --git a/packages/xpce/prolog/lib/emacs/application.pl b/packages/xpce/prolog/lib/emacs/application.pl
index d2f8056..a5dc3c7 100644
--- a/packages/xpce/prolog/lib/emacs/application.pl
+++ b/packages/xpce/prolog/lib/emacs/application.pl
@@ -51,6 +51,8 @@
 
 :- pce_begin_class(emacs, application,
                    "PceEmacs main object").
+
+class_variable(icon_image, image*, @pce_image).
 
 variable(buffer_list,   dict,    get, "List of buffers maintained").
 variable(history,       history, get, "History of visited places").
diff --git a/packages/xpce/prolog/lib/emacs/emacs.pl b/packages/xpce/prolog/lib/emacs/emacs.pl
index e50925a..190be1d 100644
--- a/packages/xpce/prolog/lib/emacs/emacs.pl
+++ b/packages/xpce/prolog/lib/emacs/emacs.pl
@@ -87,6 +87,7 @@
 :- consult(language_mode).
 :- consult(outline_mode).
 :- consult(bookmarks).
+:- consult(help_buffer).
 
 
                  /*******************************
diff --git a/packages/xpce/prolog/lib/emacs/help_buffer.pl b/packages/xpce/prolog/lib/emacs/help_buffer.pl
new file mode 100644
index 0000000..ae92d7b
--- /dev/null
+++ b/packages/xpce/prolog/lib/emacs/help_buffer.pl
@@ -0,0 +1,83 @@
+/*  Part of XPCE --- The SWI-Prolog GUI toolkit
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2020, VU University Amsterdam
+			 CWI, Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(emacs_show_help, []).
+:- use_module(library(pce), [new/2, pce_open/3, send/2, op(_,_,_)]).
+:- autoload(library(sgml), [load_html/3]).
+:- autoload(library(lynx/html_text),[html_text/2]).
+:- autoload(library(pce_emacs), [start_emacs/0]).
+
+/** <module> Capture help in a PceEmacs buffer
+
+This module captures the  output  of   _Documentation_  in  the PceEmacs
+buffer ``*Documentation*``.
+
+@tbd	We should made the output of html_text/2 interceptable at a
+	higher level of abstraction such that we can create nice
+        coloured fragments.
+*/
+
+:- multifile
+    prolog_help:show_html_hook/1.
+
+prolog_help:show_html_hook(HTMLString) :-
+    thread_self(pce),
+    start_emacs,
+    send(@emacs, location_history),
+    setup_call_cleanup(
+        open_string(HTMLString, In),
+        load_html(stream(In), DOM, []),
+        close(In)),
+    new(B, emacs_buffer(@nil, '*Documentation*')),
+    send(B, mode, text),
+    send(B, clear),
+    setup_call_cleanup(
+        pce_open(B, write, Out),
+        ( set_stream(Out, newline(posix)),
+          with_output_to(Out, html_text(DOM, []))
+        ),
+        close(Out)),
+    send(B, modified, @off),
+    (   send(B?editors, empty)
+    ->  send(B, open, tab)
+    ;   send(B?editors, for_all, message(@arg1, caret, 0)),
+        get(B?editors?head, frame, Frame),
+        send(Frame, tab, B, @on),
+        send(Frame, expose)
+    ),
+    send(@emacs, location_history, title := 'Documentation').
+
+
+
diff --git a/packages/xpce/prolog/lib/emacs/prolog_mode.pl b/packages/xpce/prolog/lib/emacs/prolog_mode.pl
index 51bdbdf..113b2b1 100644
--- a/packages/xpce/prolog/lib/emacs/prolog_mode.pl
+++ b/packages/xpce/prolog/lib/emacs/prolog_mode.pl
@@ -53,8 +53,8 @@
 	     delete_breakpoint/1,
 	     manpce/1,
 	     prolog_ide/1,
+	     rational/1,
 	     spypce/1,
-             trace/1,
 	     tracepce/1,
 	     atomic_list_concat/2,
 	     breakpoint_property/2,
@@ -65,19 +65,24 @@
 	     set_stream/2,
 	     source_file_property/2,
 	     string_codes/2,
+	     term_string/2,
 	     term_to_atom/2,
 	     absolute_file_name/3,
 	     atomic_list_concat/3,
 	     between/3,
 	     compound_name_arity/3,
 	     default/3,
+	     file_autoload_directives/3,
 	     file_name_extension/3,
 	     get_dict/3,
 	     nb_setarg/3,
+	     rational/3,
 	     send_list/3,
 	     setup_call_cleanup/3,
+	     stream_position_data/3,
 	     strip_module/3,
 	     xref_prolog_flag/4,
+	     get_dict/5,
 	     sub_string/5
 	   ]).
 
@@ -112,6 +117,8 @@
           view_threads                 = button(prolog),
           view_debug_messages          = button(prolog),
           -                            = button(prolog),
+          check_dependencies           = button(prolog),
+          update_dependencies          = key('\\C-c\\C-d') + button(prolog),
           check_clause                 = key('\\C-c\\C-s') + button(prolog),
           setup_auto_indent            = button(prolog),
           insert_full_stop             = key(.),
@@ -172,6 +179,13 @@
                typing).
 class_variable(auto_colourise_size_limit, int, 100000,
                "Auto-colourise if buffer is smaller then this").
+class_variable(dependency_directive,
+               { 'autoload/1',
+                 'autoload/2',
+                 'use_module/1',
+                 'use_module/2'
+               }, 'autoload/2',
+               "How to insert new dependencies").
 
 variable(varmark_style,    style*,       get, "How to mark variables").
 variable(has_var_marks,    bool := @off, get, "Optimise a bit").
@@ -187,13 +201,20 @@
 variable(cond_indentation, int,          get, "Indent step for conditional").
 variable(quasiquotation_syntax,
                            name*,        both, "Default quasiquotation syntax").
+variable(dependency_directive,
+         { 'autoload/1',
+           'autoload/2',
+           'use_module/1',
+           'use_module/2'
+         },
+         both,
+         "How to insert new dependencies").
 
 class_variable(quasiquotation_syntax, name*, @nil).
 class_variable(body_indentation,      int,   4).
 class_variable(cond_indentation,      int,   4).
 class_variable(indent_tabs,           bool,  @off,
                "Use tabs for indentation").
-
 
 icon(_, I:image) :<-
     "Return icon for mode"::
@@ -891,6 +912,186 @@
     "Consult selected text"::
     get(M, selection, point(From, To)),
     send(M, consult_region, From, To).
+
+
+		 /*******************************
+		 *         DEPENDENCIES		*
+		 *******************************/
+
+:- meta_predicate
+    to_kill_buffer(0).
+
+check_dependencies(E) :->
+    "See whether any dependencies are missing"::
+    get(E, text_buffer, TB),
+    file_autoload_directives(TB, Directives, [missing(true)]),
+    count_dependencies(Directives, Count),
+    (   Directives == []
+    ->  send(E, report, status, 'No missing dependencies')
+    ;   to_kill_buffer(maplist(portray_clause, Directives)),
+        send(E, report, warning,
+             'WARNING: %d missing dependencies.  \c
+              Use ^Y to insert required directives at caret.',
+             Count)
+    ).
+
+insert_dependencies(E) :->
+    "Insert :- autoload/2 directives"::
+    (   get(E, mark_status, active)
+    ->  get(E, selection, point(From, To))
+    ;   From = 0,
+        To = 0
+    ),
+    update_dependencies(E, From, To).
+
+update_dependencies(E) :->
+    "Update existing dependencies or add new block"::
+    get(E, find_dependencies, point(From, To)),
+    update_dependencies(E, From, To).
+
+update_dependencies(E, From, To) :-
+    read_terms_in_range(E, From, To, Terms),
+    directive_options(E, Terms, DirOptions),
+    get(E, text_buffer, TB),
+    file_autoload_directives(TB, Directives, [update(Terms)|DirOptions]),
+    (   append(Terms, New, Directives)
+    ->  (   New == []
+        ->  send(E, report, status, 'No updates required')
+        ;   add_new_dependencies(E, New, To),
+            count_dependencies(New, Count),
+            send(E, report, status, 'Added %d new dependencies', Count)
+        )
+    ;   send(E, delete, From, To),
+        add_new_dependencies(E, Directives, From),
+        send(E, report, status, 'Updated dependencies')
+    ).
+
+add_new_dependencies(E, Directives, At) :-
+    send(@emacs, location_history),
+    send(E, caret, At),
+    send(@emacs, location_history, title := 'Update dependencies'),
+    setup_call_cleanup(
+        pce_open(E, update, Out),
+        ( seek(Out, At, bof, _),
+          with_output_to(Out, maplist(portray_clause, Directives))
+        ),
+        close(Out)),
+    get(E, caret, End),
+    send(E, selection, At, End, highlight),
+    send(E, auto_colourise_buffer).
+
+directive_options(_E, Terms, []) :-
+    member(:-(Directive), Terms),
+    is_dependency(Directive),
+    !.
+directive_options(E, _, [directive(Pred)]) :-
+    get(E, dependency_directive, Atom),
+    term_string(Pred, Atom).
+
+count_dependencies(Directives, Deps) :-
+    maplist(directive_deps, Directives, Counts),
+    sum_list(Counts, Deps).
+
+directive_deps((:- autoload(_, Preds)), Count) :-
+    !,
+    length(Preds, Count).
+directive_deps((:- use_module(_, Preds)), Count) :-
+    !,
+    length(Preds, Count).
+directive_deps(_, 1).
+
+to_kill_buffer(Goal) :-
+    new(E, editor),
+    setup_call_cleanup(
+        pce_open(E, write, Out),
+        with_output_to(Out, Goal),
+        close(Out)),
+    get(E?text_buffer, size, Size),
+    send(E, grab, 0, Size),
+    free(E).
+
+read_selection(E, Terms:prolog) :<-
+    "Read the selection as a list of terms"::
+    get(E, selection, point(From, To)),
+    read_terms_in_range(E, From, To, Terms).
+
+read_terms_in_range(E, From, To, Terms) :-
+    To > From,
+    !,
+    setup_call_cleanup(
+        pce_open(E, read, In),
+        ( seek(In, From, bof, _),
+          read_terms_to(In, To, Terms)
+        ),
+        close(In)).
+read_terms_in_range(_, _, _, []).
+
+read_terms_to(In, End, Terms) :-
+    quiet_read_next(In, Term, _, Here),
+    !,
+    (   Term == end_of_file
+    ->  Terms = []
+    ;   (   Here > End
+        ->  Terms = []
+        ;   Terms = [Term|Rest],
+            read_terms_to(In, End, Rest)
+        )
+    ).
+read_terms_to(_, _, []).
+
+find_dependencies(E, Range:point) :<-
+    "Get start and end of dependencies"::
+    setup_call_cleanup(
+        pce_open(E, read, In),
+        find_dependencies(In, #{}, Dict),
+        close(In)),
+    get(E, text_buffer, TB),
+    (   _{start:Start, end:End0} :< Dict
+    ->  get(TB, scan, End0, line, 1, start, End),
+        new(Range, point(Start, End))
+    ;   _{module_decl_end:Start0} :< Dict
+    ->  get(TB, scan, Start0, line, 1, start, Start),
+        new(Range, point(Start, Start))
+    ;   _{program_start:Start0} :< Dict
+    ->  get(TB, scan, Start0, line, -1, start, Start),
+        new(Range, point(Start, Start))
+    ).
+
+find_dependencies(In, State0, State) :-
+    quiet_read_next(In, Term, F, T),
+    (   Term = :-(Directive)
+    ->  update_dep_state(Directive, F, T, State0, State1),
+        find_dependencies(In, State1, State)
+    ;   State = State0.put(program_start, F)
+    ).
+
+update_dep_state(module(_,_), _, T, State0, State) :-
+    !,
+    State = State0.put(module_decl_end, T).
+update_dep_state(Decl, S, E, State0, State) :-
+    is_dependency(Decl),
+    !,
+    (   get_dict(end, State0, _, State, E)
+    ->  true
+    ;   State = State0.put(#{start:S, end:E})
+    ).
+update_dep_state(_, _, _, State, State).
+
+is_dependency(autoload(_)).
+is_dependency(use_module(_)).
+is_dependency(autoload(_,_)).
+is_dependency(use_module(_,_)).
+
+quiet_read_next(In, Term, From, To) :-
+    between(1, 10, _),
+    read_term(In, Term,
+              [ syntax_errors(quiet),
+                term_position(Pos)
+              ]),
+    nonvar(Term),
+    stream_position_data(char_count, Pos, From),
+    character_count(In, To),
+    !.
 
 
                  /*******************************
diff --git a/packages/xpce/prolog/lib/emacs/window.pl b/packages/xpce/prolog/lib/emacs/window.pl
index 8a58dc9..3867d4a 100644
--- a/packages/xpce/prolog/lib/emacs/window.pl
+++ b/packages/xpce/prolog/lib/emacs/window.pl
@@ -1547,14 +1547,15 @@
                  *******************************/
 
 location_history(M, Start:start=[int], Len:length=[int],
-                 Title:title=[char_array]) :->
+                 Always:always=[bool], Title:title=[char_array]) :->
     "Add location to the editor history"::
     (   Start == @default
     ->  get(M, caret, Caret),
         get(M, scan, Caret, line, 0, start, SOF)
     ;   SOF = Start
     ),
-    (   send(M, history_not_interesting, SOF)
+    (   Always \== @on,
+        send(M, history_not_interesting, SOF)
     ->  true
     ;   get(M, text_buffer, TB),
         new(_, emacs_history_fragment(TB, SOF, Len, Title))
diff --git a/packages/xpce/src/AGENDA b/packages/xpce/src/AGENDA
deleted file mode 100644
index 9ca6a6c..0000000
--- a/packages/xpce/src/AGENDA
+++ /dev/null
@@ -1,41 +0,0 @@
-				XPCE Agenda
-
-
-TO DO:
-	*) Selection Service interaction (not only cut-buffers)
-	*) Editor/Text
-		1) Multi Kills backward: buggy
-		2) Handle non-printable characters correctly
-	*) Bitmaps:
-		1) Scaling
-		2) Stencils
-	*) `Resizer' object: inverted box to avoid redisplay
-		1) ->object: Graphical*
-		2) ->active: Boolean
-		3) ->execute: move attached object
-	*) Creating new expression classes?
-	*) NAME_forwards AND NAME_forward!!
-	*) Window ->grab_keyboard werkt niet zonder Window ->grab_pointer!
-	*) list_browser, editor: subclass of dialog_item?
-	*) Efficient constraint handling for spatials
-		1) Trap updates for spatials at class graphical?
-	*) Communicate with host on CWD (current directory)
-	*) Clone/save:
-		3) Relations (connection, constraint, hyper):
-			- Internal <-> external relations
-	*) Creation: exploit `variable <-initial_value' (also function)
-	   Integrate with resource system.  Part of `object ->initialise'?
-	*) Improve consistency of groups
-	*) Print \t as space for xwn-draw.c text functions
-	*) Add ->report: progress and ->report: done
-	 
-Multi-Screen access 
-
-	*) Resolve logical-font names.
-	*) Handling destruction of visual tool
-	*) Fix bitmaps
-	*) Resolve CurrentDisplay usage;
-	      1) Display of current-event?
-	      2) DisplayManager <- current
-	      3) Display of some graphical
-	*) Display <->class --> resource_class
diff --git a/packages/xpce/src/CheckCommon b/packages/xpce/src/CheckCommon
deleted file mode 100755
index ed28967..0000000
--- a/packages/xpce/src/CheckCommon
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/sh
-# 
-# Check for symbols defined as COMMON and appearing in the global symbol
-# table.  This indicates that the COMMON definition is not visible when
-# the function is defined, which causes errors on some linkers (Linux on
-# IA_64 is one of them).
-# 
-# Note: this script only works on Linux/i386.  No worries, its only for
-# me to find all such problems.
-
-grep -w COMMON */*.h | \
-	sed 's/.*COMMON([^)]*)[ 	]\([a-zA-Z_0-9]*\).*/\1/' | \
-	sort -u > Common.def
-
-nm ../linux/pl2xpce.so | \
-	grep -w T | \
-	sed 's/.* T //' | \
-	sort -u > Common.glb
-
-comm -12 Common.def Common.glb
-
-rm -f Common.def Common.glb
diff --git a/packages/xpce/src/Makefile.def b/packages/xpce/src/Makefile.def
deleted file mode 100644
index cdc8908..0000000
--- a/packages/xpce/src/Makefile.def
+++ /dev/null
@@ -1,30 +0,0 @@
-.NOCHECK
-
-ARCH=pc
-OS=windows3.1
-VERSION=4.8.5, Dec. 1994
-
-MAKE=wmake /h
-CC=wcc386
-CXX=wpp386
-CWFLAGS=
-COFLAGS=/d1
-CIFLAGS=-I.. -I..\..\..
-CMFLAGS=-fpc -bt=windows
-CFLAGS=$(CWFLAGS) $(COFLAGS) $(CIFLAGS) $(CMFLAGS)
-LD=wlink
-#LDFLAGS=system win386 debug all
-LDFLAGS=system win386
-WST=msw
-
-LN=copy
-
-MKPROTO=mkproto -p
-CLPROTO=grep -vw NewClass
-ETAGS=etags
-
-.c.obj:
-	$(CC) /zq $(CFLAGS) $*.c
-
-.cxx.obj
-	$(CXX) /zq $(CFLAGS) $*.cxx
diff --git a/packages/xpce/src/PROBLEMS b/packages/xpce/src/PROBLEMS
deleted file mode 100644
index c01109d..0000000
--- a/packages/xpce/src/PROBLEMS
+++ /dev/null
@@ -1,8 +0,0 @@
-
-	* Make the window border-line an X-window border
-	* Merge displacements of windows with updateConnectionsGraphical()
-	* Find a solution for ->display: Picture: should display the
-	  <-decoration rather than the window itself.
-	* Make sure the move- and resize-gestures can be attached to
-	  windows.
-	* Update documentation
diff --git a/packages/xpce/src/TODO b/packages/xpce/src/TODO
deleted file mode 100644
index a7d0922..0000000
--- a/packages/xpce/src/TODO
+++ /dev/null
@@ -1,40 +0,0 @@
-				XPCE TODO List
-
-[Badly maintained]
-
-Frames and Windows
-==================
-
-One of the annoying things at the moment   is that frames are no windows
-and therefore can be nested nor  embedded   in  other  XPCE GUI stuff. I
-propose to make class frame a subclass  of class Window, providing tiled
-layout of subwindows. Other things that gets   closer  with this are MDI
-and `docking' as windows can be re-parented more easily.
-
-The other toplevel (shell-widget) code of class Frame can be integrated
-in class Window.  Steps:
-
-	* Create class frame_window below window and move the client-side
-          (tile) stuff there.
-
-	* Move relevant frame behaviour to class window.
-
-	* Remove class frame and rename frame_window to frame.
-
-Consequences:
-
-	* Simple windows (no tiled) that are ->open'ed no longer have an
-	  associated frame.
-
-	* <-frame will need an extra argument to indicate the desired frame
-	  as frames are now nested.
-
-Text handling
-=============
-
-The use of LocalString() can cause   problems.  Errors from alloca() are
-non-portable and some systems have severe limits on what you can do with
-alloca().
-
-
-		
diff --git a/packages/xpce/src/TODO.MT b/packages/xpce/src/TODO.MT
deleted file mode 100644
index 54ff8f1..0000000
--- a/packages/xpce/src/TODO.MT
+++ /dev/null
@@ -1,61 +0,0 @@
-Multi-threading XPCE
-
-Message Passing
-===============
-
-* Move global-data to thread-local data.  These are the 3 variables defined
-  in trace.h.  Simple
-
-
-Program objects
-===============
-
-* Simplest: lock resolveImplementationGoal()
-  drawback: executes obtainers and other potentionally expensive code that
-	    need not lock
-
-* Alternative:
-	Lock class-access methods:
-	    getSendMethodClass()
-	    getGetMethodClass()
-	Also manipulation methods on same lock:
-	    realising/method adding operations
-
-Graphics
-========
-
-Make state maintained by xdraw.c and msdraw.c thread-safe.  Options:
-
-	* Lock d_*() ... d_done() sequences
-
-	* Use thread-local-data graphical resources
-
-	* Make changedWindow() and display-manipulation thread-safe.
-
-
-User objects
-============
-
-* Lock at the window level while changes are pending:
-  When changing a graphical, grab the window-mutex.
-
-	* GrabWindow
-	* Window is released after it is updated and repainted (i.e. ->flush)
-
-* User objects:
-
-	+ leave to user (simple)
-	+ Provide basic security on data objects (chains, vector, table)
-
-	  - `ForAll' can take long and risks deadlocks!
-
-	+ Allow objects to have a mutex associated?
-
-	- send(Obj, mutex, {write,all,none})
-	   - write: lock sends to this object
-	   - read:  lock all
-
-Work-threads
-============
-
-
diff --git a/packages/xpce/src/TODO.win b/packages/xpce/src/TODO.win
deleted file mode 100644
index 11c04c3..0000000
--- a/packages/xpce/src/TODO.win
+++ /dev/null
@@ -1,36 +0,0 @@
-			MS-Windows Port TODO List
-			     Jan Wielemaker
-
-%	Last updated: Fri Mar 19 1999
-
-Images:
-
-	* TBD: Save in MS-Windows format
-
-Timers:
-
-	* FIX: Sometimes stops after closing some window.
-	* TBD: Implement timers with a time of > 2**16 milliseconds.
-
-GUI:
-
-	* Uwe Lesta:
-
-``	If you like i can tell you some things
-	where the use of the dialog elements
-	can be make more elegant (windows like).
-	e.g. a combobox ( a text_item with a value_set )
-	on windows you can also select a value by open the box
-	and drag down to the value you want.
-	Or an other example your list browser e.g.
-	Demo programs. I open it select the Program (all with the keyboard)
-	that i like and than ?? I need the mouse. 
-	with which key can i open it. ?
-	(Alt+O don't work, but the selecton is green not blue)
-''
-
-BUGS:
-
-	* new(X, colour('#00ffff')) fails.
-	* drawing boxes of very small size fails (see remark in msdraw.c).
-	* Symbol-font not mounted correctly
diff --git a/packages/xpce/src/aclocal.m4 b/packages/xpce/src/aclocal.m4
deleted file mode 100644
index 66917ae..0000000
--- a/packages/xpce/src/aclocal.m4
+++ /dev/null
@@ -1,127 +0,0 @@
-dnl  SWI-Prolog specific autoconf macros
-
-dnl  Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009 Free Software
-dnl  Foundation, Inc.
-dnl  Copyright 2011, Roberto Bagnara, BUGSENG srl.
-dnl
-dnl  This file is part of SWI-Prolog.
-dnl
-dnl  This library is free software; you can redistribute it and/or modify
-dnl  it under the terms of the GNU Lesser General Public License as published
-dnl  by the Free Software Foundation; either version 3 of the License, or (at
-dnl  your option) any later version.
-dnl
-dnl  This library is distributed in the hope that it will be useful, but
-dnl  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-dnl  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-dnl  License for more details.
-dnl
-dnl  You should have received a copy of the GNU Lesser General Public License
-dnl  along with this library.  If not, see http://www.gnu.org/licenses/.
-
-
-dnl  All the "FOR_BUILD" macros have been copied from the GNU MP Library
-dnl  and then slightly modified.
-
-
-dnl  SWI_PROG_CC_FOR_BUILD
-dnl  ---------------------
-dnl  Establish CC_FOR_BUILD, a C compiler for the build system.
-dnl
-dnl  If CC_FOR_BUILD is set then it's expected to work, otherwise some
-dnl  likely candidates are tried.
-
-AC_DEFUN([SWI_PROG_CC_FOR_BUILD],
-[AC_REQUIRE([AC_PROG_CC])
-if test -n "$CC_FOR_BUILD"; then
-  SWI_PROG_CC_FOR_BUILD_WORKS($CC_FOR_BUILD,,
-    [AC_MSG_ERROR([Specified CC_FOR_BUILD doesn't seem to work])])
-else
-  for i in cc gcc clang c89 c99 "$CC" "$CC $CFLAGS $CPPFLAGS"; do
-    SWI_PROG_CC_FOR_BUILD_WORKS($i,
-      [CC_FOR_BUILD=$i
-       break])
-  done
-  if test -z "$CC_FOR_BUILD"; then
-    AC_MSG_ERROR([Cannot find a build system compiler])
-  fi
-fi
-
-AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
-AC_SUBST(CC_FOR_BUILD)
-])
-
-
-dnl  SWI_PROG_CC_FOR_BUILD_WORKS(cc/cflags[,[action-if-good][,action-if-bad]])
-dnl  -------------------------------------------------------------------------
-dnl  See if the given cc/cflags works on the build system.
-dnl
-dnl  It seems easiest to just use the default compiler output, rather than
-dnl  figuring out the .exe or whatever at this stage.
-
-AC_DEFUN([SWI_PROG_CC_FOR_BUILD_WORKS],
-[AC_MSG_CHECKING([build system compiler $1])
-# remove anything that might look like compiler output to our "||" expression
-rm -f conftest* a.out b.out a.exe a_out.exe
-cat >conftest.c <<EOF
-int
-main ()
-{
-  exit(0);
-}
-EOF
-swi_compile="$1 -DHAVE_CONFIG_H conftest.c"
-cc_for_build_works=no
-if AC_TRY_EVAL(swi_compile); then
-  if (./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest) >&AC_FD_CC 2>&1; then
-    cc_for_build_works=yes
-  fi
-fi
-rm -f conftest* a.out b.out a.exe a_out.exe
-AC_MSG_RESULT($cc_for_build_works)
-if test "$cc_for_build_works" = yes; then
-  ifelse([$2],,:,[$2])
-else
-  ifelse([$3],,:,[$3])
-fi
-])
-
-
-dnl  SWI_PROG_EXEEXT_FOR_BUILD
-dnl  -------------------------
-dnl  Determine EXEEXT_FOR_BUILD, the build system executable suffix.
-dnl
-dnl  The idea is to find what "-o conftest$foo" will make it possible to run
-dnl  the program with ./conftest.  On Unix-like systems this is of course
-dnl  nothing, for DOS it's ".exe", or for a strange RISC OS foreign file
-dnl  system cross compile it can be ",ff8" apparently.  Not sure if the
-dnl  latter actually applies to a build-system executable, maybe it doesn't,
-dnl  but it won't hurt to try.
-
-AC_DEFUN([SWI_PROG_EXEEXT_FOR_BUILD],
-[AC_REQUIRE([SWI_PROG_CC_FOR_BUILD])
-AC_CACHE_CHECK([for build system executable suffix],
-               swi_cv_prog_exeext_for_build,
-[cat >conftest.c <<EOF
-int
-main ()
-{
-  exit (0);
-}
-EOF
-for i in .exe ,ff8 ""; do
-  swi_compile="$CC_FOR_BUILD conftest.c -o conftest$i"
-  if AC_TRY_EVAL(swi_compile); then
-    if (./conftest) 2>&AC_FD_CC; then
-      swi_cv_prog_exeext_for_build=$i
-      break
-    fi
-  fi
-done
-rm -f conftest*
-if test "${swi_cv_prog_exeext_for_build+set}" != set; then
-  AC_MSG_ERROR([Cannot determine executable suffix])
-fi
-])
-AC_SUBST(EXEEXT_FOR_BUILD,$swi_cv_prog_exeext_for_build)
-])
diff --git a/packages/xpce/src/bitmaps/pce16.xpm b/packages/xpce/src/bitmaps/pce16.xpm
deleted file mode 100644
index 0ac09b8..0000000
--- a/packages/xpce/src/bitmaps/pce16.xpm
+++ /dev/null
@@ -1,207 +0,0 @@
-/* XPM */
-static char * pce16_xpm[] = {
-"16 16 188 2",
-"  	c None",
-". 	c #EE8B39",
-"+ 	c #E93932",
-"@ 	c #DA3533",
-"# 	c #F39B38",
-"$ 	c #F79E32",
-"% 	c #F7A43C",
-"& 	c #F69B37",
-"* 	c #F58E2F",
-"= 	c #F4832C",
-"- 	c #F2752B",
-"; 	c #EF6C30",
-"> 	c #EF552B",
-", 	c #EF3322",
-"' 	c #F6AD41",
-") 	c #FAB74E",
-"! 	c #FAB64B",
-"~ 	c #F8A633",
-"{ 	c #F79B31",
-"] 	c #F58D2F",
-"^ 	c #F37C29",
-"/ 	c #F27231",
-"( 	c #F26D42",
-"_ 	c #F04D36",
-": 	c #EA382C",
-"< 	c #FBDAA2",
-"[ 	c #FEEECF",
-"} 	c #FFEDCC",
-"| 	c #FCD28E",
-"1 	c #F8A437",
-"2 	c #F69231",
-"3 	c #F6964C",
-"4 	c #FAC5A7",
-"5 	c #FCDBCE",
-"6 	c #FBC3B9",
-"7 	c #F1817C",
-"8 	c #FBDDB3",
-"9 	c #FFFFFF",
-"0 	c #FAFCFF",
-"a 	c #F6FAFE",
-"b 	c #FEFFFF",
-"c 	c #FAC681",
-"d 	c #F79634",
-"e 	c #FCE1CB",
-"f 	c #FAFEFF",
-"g 	c #F7FFFF",
-"h 	c #FDEBEA",
-"i 	c #DF7773",
-"j 	c #F7B56C",
-"k 	c #FEF1E0",
-"l 	c #FBFDFF",
-"m 	c #D9DADA",
-"n 	c #787778",
-"o 	c #C2C5C8",
-"p 	c #FFEBD4",
-"q 	c #FBA147",
-"r 	c #F5F6F6",
-"s 	c #BFC0C1",
-"t 	c #878688",
-"u 	c #D3DCDD",
-"v 	c #E39090",
-"w 	c #F5A353",
-"x 	c #FFF4E9",
-"y 	c #929294",
-"z 	c #1C1819",
-"A 	c #9C9C9E",
-"B 	c #D7D5D1",
-"C 	c #CBB6A2",
-"D 	c #E7EAEC",
-"E 	c #F4F4F4",
-"F 	c #797879",
-"G 	c #262224",
-"H 	c #B9C0C2",
-"I 	c #E08D8E",
-"J 	c #B82828",
-"K 	c #F48E39",
-"L 	c #FBD0A7",
-"M 	c #E3E4E5",
-"N 	c #BEBFC1",
-"O 	c #C8C9CC",
-"P 	c #D1D3D3",
-"Q 	c #D3D4D5",
-"R 	c #B3B5B7",
-"S 	c #F7F9F9",
-"T 	c #DADBDC",
-"U 	c #C1C3C4",
-"V 	c #F1F6F5",
-"W 	c #CD464A",
-"X 	c #AC191B",
-"Y 	c #F27B29",
-"Z 	c #F5903F",
-"` 	c #FCD4B5",
-" .	c #FFFCF9",
-"..	c #FFFCF5",
-"+.	c #D6BBA7",
-"@.	c #BDBEBF",
-"#.	c #BFC0C2",
-"$.	c #A29A99",
-"%.	c #F7CEC0",
-"&.	c #FFFEFE",
-"*.	c #FEECEA",
-"=.	c #DE6A6B",
-"-.	c #B8151B",
-";.	c #A21B1D",
-">.	c #E66928",
-",.	c #EA7227",
-"'.	c #EC7421",
-").	c #F07D2D",
-"!.	c #F37A27",
-"~.	c #F17427",
-"{.	c #8D7C75",
-"].	c #7C7D7F",
-"^.	c #B15C46",
-"/.	c #F53B19",
-"(.	c #EB2D25",
-"_.	c #D7151B",
-":.	c #BD0D14",
-"<.	c #A70D12",
-"[.	c #931112",
-"}.	c #D35728",
-"|.	c #D1551D",
-"1.	c #CC581D",
-"2.	c #DD6022",
-"3.	c #ED6727",
-"4.	c #F46326",
-"5.	c #C65C35",
-"6.	c #785954",
-"7.	c #F14024",
-"8.	c #ED2B24",
-"9.	c #D7181E",
-"0.	c #B71016",
-"a.	c #9E0B0F",
-"b.	c #850406",
-"c.	c #8C1613",
-"d.	c #DF5132",
-"e.	c #D7451D",
-"f.	c #DB4C20",
-"g.	c #E75123",
-"h.	c #F05326",
-"i.	c #F04E26",
-"j.	c #F34523",
-"k.	c #D04034",
-"l.	c #ED2622",
-"m.	c #E01B22",
-"n.	c #C8161C",
-"o.	c #AD1015",
-"p.	c #98090C",
-"q.	c #820405",
-"r.	c #CF2A1D",
-"s.	c #DE321F",
-"t.	c #EF3823",
-"u.	c #F23422",
-"v.	c #EF2F24",
-"w.	c #EC2824",
-"x.	c #E72022",
-"y.	c #D91920",
-"z.	c #C9141A",
-"A.	c #B81016",
-"B.	c #9E0A0E",
-"C.	c #840305",
-"D.	c #740303",
-"E.	c #D31E22",
-"F.	c #E02124",
-"G.	c #DD2527",
-"H.	c #CD3133",
-"I.	c #D81E23",
-"J.	c #D7181F",
-"K.	c #CB161E",
-"L.	c #C01319",
-"M.	c #A72024",
-"N.	c #99181B",
-"O.	c #910406",
-"P.	c #7A0001",
-"Q.	c #6F0202",
-"R.	c #9C8489",
-"S.	c #B6A9AC",
-"T.	c #A08384",
-"U.	c #B51E25",
-"V.	c #B51319",
-"W.	c #994649",
-"X.	c #ABA3A6",
-"Y.	c #A4979A",
-"Z.	c #97999C",
-"`.	c #A0A2A4",
-" +	c #7B7B7F",
-".+	c #C4C7CA",
-"++	c #ACAFB1",
-"@+	c #888A8C",
-"      .                 + @     ",
-"      # $ % & * = - ; > ,       ",
-"      ' ) ! ~ { ] ^ / ( _ :     ",
-"      < [ } | 1 2 3 4 5 6 7     ",
-"    8 9 0 a b c d e 9 f g h i   ",
-"  j k l m n o p q 9 r s t u v   ",
-"  w x l y z A B C D E F G H I J ",
-"  K L 9 M N O P Q R S T U V W X ",
-"  Y Z `  ...+.@.#.$.%.&.*.=.-.;.",
-"  >.,.'.).!.~.{.].^./.(._.:.<.[.",
-"  }.|.1.2.3.4.5.6.7.8.9.0.a.b.c.",
-"  d.e.f.g.h.i.j.k.l.m.n.o.p.q.  ",
-"    r.s.t.u.v.w.x.y.z.A.B.C.D.  ",
-"    E.F.G.H.I.J.K.L.M.N.O.P.Q.  ",
-"        R.S.T.U.V.W.X.Y.        ",
-"        Z.  `.     +.+++@+      "};
diff --git a/packages/xpce/src/bitmaps/swipl48.xpm b/packages/xpce/src/bitmaps/swipl48.xpm
new file mode 100644
index 0000000..aa9292b
--- /dev/null
+++ b/packages/xpce/src/bitmaps/swipl48.xpm
@@ -0,0 +1,279 @@
+/* XPM */
+static char *swipl48_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"48 48 225 2 ",
+"   c #231F20",
+".  c #6A0B0E",
+"X  c #730B0E",
+"o  c #770E11",
+"O  c #6D0C10",
+"+  c #691928",
+"@  c #49243A",
+"#  c #403E3F",
+"$  c #591D2F",
+"%  c #092C49",
+"&  c #17314C",
+"*  c #153352",
+"=  c #26384E",
+"-  c #293B51",
+";  c #313E51",
+":  c #163E64",
+">  c #452840",
+",  c #394557",
+"<  c #3C424F",
+"1  c #1E446B",
+"2  c #4C4A4A",
+"3  c #454D5A",
+"4  c #575557",
+"5  c #49515E",
+"6  c #6D5054",
+"7  c #4C5462",
+"8  c #555B66",
+"9  c #656364",
+"0  c #67676C",
+"q  c #746869",
+"w  c #676A73",
+"e  c #6D7179",
+"r  c #74767A",
+"t  c #5C6069",
+"y  c #870E12",
+"u  c #930F14",
+"i  c #851013",
+"p  c #941115",
+"a  c #9D1116",
+"s  c #99161A",
+"d  c #A41217",
+"f  c #AC1419",
+"g  c #A41419",
+"h  c #B3141A",
+"j  c #BB151B",
+"k  c #BF181E",
+"l  c #B13519",
+"z  c #981C29",
+"x  c #963233",
+"c  c #AA242D",
+"v  c #A11C2A",
+"b  c #C3161C",
+"n  c #CC171E",
+"m  c #CB1C1F",
+"M  c #D5181F",
+"N  c #D0171E",
+"B  c #CD301E",
+"V  c #DC1920",
+"C  c #D41920",
+"Z  c #CD1921",
+"A  c #E31B22",
+"S  c #EB1C23",
+"D  c #D32C2F",
+"F  c #EE2323",
+"G  c #EE2C22",
+"H  c #E82624",
+"J  c #EF3422",
+"K  c #E83B23",
+"L  c #F03C21",
+"P  c #F03722",
+"I  c #EF3E3E",
+"U  c #DB4B1F",
+"Y  c #C4451C",
+"T  c #D4452F",
+"R  c #E94723",
+"E  c #F04421",
+"W  c #F14B21",
+"Q  c #E75621",
+"!  c #F15321",
+"~  c #F25B21",
+"^  c #EE463B",
+"/  c #F36420",
+"(  c #F36C20",
+")  c #F47421",
+"_  c #F57B21",
+"`  c #EC6C35",
+"'  c #BC3957",
+"]  c #DB374A",
+"[  c #824A49",
+"{  c #A94C46",
+"}  c #9D506B",
+"|  c #BB5569",
+" . c #866969",
+".. c #887A7A",
+"X. c #956768",
+"o. c #AF6667",
+"O. c #CD4A45",
+"+. c #EF4E49",
+"@. c #F17053",
+"#. c #D96A6E",
+"$. c #E97875",
+"%. c #C85678",
+"&. c #F58321",
+"*. c #F68B21",
+"=. c #F69422",
+"-. c #F79C22",
+";. c #F48537",
+":. c #F79838",
+">. c #F8A423",
+",. c #F8A923",
+"<. c #BA877A",
+"1. c #F58448",
+"2. c #F58755",
+"3. c #EA8459",
+"4. c #F5AB4D",
+"5. c #F19471",
+"6. c #F3AA72",
+"7. c #36629B",
+"8. c #3D69A3",
+"9. c #325D93",
+"0. c #526896",
+"q. c #787B83",
+"w. c #6A7994",
+"e. c #587CB3",
+"r. c #4D6EA7",
+"t. c #5E6594",
+"y. c #B06E93",
+"u. c #7C828F",
+"i. c #6C8BBE",
+"p. c #6383B8",
+"a. c #718AB8",
+"s. c #7888A9",
+"d. c #5E80B5",
+"f. c #7993C3",
+"g. c #848384",
+"h. c #8C8B8C",
+"j. c #898787",
+"k. c #958B8B",
+"l. c #949293",
+"z. c #9C9B9B",
+"x. c #989799",
+"c. c #8F8F92",
+"v. c #A39F9F",
+"b. c #B58F8F",
+"n. c #8792AB",
+"m. c #989BA3",
+"M. c #8F94B5",
+"N. c #A19FA0",
+"B. c #BB9CB0",
+"V. c #99A4BE",
+"C. c #A4A3A3",
+"Z. c #A9A6A6",
+"A. c #AEADAD",
+"S. c #A4A5AA",
+"D. c #B0AFAF",
+"F. c #B8A8A9",
+"G. c #B3ACB3",
+"H. c #B3B2B2",
+"J. c #B8B7B7",
+"K. c #BCBBBB",
+"L. c #B6B6B9",
+"P. c #A8ACB5",
+"I. c #CA9697",
+"U. c #D99292",
+"Y. c #DD8588",
+"T. c #E6938C",
+"R. c #F5AA88",
+"E. c #F6B78B",
+"W. c #EEAA94",
+"Q. c #C1BEBE",
+"!. c #C5B4B5",
+"~. c #D2B2B1",
+"^. c #E5B8B9",
+"/. c #EFB1A7",
+"(. c #CE9A9A",
+"). c #FAC48D",
+"_. c #F9CDB3",
+"`. c #849CC8",
+"'. c #8BA2CC",
+"]. c #99A7CA",
+"[. c #98ABD2",
+"{. c #A3AAC5",
+"}. c #ACB3C3",
+"|. c #BBBDC4",
+" X c #AAB9D9",
+".X c #B2BDD8",
+"XX c #C0BFC0",
+"oX c #B7C2DC",
+"OX c #BEC2CE",
+"+X c #B9C5E1",
+"@X c #BAC7E2",
+"#X c #C4C3C4",
+"$X c #CCCBCB",
+"%X c #C6C6C8",
+"&X c #D9CDCD",
+"*X c #CCCED4",
+"=X c #D4D3D3",
+"-X c #DBDBDB",
+";X c #D7D7DA",
+":X c #D0D1D7",
+">X c #F9D7C9",
+",X c #E5DCDA",
+"<X c #FBDBD6",
+"1X c #EDCBCA",
+"2X c #FDE8D7",
+"3X c #C2CDE5",
+"4X c #CBD4E9",
+"5X c #CCD5EA",
+"6X c #D4DCED",
+"7X c #D9DCE7",
+"8X c #DCE3F1",
+"9X c #E4E4E4",
+"0X c #ECEBEC",
+"qX c #E4E5EA",
+"wX c #FCEBE8",
+"eX c #FCF2EC",
+"rX c #E5EAF5",
+"tX c #EAEDF6",
+"yX c #E3E8F4",
+"uX c #EEF2F9",
+"iX c #F2F2F2",
+"pX c #F3F6FB",
+"aX c #FFFFFF",
+"sX c #FBF5F5",
+"dX c None",
+/* pixels */
+"dXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdX-X;X=X=X=X$X$X$X#XdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdX9X9X9X-X-X-X;X;X=X=X=X$X%X#X#XXXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXdXdXdXdXdX9X9X9X9X9X-X9X-X-X;X;X=X=X$X$X%X#XK.J.J.H.dXdXdXdXdXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXdXdXdXqXqX9X9X*X|.}.].V.{.}.OX$X=X=X$X$X%X#XXXK.J.H.D.dXdXdXdXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXdX0X0XqX*X}.f.i.p.p.d.e.e.r.r.r.s.L.%X$X$X%XXXQ.J.L.D.A.H.dXdXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdX0XqX:X[.'.`.f.f.f.p.p.d.p.s.n.n.d.0.w.A.$X$X%X#XK.J.H.A.A.D.dXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdX0XqXoX[.[.'.'.f.f.f.M.L.$X-X-X-X-X=X$XXXn.x.XX$X#XK.K.L.D.D.D.D.dXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdX0XqX.X XG.B.{.'.'.`.|.7XqX0X0X0X9X9X9X-X-X=X$XXX%X#X!.!.I.F.A.A.D.D.dXdXdXdXdXdXdX",
+"dXdXdXdXdXdX0XqXoXoX XU.) _ 3.N.*X0XiXiXiX0X0X9X9X9X9X-X;X=X=X#X$.F S O.G.G.A.A.D.D.dXdXdXdXdXdX",
+"dXdXdXdXdXiX0X3X@X@XoX.X;.&.&.&._.sXiX>X/.6.5.2.1.5.T./.&X-X^.^ G F S I.J.J.D.D.Z.D.D.dXdXdXdXdX",
+"dXdXdXdX0X0X7X3X3X3X@X+X5.*.*.*.*.E.:.*.&.&._ _ ( ( ~ ~ ! $.+.E G F S !.J.D.D.D.x.C.D.D.dXdXdXdX",
+"dXdXdXdXiXqX5X6X4X4X3X@XR.=.-.-.-.=.-.=.*.*.&._ _ ( / ~ ! W E L J F S !.K.J.D.D.Z.u.D.D.dXdXdXdX",
+"dXdXdXiX0X7X6X6X6X5X4X3X6.-.>.>.>.,.>.-.=.=.*.&._ ( ( ~ ~ W E L J G F !.K.L.H.A.A.e N.D.D.dXdXdX",
+"dXdXdXiXqX8XyX8X8X6X7X5X4.>.,.,.,.,.,.>.-.=.*.&._ ) ( / ~ ! W E J G F ~.K.L.H.D.D.h.r D.D.D.dXdX",
+"dXdXiX0XrXtXtXrXrX8X6X&X>.).2XeXeX2X_.4.>.-.=.*.&._ ( / W.<X2XwX<X/.+.$.K.J.H.A.A.C.5 C.D.D.dXdX",
+"dXdX0X0XuXuXuXuXtX8X7X6.wXaXaXaXaXaXaXeX).-.=.*.&._ 2.wXaXaXaXaXaXaXwX$.I.J.H.A.A.A.t h.D.D.dXdX",
+"dXiX0X0XpXpXaXpXuXqXE.wXaXaXaXaXaXaXaXaXaXE.-.*.&.1.eXaXaXaXaXaXaXaXaXaX$.F.D.D.D.D.r 0 Z.D.H.dX",
+"dX0X0XtXpXpXaXpXuX,X_.aXaXaXaXaXaXaXaXaXaXeX-.*.&.>XaXaXaXaXaXaXaXaXaXaX<X#.D.D.D.D.c., C.D.D.dX",
+"dX0X0XtXpXpXpXpXuX6.sXaXaXaXaXiX=X%X=XiXaXaXE.*.1.aXaXaXaXaXiX=X#X=XiXaXaXY.b.D.A.A.m.% c.D.D.dX",
+"dX0XqXtXpXpXpXuX>X6.aXaXaXaXsX%Xl.9 h.K.sXaX>X*.E.aXaXaXaXiXXXh.9 l.#XiXaX^.| D.D.A.Z.& r A.D.H.",
+"dX0X9XyXrXtXtXtXW.E.aXaXaXaX9Xz.iXr   x.-XaX2X*./.aXaXaXaX-Xz.pX4   N.9XaX1Xb Z.A.D.A., t A.D.H.",
+"0X0X7XqXyXyXrXqX;.6.aXaXaXaX-Xl.2     j.=XaX&X(.~.iXaXaXaX=Xj.2     l.-XaX^.j y.A.D.A., 7 S.D.H.",
+"9X0X7X7X8X8X8X&X_ ;.aXaXaXaX0XL.2   # H.-X#X%X$X#XA.9XaXaX9XH.#   2 H.0XaXU.j o.D.A.A.5 , C.D.D.",
+"9X9X7X6X6X6X6X^._ _ >XaXaXaXaX-XJ.Z.J.=X%X%X-X-X$XJ.z.aXaXaX=XJ.A.K.;XaXiXD h { A.D.A., , z.D.D.",
+"9X9X7X4X4X4X4XW.) ) 2.sXaXaXaXaXiXqX0XaXD.$X-X-X&XJ.c.qXaXaXaXiX0XiXaXpXU.j h g A.D.A.= - N.D.D.",
+"9X9X;X@X@X3X3XU.( ( _ 5.eXaXaXaXaXaXaXaXC.Q.=X=X%XD.j.9XaXaXaXaXaXaXaXW.b j f a Z.D.C.% , N.D.H.",
+"9X9X;X+X+X+X+XY./ ( ( ) 1._.eXaXaXsX,X5.<.Z.J.J.D.x. .@.1XeXaXaXsX1X#.n j h d a Z.D.l.% , C.D.H.",
+"dX,X;X X X+X.XY.Q / / ( ( ( ( ` 2.) ) _ O.<.l.l.j.q T R G G +.+.S M m b j f a u Z.A.q.% 8 Z.D.H.",
+"dX-X,X X X X X(.U ~ ~ / / ( / ( / / / / / { 9 9 4 [ L P G F F S V C n k f d u x D.A.5 % w A.D.dX",
+"dX;X;X.X[.[.[.B.U l U U Q Q Q / ~ ~ ~ ! ! R 6 4 4 T P G F F S A C k h a d i o X.D.z.% % g.A.D.dX",
+"dX-X7XXX'.[.[.[.E U W U l Q B Y Q ! ! W W E O.4 { J G G F S A j a k g i d p i k.D.w % = z.D.H.dX",
+"dXdX;X:X'.'.'.`.#.K E R R W U R W E W E E L K [ K G F F S A M n f j h g a y i v.z.& % 8 Z.D.H.dX",
+"dXdX=X;X{.`.f.`.y.B B K B K K E E L L L L J J D G F S S V M N n j f a p o O [ Z.7 % % h.A.A.dXdX",
+"dXdX=X=X%Xa.f.f.M.J B P B l L J P P P J G G F F F F S V M n b j f p X p y X X.e % % 8 N.D.D.dXdX",
+"dXdXdX$X=XV.i.i.f.] G G G J G G G G G G G F F S S A V M m b j h d d p y o o 6 % % & c.A.D.dXdXdX",
+"dXdXdX$X$X#Xa.p.e.%.m Z H F F F F F F S S S S A V M n b b j f g a p y X . O & % % e Z.D.H.dXdXdX",
+"dXdXdXdX%X$XP.d.e.y.M N A A A S S S S A A V V M N n b b h d g a p y i o . + % % 8 C.A.A.dXdXdXdX",
+"dXdXdXdXdX%X%XM.e.w.V V ] | V A A D D V M M m b b j h d g v s i u + $ X . $ % 5 x.A.A.H.dXdXdXdX",
+"dXdXdXdXdX#X#XK.y.r.M ' r.8.t.} ..c.h.X.D j k j h f v X.h.l.<.6 @ % % @ . @ 4 x.A.A.H.dXdXdXdXdX",
+"dXdXdXdXdXdXQ.Q.|.f.} 8.8.7.0.g.A.|.K.N. .x c v v z q v.J.Q.S.u.2 % % % @ 9 z.A.A.A.dXdXdXdXdXdX",
+"dXdXdXdXdXdXdXJ.L.L.m.0.7.9.0 m.OX=X=XJ.j., * % % & <.H.=X-X%XZ.0 % % , u.Z.A.A.D.dXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXL.L.L.Z.c.9.9 C.S.u.u.C.c.3 % % % = u.Z.q.e m.Z.q < r z.Z.D.A.D.dXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXL.D.H.D.C.9 q.1 : : * 0 < % % % < 0 - % % = r 9 z.A.A.A.A.H.dXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXdXdXD.D.D.h.z.l.u.w 7 5 < & % & , 5 8 w j.x.C.g.D.A.A.A.H.dXdXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXdXdXdXD.D.A.A.D.D.A.Z.C.N.z.z.z.N.C.Z.A.A.A.A.D.D.D.D.dXdXdXdXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXdXdXdXdXdXH.D.D.D.D.D.D.D.H.D.D.D.D.D.D.D.A.D.D.D.dXdXdXdXdXdXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXH.H.D.D.D.D.D.D.D.D.D.D.D.H.L.dXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdX",
+"dXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXH.H.H.H.H.H.dXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdXdX"
+};
diff --git a/packages/xpce/src/gra/image.c b/packages/xpce/src/gra/image.c
index 787fd64..5eb2f1d 100644
--- a/packages/xpce/src/gra/image.c
+++ b/packages/xpce/src/gra/image.c
@@ -961,7 +961,7 @@
 
 
 #ifdef XPM_PCEIMAGE
-#include "bitmaps/pce16.xpm"
+#include "bitmaps/swipl48.xpm"
 #include "bitmaps/hadjusttile.xpm"
 #include "bitmaps/vadjusttile.xpm"
 #include "bitmaps/up.xpm"
@@ -1035,7 +1035,7 @@
   stdImage(NAME_intItemImage, &INT_ITEM_IMAGE,
 	   (char*)intarrows_bits, intarrows_width, intarrows_height);
 #ifdef XPM_PCEIMAGE
-  stdXPMImage(NAME_pceImage,	     NULL,		  pce16_xpm);
+  stdXPMImage(NAME_pceImage,	     NULL,		  swipl48_xpm);
   stdXPMImage(NAME_hadjustTileImage, NULL,		  hadjusttile_xpm);
   stdXPMImage(NAME_vadjustTileImage, NULL,		  vadjusttile_xpm);
   stdXPMImage(NAME_scrollUpImage,    &SCROLL_UP_IMAGE,	  up_xpm);
diff --git a/packages/xpce/src/h/graphics.h b/packages/xpce/src/h/graphics.h
index d7ac86a..5d78c8b 100644
--- a/packages/xpce/src/h/graphics.h
+++ b/packages/xpce/src/h/graphics.h
@@ -814,6 +814,7 @@
   Chain		members;		/* its member frames */
   Name		kind;			/* {user,service} */
   Chain		modal;			/* Stack of modal frames */
+  Image		icon_image;		/* Image of the icon */
 End;
 
 
diff --git a/packages/xpce/src/install-sh b/packages/xpce/src/install-sh
deleted file mode 100755
index ab74c88..0000000
--- a/packages/xpce/src/install-sh
+++ /dev/null
@@ -1,238 +0,0 @@
-#!/bin/sh
-#
-# install - install a program, script, or datafile
-# This comes from X11R5.
-#
-# Calling this script install-sh is preferred over install.sh, to prevent
-# `make' implicit rules from creating a file called install from it
-# when there is no Makefile.
-#
-# This script is compatible with the BSD install script, but was written
-# from scratch.
-#
-
-
-# set DOITPROG to echo to test this script
-
-# Don't use :- since 4.3BSD and earlier shells don't like it.
-doit="${DOITPROG-}"
-
-
-# put in absolute paths if you don't have them in your path; or use env. vars.
-
-mvprog="${MVPROG-mv}"
-cpprog="${CPPROG-cp}"
-chmodprog="${CHMODPROG-chmod}"
-chownprog="${CHOWNPROG-chown}"
-chgrpprog="${CHGRPPROG-chgrp}"
-stripprog="${STRIPPROG-strip}"
-rmprog="${RMPROG-rm}"
-mkdirprog="${MKDIRPROG-mkdir}"
-
-tranformbasename=""
-transform_arg=""
-instcmd="$mvprog"
-chmodcmd="$chmodprog 0755"
-chowncmd=""
-chgrpcmd=""
-stripcmd=""
-rmcmd="$rmprog -f"
-mvcmd="$mvprog"
-src=""
-dst=""
-dir_arg=""
-
-while [ x"$1" != x ]; do
-    case $1 in
-	-c) instcmd="$cpprog"
-	    shift
-	    continue;;
-
-	-d) dir_arg=true
-	    shift
-	    continue;;
-
-	-m) chmodcmd="$chmodprog $2"
-	    shift
-	    shift
-	    continue;;
-
-	-o) chowncmd="$chownprog $2"
-	    shift
-	    shift
-	    continue;;
-
-	-g) chgrpcmd="$chgrpprog $2"
-	    shift
-	    shift
-	    continue;;
-
-	-s) stripcmd="$stripprog"
-	    shift
-	    continue;;
-
-	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
-	    shift
-	    continue;;
-
-	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
-	    shift
-	    continue;;
-
-	*)  if [ x"$src" = x ]
-	    then
-		src=$1
-	    else
-		# this colon is to work around a 386BSD /bin/sh bug
-		:
-		dst=$1
-	    fi
-	    shift
-	    continue;;
-    esac
-done
-
-if [ x"$src" = x ]
-then
-	echo "install:	no input file specified"
-	exit 1
-else
-	true
-fi
-
-if [ x"$dir_arg" != x ]; then
-	dst=$src
-	src=""
-	
-	if [ -d $dst ]; then
-		instcmd=:
-	else
-		instcmd=mkdir
-	fi
-else
-
-# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
-# might cause directories to be created, which would be especially bad 
-# if $src (and thus $dsttmp) contains '*'.
-
-	if [ -f $src -o -d $src ]
-	then
-		true
-	else
-		echo "install:  $src does not exist"
-		exit 1
-	fi
-	
-	if [ x"$dst" = x ]
-	then
-		echo "install:	no destination specified"
-		exit 1
-	else
-		true
-	fi
-
-# If destination is a directory, append the input filename; if your system
-# does not like double slashes in filenames, you may need to add some logic
-
-	if [ -d $dst ]
-	then
-		dst="$dst"/`basename $src`
-	else
-		true
-	fi
-fi
-
-## this sed command emulates the dirname command
-dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
-
-# Make sure that the destination directory exists.
-#  this part is taken from Noah Friedman's mkinstalldirs script
-
-# Skip lots of stat calls in the usual case.
-if [ ! -d "$dstdir" ]; then
-defaultIFS='	
-'
-IFS="${IFS-${defaultIFS}}"
-
-oIFS="${IFS}"
-# Some sh's can't handle IFS=/ for some reason.
-IFS='%'
-set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
-IFS="${oIFS}"
-
-pathcomp=''
-
-while [ $# -ne 0 ] ; do
-	pathcomp="${pathcomp}${1}"
-	shift
-
-	if [ ! -d "${pathcomp}" ] ;
-        then
-		$mkdirprog "${pathcomp}"
-	else
-		true
-	fi
-
-	pathcomp="${pathcomp}/"
-done
-fi
-
-if [ x"$dir_arg" != x ]
-then
-	$doit $instcmd $dst &&
-
-	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
-	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
-	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
-	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
-else
-
-# If we're going to rename the final executable, determine the name now.
-
-	if [ x"$transformarg" = x ] 
-	then
-		dstfile=`basename $dst`
-	else
-		dstfile=`basename $dst $transformbasename | 
-			sed $transformarg`$transformbasename
-	fi
-
-# don't allow the sed command to completely eliminate the filename
-
-	if [ x"$dstfile" = x ] 
-	then
-		dstfile=`basename $dst`
-	else
-		true
-	fi
-
-# Make a temp file name in the proper directory.
-
-	dsttmp=$dstdir/#inst.$$#
-
-# Move or copy the file name to the temp name
-
-	$doit $instcmd $src $dsttmp &&
-
-	trap "rm -f ${dsttmp}" 0 &&
-
-# and set any options; do chmod last to preserve setuid bits
-
-# If any of these fail, we abort the whole thing.  If we want to
-# ignore errors from any of these, just make sure not to ignore
-# errors from the above "$doit $instcmd $src $dsttmp" command.
-
-	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
-	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
-	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
-	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
-
-# Now rename the file to the real destination.
-
-	$doit $rmcmd -f $dstdir/$dstfile &&
-	$doit $mvcmd $dsttmp $dstdir/$dstfile 
-
-fi &&
-
-
-exit 0
diff --git a/packages/xpce/src/mkproto.sh b/packages/xpce/src/mkproto.sh
deleted file mode 100755
index 62e2349..0000000
--- a/packages/xpce/src/mkproto.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/sh
-
-# mkproto file ...
-# 
-# Generate the proto.h files in the various subdirectories. mkproto is a
-# public domain program to generate ANSI prototypes from C-sources.
-
-mkproto -p -d COMMON -D '#define COMMON(type) SO_LOCAL type' $* | \
-	grep -vw NewClass | grep -v pceMT
diff --git a/packages/xpce/src/nomd b/packages/xpce/src/nomd
deleted file mode 100755
index 5f3e978..0000000
--- a/packages/xpce/src/nomd
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/sh
-
-arch=$1
-
-echo "[ERROR: No machine description file for PLARCH=$arch]"
-
-arches=`ls md | grep -v CVS | sed 's/md-\(.*\)\.h/\1/'`
-
-echo ""
-echo "Please edit PLARCH in Makefile to be one of:"
-for a in $arches; do echo "	$a"; done
-exit 1
diff --git a/packages/xpce/src/rel-ln b/packages/xpce/src/rel-ln
deleted file mode 100755
index 1bacc1b..0000000
--- a/packages/xpce/src/rel-ln
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/bin/sh
-# Author: Stepan Kasal <kasal@suse.cz>
-#
-# Version: 0.1
-#	this shell script is public domain ;-)
-# Modified: Thu Feb 17 2000 (JW)
-#	Avoid use of ln -sf (GNU specific)
-#	Avoid use of GNU sed extensions
-#	If all fails due to other links, make an absolute link.
-# Modified: Thu Mar  9 2000 (JW)
-#	Avoid using grep -q (GNU specific)
-#
-# Purpose: Make relative links between the binary and lib directory to
-# achieve a relocatable object.  Notably useful for generating RPM files.
-
-check_path()
-{ dir=$(dirname "$1")
-  file=$(basename "$1")
-  cdir=$(cd $dir && pwd)
-
-  echo $cdir/$file
-}
-
-compare()
-{ test $# = 4 && test "$1" = "$3" && from=$2 && to=$4
-}
-
-if test $# != 2 ; then
-  echo "usage:  $0 from to
-	creates relative symbolic link from \$1 to \$2" >&2
-  exit 1
-fi
-
-from=$1
-to=$2
-
-from=$(check_path "$from")
-to=$(check_path "$to")
-
-# Make sure $to points to destination file instead of dir
-
-if [ -d $to ]; then
-  to=$to/`basename $from`;
-fi
-
-abs_to="$to"
-abs_from="$from"
-
-# Remove leading / and replace repeated // into a single /
-
-from=`echo $from | sed -e 's,//*,/,g' -e 's,/,,'`
-to=`echo $to | sed -e 's,//*,/,g' -e 's,/,,'`
-
-# Now get rid of the common start.
-
-while compare `echo $from|sed "s,/, ,"` `echo $to|sed "s,/, ,"`
-do test a = a
-done
-
-# Remove all but the last segment of $to into .. and put the from after this
-
-relf="`echo $to | sed -e 's,[^/][^/]*/,../,g' -e 's,[^/][^/]*$,,'`$from"
-
-rm -f "$abs_to"
-# Cygwin specific test to find out if a symlink exists with a .exe suffix.
-# Newer ln(1) create symlinks to executables also with a .exe suffix.
-[ -s "$abs_to".exe ] && rm -f "$abs_to".exe
-
-# Now, all can be in vain due to other symbolic links.  If this is the case,
-# link absolute after all.
-
-if (cd `dirname $abs_to` && test -e $relf); then
-   ln -s "$relf" "$abs_to"
-else
-   echo "`basename $0`: Making abolute link to $abs_from"
-   ln -s "$abs_from" "$abs_to"
-fi
diff --git a/packages/xpce/src/win/application.c b/packages/xpce/src/win/application.c
index a43fda3..a253543 100644
--- a/packages/xpce/src/win/application.c
+++ b/packages/xpce/src/win/application.c
@@ -43,6 +43,7 @@
   assign(app, members, newObject(ClassChain, EAV));
   assign(app, kind,    NAME_user);
   assign(app, modal,   newObject(ClassChain, EAV));
+  obtainClassVariablesObject(app);
 
   appendChain(TheApplications, app);
 
@@ -204,7 +205,9 @@
   IV(NAME_kind, "{user,service}", IV_BOTH,
      NAME_debugging, "If service, events cannot be debugged"),
   IV(NAME_modal, "chain", IV_NONE,
-     NAME_event, "Frame for modal operation")
+     NAME_event, "Frame for modal operation"),
+  IV(NAME_iconImage, "image*", IV_BOTH,
+     NAME_icon, "Image used for the iconic representation")
 };
 
 /* Send Methods */
@@ -239,12 +242,10 @@
 
 /* Resources */
 
-#define rc_application NULL
-/*
 static classvardecl rc_application[] =
-{
-};
-*/
+{ RC(NAME_iconImage, "image*", "@nil",
+     "Image displayed for an icon")
+};
 
 /* Class Declaration */
 
diff --git a/packages/xpce/src/x11/include.h b/packages/xpce/src/x11/include.h
index 098b347..aa2babd 100644
--- a/packages/xpce/src/x11/include.h
+++ b/packages/xpce/src/x11/include.h
@@ -268,6 +268,8 @@
 COMMON(int)		write_gif_file(IOSTREAM *fd, XImage *img, XImage *msk,
 				       Display *disp, Colormap cmap);
 COMMON(XImage *)	attachXpmImageImage(Image image, XpmImage *xpm);
+COMMON(unsigned long *)	XImageToRGBA(XImage *img, XImage *msk,
+				     Display *disp, Colormap cmap, size_t *lenp);
 
 /* xcolour.c */
 COMMON(status)		allocNearestColour(Display *display, Colormap map,
@@ -275,5 +277,7 @@
 
 extern XtAppContext ThePceXtAppContext;	/* X toolkit application context */
 
+COMMON(unsigned long*)	ws_image_to_rgba(Image image, Image mask, size_t *lenp);
+
 #endif /*_PCE_X11_INCLUDED*/
 
diff --git a/packages/xpce/src/x11/xfont.c b/packages/xpce/src/x11/xfont.c
index c5cc958..4c7f17f 100644
--- a/packages/xpce/src/x11/xfont.c
+++ b/packages/xpce/src/x11/xfont.c
@@ -73,7 +73,7 @@
 
     XftPatternAddString(p, XFT_FAMILY, fam);
     XftPatternAddDouble(p, XFT_PIXEL_SIZE, (double)valInt(f->points)*fscale);
-    if ( f->style == NAME_italic )
+    if ( f->style == NAME_italic || f->style == NAME_oblique )
       XftPatternAddInteger(p, XFT_SLANT, XFT_SLANT_ITALIC);
     else if ( f->style == NAME_roman )
       XftPatternAddInteger(p, XFT_SLANT, XFT_SLANT_ROMAN);
diff --git a/packages/xpce/src/x11/xframe.c b/packages/xpce/src/x11/xframe.c
index 57b9480..c394428 100644
--- a/packages/xpce/src/x11/xframe.c
+++ b/packages/xpce/src/x11/xframe.c
@@ -47,6 +47,8 @@
 static void	destroyFrame(Widget, FrameObj, XtPointer);
 static status   updateAreaFrame(FrameObj fr, Int border);
 static int	ws_group_frame(FrameObj fr);
+static int	ws_set_pid_frame(FrameObj fr);
+static void	ws_set_net_icon_frame(FrameObj fr);
 
 #define MainWindow(fr)	     ( isNil(fr->members->head) ? (Any) fr : \
 			       fr->members->head->value )
@@ -144,6 +146,15 @@
 
     XtDestroyWidget(w);
   }
+}
+
+
+static Image
+getIconFrame(FrameObj fr)
+{ if ( notNil(fr->application) && notNil(fr->application->icon_image) )
+    return fr->application->icon_image;
+
+  return fr->icon_image;
 }
 
 
@@ -154,6 +165,7 @@
   Widget w;
   DisplayObj d = fr->display;
   DisplayWsXref r = d->ws_ref;
+  Image icon;
 
   XtSetArg(args[n], XtNtitle,		  nameToMB(fr->label));   n++;
   XtSetArg(args[n], XtNmappedWhenManaged, False);                 n++;
@@ -177,13 +189,13 @@
   { XtSetArg(args[n], XtNsaveUnder, True);
     n++;
   }
-  if ( notNil(fr->icon_image) )
+  if ( notNil(icon=getIconFrame(fr)) )
   { XtSetArg(args[n], XtNiconPixmap,
-	     getXrefObject(fr->icon_image, fr->display));
+	     getXrefObject(icon, fr->display));
     n++;
-    if ( notNil(fr->icon_image->mask) )
+    if ( notNil(icon->mask) )
     { XtSetArg(args[n], XtNiconMask,
-	       getXrefObject(fr->icon_image->mask, fr->display));
+	       getXrefObject(icon->mask, fr->display));
       n++;
     }
   }
@@ -263,6 +275,10 @@
 
   ws_frame_background(fr, fr->background); /* Why is this necessary? */
   ws_group_frame(fr);
+  if ( notNil(fr->application) && notNil(fr->application->icon_image) )
+    ws_set_pid_frame(fr);		   /* group in Ubuntu dock */
+
+  ws_set_net_icon_frame(fr);
 }
 
 
@@ -410,6 +426,28 @@
 
   fail;
 }
+
+static int
+ws_set_pid_frame(FrameObj fr)
+{ Widget w = widgetFrame(fr);
+  DisplayWsXref r = fr->display->ws_ref;
+  unsigned int xpid = getpid();
+  static Atom _net_wm_pid = 0;
+
+  if ( !_net_wm_pid )
+    _net_wm_pid = XInternAtom(r->display_xref,
+			      "_NET_WM_PID",
+			      False);
+
+  XChangeProperty(r->display_xref,
+		  XtWindow(w),
+		  _net_wm_pid,
+		  XA_CARDINAL, 32, PropModeReplace,
+		  (unsigned char *) &xpid, 1);
+
+  return TRUE;
+}
+
 
 #ifdef O_XDND
 		 /*******************************
@@ -1364,6 +1402,42 @@
 }
 
 
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+See https://stackoverflow.com/questions/10699927/xlib-argb-window-icon
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+static void
+ws_set_net_icon_frame(FrameObj fr)
+{ unsigned long *buffer;
+  size_t length;
+  Image icon = getIconFrame(fr);
+
+  if ( notNil(icon) &&
+       getXrefObject(icon, fr->display) &&
+       (buffer=ws_image_to_rgba(icon, DEFAULT, &length)) )
+  { Widget w = widgetFrame(fr);
+    DisplayWsXref r = fr->display->ws_ref;
+    static Atom _net_wm_icon = 0;
+    static Atom cardinal     = 0;
+
+    if ( !_net_wm_icon ) {
+      _net_wm_icon = XInternAtom(r->display_xref,
+				 "_NET_WM_ICON",
+				 False);
+      cardinal = XInternAtom(r->display_xref, "CARDINAL", False);
+    }
+
+    XChangeProperty(r->display_xref,
+		    XtWindow(w),
+		    _net_wm_icon,
+		    cardinal, 32,
+		    PropModeReplace, (const unsigned char*) buffer, length);
+
+    free(buffer);
+  }
+}
+
+
 void
 ws_set_icon_label_frame(FrameObj fr)
 { Widget w = widgetFrame(fr);
diff --git a/packages/xpce/src/x11/ximage.c b/packages/xpce/src/x11/ximage.c
index dcb12c3..e556478 100644
--- a/packages/xpce/src/x11/ximage.c
+++ b/packages/xpce/src/x11/ximage.c
@@ -150,6 +150,44 @@
     return errorPce(image, NAME_cannotSaveObject, NAME_noImage);
 
   succeed;
+}
+
+
+unsigned long *
+ws_image_to_rgba(Image image, Image mask, size_t *lenp)
+{ XImage *img, *msk = NULL;
+  int img_free=FALSE;
+  int msk_free=FALSE;
+  DisplayObj d = image->display;
+  DisplayWsXref r;
+  unsigned long *data;
+
+  if ( isNil(d) )
+    d = CurrentDisplay(image);
+  r = d->ws_ref;
+
+  if ( isDefault(mask) )
+    mask = image->mask;
+
+  if ( !(img=getXImageImage(image)) )
+  { if ( (img = getXImageImageFromScreen(image)) )
+      img_free = TRUE;
+    else
+      return NULL;
+  }
+
+  if ( notNil(mask) )
+  { if ( !(msk=getXImageImage(mask)) )
+    { if ( (msk = getXImageImageFromScreen(mask)) )
+	msk_free = TRUE;
+    }
+  }
+
+  data = XImageToRGBA(img, msk, r->display_xref, 0, lenp);
+  if ( img_free ) XDestroyImage(img);
+  if ( msk_free ) XDestroyImage(msk);
+
+  return data;
 }
 
 
diff --git a/packages/xpce/src/x11/xppm.c b/packages/xpce/src/x11/xppm.c
index 01b826d..def5cdf 100644
--- a/packages/xpce/src/x11/xppm.c
+++ b/packages/xpce/src/x11/xppm.c
@@ -99,7 +99,7 @@
 };
 
 struct table
-{ int 		size;
+{ int		size;
   Symbol	symbols[1];
 };
 
@@ -835,7 +835,7 @@
 		c = pixelToColor(img, pixel, &info);
 		r = intensityXColor(c);
 		r = rescale(r, BRIGHT, scale);
-  		if ( Sputc(r, fd) == EOF )
+		if ( Sputc(r, fd) == EOF )
 		  return -1;
 	      }
 	    }
@@ -883,3 +883,92 @@
 
   return 0;
 }
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Translate an XImage and an optional mask into  an RBGA image in a format
+that is suitable for _NET_WM_ICON.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+unsigned long *
+XImageToRGBA(XImage *img, XImage *msk,
+	     Display *disp, Colormap cmap, size_t *lenp)
+{ int width  = img->width;
+  int height = img->height;
+  XPixelInfo img_info;
+  XPixelInfo msk_info;
+  XColor img_cdata[256];
+  XColor msk_cdata[256];
+  int msk_is_bitmap = TRUE;
+  int x, y;
+  unsigned long *data, *p;
+  const int scale = 255;
+  size_t len;
+
+  if ( msk && (msk->height != height || msk->width != width) )
+    msk = NULL;
+
+  if ( img->format != XYBitmap )
+  { img_info.cinfo = img_cdata;
+    makeXPixelInfo(&img_info, img, disp, cmap);
+  }
+  if ( msk )
+  { if ( msk->format == XYBitmap ||
+	 (msk->format == ZPixmap && msk->bits_per_pixel == 1) )
+    { msk_is_bitmap = TRUE;
+    } else
+    { msk_is_bitmap = FALSE;
+      msk_info.cinfo = msk_cdata;
+      makeXPixelInfo(&msk_info, msk, disp, cmap);
+    }
+  }
+
+  len = 2+width*height;
+  if ( lenp )
+    *lenp = len;
+  if ( !(data = malloc(len*sizeof(*data))) )
+    return data;
+  p = data;
+  *p++ = width;
+  *p++ = height;
+
+  for(y=0; y<height; y++)
+  { for(x=0; x<width; x++)
+    { XColor *c;
+      unsigned int r, g, b, a;
+      union
+      { unsigned int i32;
+	char c32[4];
+      } upix;
+
+      c = pixelToColor(img, XGetPixel(img, x, y), &img_info);
+      r = rescale(c->red,   BRIGHT, scale);
+      g = rescale(c->green, BRIGHT, scale);
+      b = rescale(c->blue,  BRIGHT, scale);
+
+      if ( msk )
+      { unsigned long pixel = XGetPixel(msk, x, y);
+	if ( msk_is_bitmap )
+	{ a = pixel ? scale : 0;
+	} else
+	{ XColor *c;
+	  int r;
+
+	  c = pixelToColor(img, pixel, &msk_info);
+	  r = intensityXColor(c);
+	  a = rescale(r, BRIGHT, scale);
+	}
+      } else
+      { a = 255;
+      }
+
+      upix.c32[0] = b;			/* blue */
+      upix.c32[1] = g;			/* green */
+      upix.c32[2] = r;			/* red */
+      upix.c32[3] = a;
+      *p++ = upix.i32;
+    }
+  }
+
+  return data;
+}
diff --git a/packages/xpce/src/xpce-copy.c b/packages/xpce/src/xpce-copy.c
deleted file mode 100644
index a97e41a..0000000
--- a/packages/xpce/src/xpce-copy.c
+++ /dev/null
@@ -1,783 +0,0 @@
-/*  Part of XPCE --- The SWI-Prolog GUI toolkit
-
-    Author:        Jan Wielemaker and Anjo Anjewierden
-    E-mail:        J.Wielemaker@vu.nl
-    WWW:           http://www.swi-prolog.org/projects/xpce/
-    Copyright (c)  2013, University of Amsterdam
-                         VU University Amsterdam
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions
-    are met:
-
-    1. Redistributions of source code must retain the above copyright
-       notice, this list of conditions and the following disclaimer.
-
-    2. Redistributions in binary form must reproduce the above copyright
-       notice, this list of conditions and the following disclaimer in
-       the documentation and/or other materials provided with the
-       distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-    POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-SYNOPSIS:
-	xpce-copy [-v] [-c] [-m mode] from to
-	xpce-copy [-v] [-c] [-m mode] [-p] file file ... dir
-
-Simple install replacement  to  be  used   for  XPCE  installation.  The
-configure install.sh script is very slow,   while  all operating systems
-appear to be using different versions of install. This should solve this
-problem.
-
-This installer is also used to install the system under windows to avoid
-the limitiations and  portability  issues   around  the  Windows command
-interpreter and copy command.
-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <fcntl.h>
-#include <errno.h>
-#include <time.h>
-#include <string.h>
-
-#ifndef MAXPATHLEN
-#define MAXPATHLEN 1024
-#endif
-
-#ifndef TRUE
-#define TRUE 1
-#define FALSE 0
-#endif
-
-#define bool int
-#define shift (argc--, argv++)
-
-#define CPBUFSIZE 8192
-
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
-#if defined(_MSC_VER) || defined(__MINGW32__)
-#ifndef __WINDOWS__
-#define __WINDOWS__
-#endif
-#endif
-
-#ifdef __WINDOWS__
-#include <io.h>				/* read, write, etc */
-#include <direct.h>			/* mkdir, chdir */
-#define IsDirSep(c) ((c) == '/' || (c) == '\\')
-#define DIRSEP '\\'
-#define mode_t unsigned short
-#else
-#define IsDirSep(c) ((c) == '/')
-#define DIRSEP '/'
-#endif
-
-		 /*******************************
-		 *	       SETTINGS		*
-		 *******************************/
-
-unsigned short mode;
-bool	 set_mode;
-bool	 copy;
-char *	 program;
-int	 verbose=0;
-bool	 makedirs;
-bool	 strippath = -1;		/* i.e. use basename() */
-bool	 installdirs = FALSE;		/* -d */
-bool	 newer_only = FALSE;
-
-static int
-get_mode(const char *s, unsigned short *m)
-{ unsigned short mode = 0;
-
-  while(*s >= '0' && *s <= '7')
-  { mode = (mode << 3) + *s++ - '0';
-  }
-
-  if ( *s )
-    return FALSE;
-
-  *m = mode;
-  return TRUE;
-}
-
-
-static int
-isdir(const char *path)
-{ struct stat buf;
-  char tmp[MAXPATHLEN];
-  char *s;
-
-  strcpy(tmp, path);			/* delete trailing / to work */
-  s = tmp+strlen(tmp);			/* around bugs in some runtime */
-  if ( s>tmp && s[-1] == '/' )		/* libraries */
-    *--s = 0;
-
-  if ( stat(tmp, &buf) < 0 ||
-       (buf.st_mode & S_IFMT) != S_IFDIR )
-    return FALSE;
-
-  return TRUE;
-}
-
-
-static void
-get_file_mode(const char *name, int fd, mode_t *m)
-{ struct stat buf;
-
-#ifdef HAVE_FSTAT
-  if ( fstat(fd, &buf) == 0 )
-#else
-  if ( stat(name, &buf) == 0 )
-#endif
-    *m = buf.st_mode;
-  else
-    *m = 0755;				/* default (hack) */
-}
-
-
-static int
-last_modified(const char *name, time_t *t)
-{ struct stat buf;
-
-  if ( stat(name, &buf) == 0 )
-  { *t = buf.st_mtime;
-    return 0;
-  } else
-    return -1;
-}
-
-
-const char *
-basename(const char *path)
-{ const char *base;
-
-  for(base=path; *path; path++)
-  { if ( IsDirSep(*path) )
-      base = path+1;
-  }
-
-  return base;
-}
-
-
-char *
-dirname(const char *path)		/* returns malloced directory name */
-{ const char *base = basename(path);
-  char *rval;
-
-  while(base > path && IsDirSep(base[-1]) )
-    base--;
-
-  if ( !(rval = malloc(base-path+1)) )
-  { perror("malloc");
-    exit(1);
-  }
-  memcpy(rval, path, base-path);
-  rval[base-path] = '\0';
-
-  return rval;
-}
-
-
-static int
-makedir(char *path)
-{ again:
-
-#ifdef __WINDOWS__
-  if ( mkdir(path) == 0 )
-#else
-  if ( mkdir(path, 0777) == 0 )
-#endif
-  { free(path);
-    return TRUE;
-  }
-
-  if ( errno == ENOENT )
-  { if ( makedir(dirname(path)) )
-      goto again;
-  }
-
-  free(path);
-  return FALSE;
-}
-
-
-static char *
-str_store(const char *in)
-{ char *rval;
-
-  if ( (rval = malloc(strlen(in)+1)) )
-  { strcpy(rval, in);
-    return rval;
-  }
-
-  perror("malloc");
-  exit(1);
-}
-
-
-static int
-install_dir(const char *name)
-{ if ( !isdir(name) )
-    return makedir(str_store(name));
-
-  return TRUE;
-}
-
-
-static int
-install_file(const char *from, const char *to)
-{ int fdfrom, fdto;
-  char buf[CPBUFSIZE];
-  int rval;
-  int n;
-  mode_t m;
-
-  if ( newer_only )
-  { time_t to_time;
-
-    if ( last_modified(to, &to_time) == 0 )
-    { time_t from_time;
-
-      if ( last_modified(from, &from_time) != 0 )
-      { perror(from);
-	return FALSE;
-      }
-
-      if ( difftime(from_time, to_time) < 0.0 )
-      { if ( verbose >= 2 )
-	  fprintf(stderr, "Skipped %s (not modified)\n", to);
-	return TRUE;
-      }
-    }
-  }
-
-  if ( (fdfrom = open(from, O_RDONLY|O_BINARY)) < 0 )
-  { perror(from);
-    return FALSE;
-  }
-
-  if ( set_mode )
-    m = mode;
-  else
-    get_file_mode(from, fdfrom, &m);
-
-  unlink(to);
-  again:
-  if ( (fdto = open(to, O_WRONLY|O_BINARY|O_CREAT|O_TRUNC, m)) < 0 )
-  { if ( errno == ENOENT && makedir(dirname(to)) )
-      goto again;
-    perror(to);
-    close(fdfrom);
-    return FALSE;
-  }
-
-  while( (n = read(fdfrom, buf, CPBUFSIZE)) > 0 )
-  { char *b = buf;
-
-    while(n > 0)
-    { int n2;
-
-      if ( (n2=write(fdto, b, n)) < 0 )
-      { perror(to);
-	rval = FALSE;
-	goto out;
-      }
-      b += n2;
-      n -= n2;
-    }
-  }
-  if ( n < 0 )
-  { perror(from);
-    rval = FALSE;
-  } else
-    rval = TRUE;
-
-out:
-  close(fdfrom);
-  close(fdto);
-
-  return rval;
-}
-
-
-const char *
-strip_path(const char *path, int strip)
-{ if ( strip < 0 )
-    return basename(path);
-  else
-  { const char *base = path;
-
-    while(strip-- > 0)
-    { while( IsDirSep(*base) )
-	base++;
-      while( *base && !IsDirSep(*base) )
-	base++;
-      while( IsDirSep(*base) )
-	base++;
-    }
-
-    return base;
-  }
-}
-
-
-static int
-install_file_in_dir(const char *file, const char *dir)
-{ char path[MAXPATHLEN];
-  const char *base = strip_path(file, strippath);
-  int rval;
-
-  sprintf(path, "%s%c%s", dir, DIRSEP, base);
-
-  if ( (rval = install_file(file, path)) && verbose )
-    printf("%s\n", base);
-
-  return rval;
-}
-
-		 /*******************************
-		 *	       IGNORE		*
-		 *******************************/
-
-#define MAXLINE 1024
-#define EOS '\0'
-
-int compilePattern(const char *p);
-int matchPattern(const char *s);
-
-typedef struct icell *Icell;
-
-struct icell
-{ char *pattern;
-  Icell next;
-};
-
-typedef struct
-{ Icell head;
-  Icell tail;
-} ilist, *Ilist;
-
-ilist _ignore_patterns;
-Ilist ignore_patterns = &_ignore_patterns;
-
-void
-to_ignore_list(Ilist ign, const char *pattern)
-{ char *p = str_store(pattern);
-  Icell c = malloc(sizeof(struct icell));
-
-  c->pattern = p;
-  c->next = NULL;
-  if ( ign->tail )
-  { ign->tail->next = c;
-    ign->tail = c;
-  } else
-  { ign->head = ign->tail = c;
-  }
-}
-
-
-int
-ignore(Ilist ign, const char *name)
-{ Icell c;
-
-  for(c = ignore_patterns->head; c; c=c->next)
-  { compilePattern(c->pattern);
-    if ( matchPattern(name) )
-      return TRUE;
-  }
-  for(c = ign->head; c; c=c->next)
-  { compilePattern(c->pattern);
-     if ( matchPattern(name) )
-       return TRUE;
-  }
-
-  return FALSE;
-}
-
-
-static void
-ignoreForDir(Ilist l, char *d)
-{ char n[MAXPATHLEN];
-  FILE *fd;
-
-  sprintf(n, "%s%c.cvsignore", d, DIRSEP);
-  if ( (fd = fopen(n, "r")) )
-  { char p[MAXLINE];
-
-    while( fgets(p, sizeof(p), fd) )
-    { char *s = p;
-      int len;
-
-      while(*s && *s < ' ')
-	s++;
-      len = strlen(s);
-
-      while( len > 0 && s[len-1] < ' ' )
-	len--;
-      s[len] = EOS;
-
-      if ( len > 0 )
-      { if ( verbose )
-	  printf("ignore %s in %s\n", s, d);
-	to_ignore_list(l, s);
-      }
-    }
-
-    fclose(fd);
-  }
-}
-
-
-		 /*******************************
-		 *	  WILDCHART MATCH	*
-		 *******************************/
-
-#define succeed return(TRUE);
-#define fail	return(FALSE);
-#ifndef uchar
-#define uchar unsigned char
-#endif
-
-#define MAXCODE 512
-
-#define ANY	128
-#define STAR	129
-#define ALT	130
-#define JMP	131
-#define ANYOF	132
-#define EXIT	133
-
-#define NOCURL	0
-#define CURL	1
-
-#define warning(text) \
-	(fprintf(stderr, "%s: bad pattern: %s\n", program, text), \
-	 exit(0))
-
-#define Output(c)	{ if ( Out->size > MAXCODE-1 ) \
-			  { warning("pattern too large"); \
-			    return (char *) NULL; \
-			  } \
-			  Out->code[Out->size++] = c; \
-			}
-#define setMap(c)	{ map[(c)/8] |= 1 << ((c) % 8); }
-
-static struct _pattern_buffer
-{ int	size;
-  uchar	code[MAXCODE];
-} default_pattern_buffer;
-
-static char	*compile_pattern(struct _pattern_buffer*, const char *, int);
-static int	match_pattern(uchar *, const char *);
-
-int
-compilePattern(const char *p)
-{ default_pattern_buffer.size = 0;
-  if ( compile_pattern(&default_pattern_buffer, p, NOCURL) == (char *) NULL )
-    fail;
-
-  succeed;
-}
-
-
-static char *
-compile_pattern(struct _pattern_buffer *Out, const char *p, int curl)
-{ char c;
-
-  for(;;)
-  { switch(c = *p++)
-    { case EOS:
-	break;
-      case '\\':
-	Output(*p == EOS ? '\\' : (*p & 0x7f));
-	if (*p == EOS )
-	  break;
-	p++;
-	continue;
-      case '?':
-	Output(ANY);
-	continue;
-      case '*':
-	Output(STAR);
-	continue;
-      case '[':
-	{ uchar *map;
-	  int n;
-
-	  Output(ANYOF);
-	  map = &Out->code[Out->size];
-	  Out->size += 16;
-	  if ( Out->size >= MAXCODE )
-	  { warning("Pattern too long");
-	    return (char *) NULL;
-	  }
-
-	  for( n=0; n < 16; n++)
-	    map[n] = 0;
-
-	  for(;;)
-	  { switch( c = *p++ )
-	    { case '\\':
-		if ( *p == EOS )
-		{ warning("Unmatched '['");
-		  return (char *)NULL;
-		}
-		setMap(*p);
-		p++;
-		continue;
-	      case ']':
-		break;
-	      default:
-		if ( p[-1] != ']' && p[0] == '-' && p[1] != ']' )
-		{ register int chr;
-
-		  for ( chr=p[-1]; chr <= p[1]; chr++ )
-		    setMap(chr);
-		  p += 2;
-		} else
-		  setMap(c);
-		continue;
-	    }
-	    break;
-	  }
-
-	  continue;
-	}
-      case '{':
-	{ int ai, aj = -1;
-
-	  for(;;)
-	  { Output(ALT); ai = Out->size; Output(0);
-	    if ( (p = compile_pattern(Out, p, CURL)) == (char *) NULL )
-	      return (char *) NULL;
-	    if ( aj > 0 )
-	      Out->code[aj] = Out->size - aj;
-	    if ( *p == ',' )
-	    { Output(JMP); aj = Out->size; Output(0);
-	      Out->code[ai] = Out->size - ai;
-	      Output(ALT); ai = Out->size; Output(0);
-	      p++;
-	    } else if ( *p == '}' )
-	    { p++;
-	      break;
-	    } else
-	    { warning("Unmatched '{'");
-	      return (char *) NULL;
-	    }
-	  }
-
-	  continue;
-	}
-      case '}':
-      case ',':
-	if ( curl == CURL )
-	{ p--;
-	  return (char *)p;
-	}
-	/*FALLTHROUGH*/
-      default:
-	Output(c & 0x7f);
-	continue;
-    }
-
-    Output(EXIT);
-    return (char *)p;
-  }
-}
-
-
-int
-matchPattern(const char *s)
-{ return match_pattern(default_pattern_buffer.code, s);
-}
-
-
-static int
-match_pattern(uchar *p, const char *s)
-{ uchar c;
-
-  for(;;)
-  { switch( c = *p++ )
-    { case EXIT:
-	  return (*s == EOS ? TRUE : FALSE);
-      case ANY:						/* ? */
-	  if ( *s == EOS )
-	    fail;
-	  s++;
-	  continue;
-      case ANYOF:					/* [...] */
-	  if ( p[*s / 8] & (1 << (*s % 8)) )
-	  { p += 16;
-	    s++;
-	    continue;
-	  }
-	  fail;
-      case STAR:					/* * */
-	  do
-	  { if ( match_pattern(p, s) )
-	      succeed;
-	  } while( *s++ );
-	  fail;
-      case JMP:						/* { ... } */
-	  p += *p;
-	  continue;
-      case ALT:
-	  if ( match_pattern(p+1, s) )
-	    succeed;
-	  p += *p;
-	  continue;
-      default:						/* character */
-	  if ( c != (uchar) *s )
-	    fail;
-	  s++;
-	  continue;
-    }
-  }
-}
-
-		 /*******************************
-		 *		MAIN		*
-		 *******************************/
-
-void
-usage()
-{ fprintf(stderr, "  Usage: %s options file ... directory\n", program);
-  fprintf(stderr, "     or: %s options from to\n", program);
-  fprintf(stderr, "     or: %s [-C dir] -d dir ...\n", program);
-  fprintf(stderr, "options: [-v[N]] [-n] [-c] [-p[N]] [-C dir] [-m mode]\n");
-  exit(1);
-}
-
-
-int
-main(int argc, char **argv)
-{ char *out;
-  int errors = 0;
-
-  program = argv[0];
-  shift;
-  while(argc > 0 && argv[0][0] == '-')
-  { char *opts = &argv[0][1];
-
-    shift;
-    for( ; *opts; opts++ )
-    { switch( *opts )
-      { case 'c':
-	  copy = TRUE;
-	  break;
-	case 'p':
-	  strippath = 0;
-	  makedirs = TRUE;
-	  if ( isdigit(opts[1]&0xff) )
-	  { opts++;
-	    strippath = *opts - '0';
-	  }
-	  break;
-	case 'd':
-	  installdirs = TRUE;
-	  break;
-	case 'n':
-	  newer_only = TRUE;
-	  break;
-	case 'v':
-	  verbose++;
-	  if ( isdigit(opts[1]&0xff) )
-	  { opts++;
-	    verbose = *opts - '0';
-	  }
-	  break;
-	case 'C':
-	{ char *dir = argv[0];
-
-	  shift;
-	  if ( chdir(dir) != 0 )
-	  { perror(dir);
-	    exit(1);
-	  }
-	  break;
-	}
-	case 'm':
-	  if ( argc > 0 && get_mode(argv[0], &mode) )
-	  { shift;
-	    set_mode = TRUE;
-	  }
-	  break;
-	default:
-	  usage();
-      }
-    }
-  }
-
-  if ( argc == 0 )
-    usage();
-  out = argv[argc-1];
-
-  if ( installdirs )
-  { int i;
-
-    for(i=0; i<argc; i++)
-    { if ( !install_dir(argv[i]) )
-	errors++;
-    }
-  } else
-  { if ( isdir(out) )
-    { int i;
-
-      to_ignore_list(ignore_patterns, "*~");
-      to_ignore_list(ignore_patterns, "*.bak");
-      to_ignore_list(ignore_patterns, "*.old");
-      to_ignore_list(ignore_patterns, ".cvsignore");
-      to_ignore_list(ignore_patterns, "CVS");
-      ignoreForDir(ignore_patterns, out);
-
-      for(i=0; i<argc-1; i++)
-      { if ( ignore(ignore_patterns, argv[i]) )
-	  continue;
-
-	if ( isdir(argv[i]) )
-	{ if ( verbose )
-	    fprintf(stderr, "Skipping directory %s\n", argv[i]);
-	  continue;
-	}
-
-	if ( !install_file_in_dir(argv[i], out) )
-	  errors++;
-      }
-    } else
-    { if ( !install_file(argv[0], out) )
-	errors++;
-    }
-  }
-
-  return errors ? 1 : 0;
-}
diff --git a/scripts/make-distribution b/scripts/make-distribution
index a67cb29..9020aa3 100755
--- a/scripts/make-distribution
+++ b/scripts/make-distribution
@@ -94,7 +94,7 @@
 build_PPAs()
 { git branch -D ppa || true
   git checkout -b ppa
-  for distro in xenial bionic disco eoan; do
+  for distro in xenial bionic disco eoan focal; do
     ./scripts/make-ppa --distro=$distro --push
   done
   git checkout master
@@ -102,11 +102,15 @@
 }
 
 build()
-{ build_pdf
-  build_win32
-  build_win64
-  build_source
-  build_PPAs
+{ if [ $(uname) = Darwin ]; then
+    build_macosx_gcc
+  else
+    build_pdf
+    build_win32
+    build_win64
+    build_source
+    build_PPAs
+  fi
 }
 
 ################
@@ -127,7 +131,13 @@
 }
 
 upload_macosx()
-{ upload_file bin build.macosx/swipl-${version}-1.x86_64.dmg
+{ if [ -f build.macosx-gcc/swipl-${version}-1.x86_64.dmg ]; then
+    echo "Uploading fast GCC version"
+    upload_file bin build.macosx-gcc/swipl-${version}-1.x86_64.dmg
+  else
+    echo "WARNING: uploading slow Clang version"
+    upload_file bin build.macosx/swipl-${version}-1.x86_64.dmg
+  fi
 }
 
 upload_pdf()
diff --git a/scripts/make-ppa b/scripts/make-ppa
index 0c4ea78..0ca7d67 100755
--- a/scripts/make-ppa
+++ b/scripts/make-ppa
@@ -8,7 +8,7 @@
 PL_VERSION=`cat VERSION`
 VTAG=HEAD
 TARGET_DISTRO=none
-distros="xenial bionic disco eoan"
+distros="xenial bionic disco eoan focal"
 build=true
 buildbin=false
 push=false
diff --git a/snap/local/publish.md b/snap/local/publish.md
index 5472742..32dfec7 100644
--- a/snap/local/publish.md
+++ b/snap/local/publish.md
@@ -2,6 +2,7 @@
 
 ## Building
 
+   snapcraft clean swi-prolog
    snapcraft
 
 ## Local testing
diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml
index c95b761..d1b0d32 100644
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -89,6 +89,7 @@
       - libxt6
       - odbc-postgresql
       - tdsodbc
+      - libtcmalloc-minimal4
       - unixodbc
     build-packages:
       - libarchive-dev
@@ -115,3 +116,4 @@
       - zlib1g-dev
       - libyaml-dev
       - libglvnd-dev
+      - libgoogle-perftools-dev
diff --git a/src/ATOMS b/src/ATOMS
index df4b7f8..036fc89 100644
--- a/src/ATOMS
+++ b/src/ATOMS
@@ -8,6 +8,7 @@
 # This file is processed using defatom, compiled from defatom.c to
 # produce pl-atom.ic, pl-atom.ih, pl-funct.ic and pl-funct.ih.
 
+A abi			"abi"
 A abort			"abort"
 A aborted		"$aborted"
 A abs			"abs"
@@ -92,6 +93,7 @@
 A btree			"btree"
 A buffer		"buffer"
 A buffer_size		"buffer_size"
+A built_in		"built_in"
 A built_in_procedure	"built_in_procedure"
 A busy			"busy"
 A byte			"byte"
@@ -322,6 +324,7 @@
 A floor			"floor"
 A force			"force"
 A foreign		"foreign"
+A foreign_interface	"foreign_interface"
 A foreign_function	"$foreign_function"
 A foreign_return_value	"foreign_return_value"
 A fork			"fork"
@@ -620,6 +623,8 @@
 A prove			":-"
 A public		"public"
 A punct			"punct"
+A qlf			"qlf"
+A qlf_min_load		"qlf_min_load"
 A quasi_quotation	"quasi_quotation"
 A quasi_quotation_position  "quasi_quotation_position"
 A quasi_quotation_syntax	"quasi_quotation_syntax"
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 068c244..d2b3585 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -137,7 +137,8 @@
     sandbox.pl prolog_format.pl prolog_install.pl check_installation.pl
     solution_sequences.pl iostream.pl dicts.pl yall.pl tabling.pl
     lazy_lists.pl prolog_jiti.pl zip.pl obfuscate.pl wfs.pl
-    prolog_wrap.pl prolog_trace.pl prolog_code.pl intercept.pl)
+    prolog_wrap.pl prolog_trace.pl prolog_code.pl intercept.pl
+    prolog_deps.pl)
 if(INSTALL_DOCUMENTATION)
   set(SWIPL_DATA_library ${SWIPL_DATA_library} help.pl)
 endif()
diff --git a/src/SWI-Prolog.h b/src/SWI-Prolog.h
index 73a628d..149253b 100644
--- a/src/SWI-Prolog.h
+++ b/src/SWI-Prolog.h
@@ -3,7 +3,7 @@
     Author:        Jan Wielemaker
     E-mail:        J.Wielemaker@vu.nl
     WWW:           http://www.swi-prolog.org
-    Copyright (c)  2008-2017, University of Amsterdam
+    Copyright (c)  2008-2020, University of Amsterdam
                               VU University Amsterdam
     All rights reserved.
 
@@ -68,11 +68,25 @@
 /* PLVERSION_TAG: a string, normally "", but for example "rc1" */
 
 #ifndef PLVERSION
-#define PLVERSION 80129
+#define PLVERSION 80130
 #endif
 #ifndef PLVERSION_TAG
 #define PLVERSION_TAG ""
 #endif
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+This number is incremented when the   SWI-Prolog PL_*() functions or one
+of the data types is modified such that old binary extensions cannot run
+reliably with the  current  version.  This   version  is  introduced  in
+SWI-Prolog 8.1.30. The  most  recent   violation  of  compatibility  was
+between versions 8.1.21 and 8.1.22  with   the  introduction of rational
+numbers are atomic type.
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+#define PL_FLI_VERSION      2		/* PL_*() functions */
+#define	PL_REC_VERSION      3		/* PL_record_external(), fastrw */
+#define PL_QLF_LOADVERSION 67		/* load all versions later >= X */
+#define PL_QLF_VERSION     67		/* save version number */
 
 
 		 /*******************************
@@ -191,6 +205,7 @@
     size_t arity;
   } t;
 } term_value_t;
+
 
 #ifndef TRUE
 #define TRUE	(1)
@@ -485,6 +500,7 @@
 PL_EXPORT(int)		PL_get_module(term_t t, module_t *module) WUNUSED;
 PL_EXPORT(int)		PL_get_arg_sz(size_t index, term_t t, term_t a) WUNUSED;
 PL_EXPORT(int)		PL_get_arg(int index, term_t t, term_t a) WUNUSED;
+PL_EXPORT(int)		PL_get_dict_key(atom_t key, term_t dict, term_t value);
 PL_EXPORT(int)		PL_get_list(term_t l, term_t h, term_t t) WUNUSED;
 PL_EXPORT(int)		PL_get_head(term_t l, term_t h) WUNUSED;
 PL_EXPORT(int)		PL_get_tail(term_t l, term_t t) WUNUSED;
@@ -505,6 +521,7 @@
 PL_EXPORT(int)		PL_is_callable(term_t t);
 PL_EXPORT(int)		PL_is_functor(term_t t, functor_t f);
 PL_EXPORT(int)		PL_is_list(term_t t);
+PL_EXPORT(int)		PL_is_dict(term_t t);
 PL_EXPORT(int)		PL_is_pair(term_t t);
 PL_EXPORT(int)		PL_is_atomic(term_t t);
 PL_EXPORT(int)		PL_is_number(term_t t);
@@ -531,6 +548,8 @@
 PL_EXPORT(int)		PL_put_list(term_t l) WUNUSED;
 PL_EXPORT(int)		PL_put_nil(term_t l);
 PL_EXPORT(int)		PL_put_term(term_t t1, term_t t2);
+PL_EXPORT(int)		PL_put_dict(term_t t, atom_t tag, size_t len,
+				    const atom_t *keys, term_t values);
 
 			/* construct a functor or list-cell */
 PL_EXPORT(int)		PL_cons_functor(term_t h, functor_t f, ...) WUNUSED;
@@ -838,10 +857,11 @@
 #define CVT_EXCEPTION	    0x00001000	/* throw exception on error */
 #define CVT_VARNOFAIL	    0x00002000	/* return 2 if argument is unbound */
 
-#define BUF_DISCARDABLE	    0x00000000
-#define BUF_RING	    0x00010000
-#define BUF_MALLOC	    0x00020000
-#define BUF_ALLOW_STACK	    0x00040000	/* allow pointer into (global) stack */
+#define BUF_DISCARDABLE	    0x00000000	/* Store in single thread-local buffer */
+#define BUF_RING	    0x00010000	/* Store in ring of 16 buffers */
+#define BUF_MALLOC	    0x00020000	/* Store using PL_malloc() */
+#define BUF_ALLOW_STACK	    0x00040000	/* Allow pointer into (global) stack */
+#define BUF_NORING	    0x00080000	/* Do not store in ring */
 
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -1086,6 +1106,21 @@
 PL_EXPORT(int)	PL_current_prolog_flag(atom_t name, int type, void *ptr);
 
 
+		 /*******************************
+		 *	      VERSIONS		*
+		 *******************************/
+
+#define PL_VERSION_SYSTEM	1	/* Prolog version */
+#define PL_VERSION_FLI		2	/* PL_* compatibility */
+#define PL_VERSION_REC		3	/* PL_record_external() compatibility */
+#define PL_VERSION_QLF		4	/* Saved QLF format version */
+#define PL_VERSION_QLF_LOAD	5	/* Min loadable QLF format version */
+#define PL_VERSION_VM		6	/* VM signature */
+#define PL_VERSION_BUILT_IN	7	/* Built-in predicate signature */
+
+PL_EXPORT(unsigned int) PL_version(int which);
+
+
 		/********************************
 		*         QUERY PROLOG          *
 		*********************************/
diff --git a/src/Tests/xsb/table_tests/exec.P b/src/Tests/xsb/table_tests/exec.P
new file mode 100644
index 0000000..8f30cf6
--- /dev/null
+++ b/src/Tests/xsb/table_tests/exec.P
@@ -0,0 +1,448 @@
+% Author: Bart Demoen K.U.Leuven
+% Date: Oct 21 1996
+
+makeground([]) .
+makeground([X|R]) :- mkgr(X) , makeground(R) .
+
+mkgr(X) :- var(X) , ! , (X = g ; X = i ; X = v) .
+mkgr(_) .
+
+mymember(X,[Y|R]) :- mm(X,R,Y) .
+mm(X,_,X) .
+mm(X,[Y|R],_) :- mm(X,R,Y) .
+
+:- table(compute1/4) .
+
+compute(Vars,DRs,Mal,DR) :- compute1(Vars,DRs,Mal,DR), fail .
+compute(Vars,DRs,Mal,DR) :- compute1(Vars,DRs,Mal,DR).
+
+compute1(Vars,DRs,Mal,DR) :-
+	findall(Mal,(lookup(Vars,DRs),makeground(Mal)),All),
+	sort(All,DR) .
+
+lookup([],[]) .
+lookup([V|VarList],[DR|DRList]) :- mymember(V,DR) , lookup(VarList,DRList) .
+
+fail_iff_0([],_) :- fail .
+
+iffequal_2([_,_],[[g,g],[i,i],[v,v]]) .
+
+iff_1([_],[[g]]) .
+
+iff_2([_,_],
+[[g,g],
+[i,i],
+[i,v]]) .
+
+iff_3([_,_,_],
+[[g,g,g],
+[i,g,i],
+[i,g,v],
+[i,i,g],
+[i,i,i],
+[i,i,v],
+[i,v,g],
+[i,v,i],
+[i,v,v]]) .
+
+iff_4([_,_,_,_],
+[[g,g,g,g],
+[i,g,g,i],
+[i,g,g,v],
+[i,g,i,g],
+[i,g,i,i],
+[i,g,i,v],
+[i,g,v,g]|R]) :- r4_1(R) .
+r4_1([
+[i,g,v,i],
+[i,g,v,v],
+[i,i,g,g],
+[i,i,g,i],
+[i,i,g,v],
+[i,i,i,g],
+[i,i,i,i],
+[i,i,i,v],
+[i,i,v,g],
+[i,i,v,i],
+[i,i,v,v]|R]) :- r4_2(R) .
+r4_2([
+[i,v,g,g],
+[i,v,g,i],
+[i,v,g,v],
+[i,v,i,g],
+[i,v,i,i],
+[i,v,i,v],
+[i,v,v,g],
+[i,v,v,i],
+[i,v,v,v]]) .
+
+
+iff_5([_,_,_,_,_],
+[[g,g,g,g,g],
+[i,g,g,g,i],
+[i,g,g,g,v],
+[i,g,g,i,g],
+[i,g,g,i,i],
+[i,g,g,i,v],
+[i,g,g,v,g],
+[i,g,g,v,i],
+[i,g,g,v,v],
+[i,g,i,g,g]|R]) :- r5_1(R) .
+r5_1([
+[i,g,i,g,i],
+[i,g,i,g,v],
+[i,g,i,i,g],
+[i,g,i,i,i],
+[i,g,i,i,v],
+[i,g,i,v,g],
+[i,g,i,v,i],
+[i,g,i,v,v],
+[i,g,v,g,g],
+[i,g,v,g,i]|R]) :- r5_2(R) .
+r5_2([
+[i,g,v,g,v],
+[i,g,v,i,g],
+[i,g,v,i,i],
+[i,g,v,i,v],
+[i,g,v,v,g],
+[i,g,v,v,i],
+[i,g,v,v,v],
+[i,i,g,g,g],
+[i,i,g,g,i]|R]) :- r5_3(R) .
+r5_3([
+[i,i,g,g,v],
+[i,i,g,i,g],
+[i,i,g,i,i],
+[i,i,g,i,v],
+[i,i,g,v,g],
+[i,i,g,v,i],
+[i,i,g,v,v],
+[i,i,i,g,g],
+[i,i,i,g,i]|R]) :- r5_4(R) .
+r5_4([
+[i,i,i,g,v],
+[i,i,i,i,g],
+[i,i,i,i,i],
+[i,i,i,i,v],
+[i,i,i,v,g],
+[i,i,i,v,i],
+[i,i,i,v,v],
+[i,i,v,g,g],
+[i,i,v,g,i]|R]) :- r5_5(R) .
+r5_5([
+[i,i,v,g,v],
+[i,i,v,i,g],
+[i,i,v,i,i],
+[i,i,v,i,v],
+[i,i,v,v,g],
+[i,i,v,v,i],
+[i,i,v,v,v],
+[i,v,g,g,g],
+[i,v,g,g,i]|R]) :- r5_6(R) .
+r5_6([
+[i,v,g,g,v],
+[i,v,g,i,g],
+[i,v,g,i,i],
+[i,v,g,i,v],
+[i,v,g,v,g],
+[i,v,g,v,i],
+[i,v,g,v,v],
+[i,v,i,g,g],
+[i,v,i,g,i]|R]) :- r5_7(R) .
+r5_7([
+[i,v,i,g,v],
+[i,v,i,i,g],
+[i,v,i,i,i],
+[i,v,i,i,v],
+[i,v,i,v,g],
+[i,v,i,v,i],
+[i,v,i,v,v],
+[i,v,v,g,g]|R]) :- r5_8(R) .
+r5_8([
+[i,v,v,g,i],
+[i,v,v,g,v],
+[i,v,v,i,g],
+[i,v,v,i,i],
+[i,v,v,i,v],
+[i,v,v,v,g],
+[i,v,v,v,i],
+[i,v,v,v,v]]) .
+
+iff_6([_,_,_,_,_,_],
+[[g,g,g,g,g,g],
+[i,g,g,g,g,i],
+[i,g,g,g,g,v],
+[i,g,g,g,i,g],
+[i,g,g,g,i,i]|R]) :- r6_1(R) .
+r6_1([
+[i,g,g,g,i,v],
+[i,g,g,g,v,g],
+[i,g,g,g,v,i],
+[i,g,g,g,v,v],
+[i,g,g,i,g,g],
+[i,g,g,i,g,i]|R]) :- r6_2(R) .
+r6_2([
+[i,g,g,i,g,v],
+[i,g,g,i,i,g],
+[i,g,g,i,i,i],
+[i,g,g,i,i,v],
+[i,g,g,i,v,g],
+[i,g,g,i,v,i],
+[i,g,g,i,v,v]|R]) :- r6_3(R) .
+r6_3([
+[i,g,g,v,g,g],
+[i,g,g,v,g,i],
+[i,g,g,v,g,v],
+[i,g,g,v,i,g],
+[i,g,g,v,i,i],
+[i,g,g,v,i,v],
+[i,g,g,v,v,g],
+[i,g,g,v,v,i]|R]) :- r6_4(R) .
+r6_4([
+[i,g,g,v,v,v],
+[i,g,i,g,g,g],
+[i,g,i,g,g,i],
+[i,g,i,g,g,v],
+[i,g,i,g,i,g],
+[i,g,i,g,i,i],
+[i,g,i,g,i,v],
+[i,g,i,g,v,g]|R]) :- r6_5(R) .
+r6_5([
+[i,g,i,g,v,i],
+[i,g,i,g,v,v],
+[i,g,i,i,g,g],
+[i,g,i,i,g,i],
+[i,g,i,i,g,v],
+[i,g,i,i,i,g],
+[i,g,i,i,i,i],
+[i,g,i,i,i,v],
+[i,g,i,i,v,g]|R]) :- r6_6(R) .
+r6_6([
+[i,g,i,i,v,i],
+[i,g,i,i,v,v],
+[i,g,i,v,g,g],
+[i,g,i,v,g,i],
+[i,g,i,v,g,v],
+[i,g,i,v,i,g],
+[i,g,i,v,i,i],
+[i,g,i,v,i,v]|R]) :- r6_7(R) .
+r6_7([
+[i,g,i,v,v,g],
+[i,g,i,v,v,i],
+[i,g,i,v,v,v],
+[i,g,v,g,g,g],
+[i,g,v,g,g,i],
+[i,g,v,g,g,v],
+[i,g,v,g,i,g]|R]) :- r6_8(R) .
+r6_8([
+[i,g,v,g,i,i],
+[i,g,v,g,i,v],
+[i,g,v,g,v,g],
+[i,g,v,g,v,i],
+[i,g,v,g,v,v],
+[i,g,v,i,g,g]|R]) :- r6_9(R) .
+r6_9([
+[i,g,v,i,g,i],
+[i,g,v,i,g,v],
+[i,g,v,i,i,g],
+[i,g,v,i,i,i],
+[i,g,v,i,i,v],
+[i,g,v,i,v,g],
+[i,g,v,i,v,i]|R]) :- r6_10(R) .
+r6_10([
+[i,g,v,i,v,v],
+[i,g,v,v,g,g],
+[i,g,v,v,g,i],
+[i,g,v,v,g,v],
+[i,g,v,v,i,g],
+[i,g,v,v,i,i],
+[i,g,v,v,i,v]|R]) :- r6_11(R) .
+r6_11([
+[i,g,v,v,v,g],
+[i,g,v,v,v,i],
+[i,g,v,v,v,v],
+[i,i,g,g,g,g],
+[i,i,g,g,g,i],
+[i,i,g,g,g,v],
+[i,i,g,g,i,g],
+[i,i,g,g,i,i]|R]) :- r6_12(R) .
+r6_12([
+[i,i,g,g,i,v],
+[i,i,g,g,v,g],
+[i,i,g,g,v,i],
+[i,i,g,g,v,v],
+[i,i,g,i,g,g],
+[i,i,g,i,g,i],
+[i,i,g,i,g,v]|R]) :- r6_13(R) .
+r6_13([
+[i,i,g,i,i,g],
+[i,i,g,i,i,i],
+[i,i,g,i,i,v],
+[i,i,g,i,v,g],
+[i,i,g,i,v,i],
+[i,i,g,i,v,v],
+[i,i,g,v,g,g]|R]) :- r6_14(R) .
+r6_14([
+[i,i,g,v,g,i],
+[i,i,g,v,g,v],
+[i,i,g,v,i,g],
+[i,i,g,v,i,i],
+[i,i,g,v,i,v],
+[i,i,g,v,v,g],
+[i,i,g,v,v,i],
+[i,i,g,v,v,v]|R]) :- r6_15(R) .
+r6_15([
+[i,i,i,g,g,g],
+[i,i,i,g,g,i],
+[i,i,i,g,g,v],
+[i,i,i,g,i,g],
+[i,i,i,g,i,i],
+[i,i,i,g,i,v],
+[i,i,i,g,v,g],
+[i,i,i,g,v,i]|R]) :- r6_16(R) .
+r6_16([
+[i,i,i,g,v,v],
+[i,i,i,i,g,g],
+[i,i,i,i,g,i],
+[i,i,i,i,g,v],
+[i,i,i,i,i,g],
+[i,i,i,i,i,i],
+[i,i,i,i,i,v]|R]) :- r6_17(R) .
+r6_17([
+[i,i,i,i,v,g],
+[i,i,i,i,v,i],
+[i,i,i,i,v,v],
+[i,i,i,v,g,g],
+[i,i,i,v,g,i],
+[i,i,i,v,g,v],
+[i,i,i,v,i,g]|R]) :- r6_18(R) .
+r6_18([
+[i,i,i,v,i,i],
+[i,i,i,v,i,v],
+[i,i,i,v,v,g],
+[i,i,i,v,v,i],
+[i,i,i,v,v,v],
+[i,i,v,g,g,g],
+[i,i,v,g,g,i]|R]) :- r6_19(R) .
+r6_19([
+[i,i,v,g,g,v],
+[i,i,v,g,i,g],
+[i,i,v,g,i,i],
+[i,i,v,g,i,v],
+[i,i,v,g,v,g],
+[i,i,v,g,v,i],
+[i,i,v,g,v,v],
+[i,i,v,i,g,g]|R]) :- r6_21(R) .
+r6_21([
+[i,i,v,i,g,i],
+[i,i,v,i,g,v],
+[i,i,v,i,i,g],
+[i,i,v,i,i,i],
+[i,i,v,i,i,v],
+[i,i,v,i,v,g],
+[i,i,v,i,v,i]|R]) :- r6_31(R) .
+r6_31([
+[i,i,v,i,v,v],
+[i,i,v,v,g,g],
+[i,i,v,v,g,i],
+[i,i,v,v,g,v],
+[i,i,v,v,i,g],
+[i,i,v,v,i,i],
+[i,i,v,v,i,v]|R]) :- r6_41(R) .
+r6_41([
+[i,i,v,v,v,g],
+[i,i,v,v,v,i],
+[i,i,v,v,v,v],
+[i,v,g,g,g,g],
+[i,v,g,g,g,i],
+[i,v,g,g,g,v],
+[i,v,g,g,i,g],
+[i,v,g,g,i,i]|R]) :- r6_51(R) .
+r6_51([
+[i,v,g,g,i,v],
+[i,v,g,g,v,g],
+[i,v,g,g,v,i],
+[i,v,g,g,v,v],
+[i,v,g,i,g,g],
+[i,v,g,i,g,i],
+[i,v,g,i,g,v],
+[i,v,g,i,i,g]|R]) :- r6_61(R) .
+r6_61([
+[i,v,g,i,i,i],
+[i,v,g,i,i,v],
+[i,v,g,i,v,g],
+[i,v,g,i,v,i],
+[i,v,g,i,v,v],
+[i,v,g,v,g,g],
+[i,v,g,v,g,i]|R]) :- r6_71(R) .
+r6_71([
+[i,v,g,v,g,v],
+[i,v,g,v,i,g],
+[i,v,g,v,i,i],
+[i,v,g,v,i,v],
+[i,v,g,v,v,g]|R]) :- r6_81(R) .
+r6_81([
+[i,v,g,v,v,i],
+[i,v,g,v,v,v],
+[i,v,i,g,g,g],
+[i,v,i,g,g,i],
+[i,v,i,g,g,v],
+[i,v,i,g,i,g],
+[i,v,i,g,i,i]|R]) :- r6_91(R) .
+r6_91([
+[i,v,i,g,i,v],
+[i,v,i,g,v,g],
+[i,v,i,g,v,i],
+[i,v,i,g,v,v],
+[i,v,i,i,g,g],
+[i,v,i,i,g,i],
+[i,v,i,i,g,v]|R]) :- r6_111(R) .
+r6_111([
+[i,v,i,i,i,g],
+[i,v,i,i,i,i],
+[i,v,i,i,i,v],
+[i,v,i,i,v,g],
+[i,v,i,i,v,i],
+[i,v,i,i,v,v]|R]) :- r6_221(R) .
+r6_221([
+[i,v,i,v,g,g],
+[i,v,i,v,g,i],
+[i,v,i,v,g,v],
+[i,v,i,v,i,g],
+[i,v,i,v,i,i],
+[i,v,i,v,i,v]|R]) :- r6_331(R) .
+r6_331([
+[i,v,i,v,v,g],
+[i,v,i,v,v,i],
+[i,v,i,v,v,v],
+[i,v,v,g,g,g],
+[i,v,v,g,g,i],
+[i,v,v,g,g,v]|R]) :- r6_441(R) .
+r6_441([
+[i,v,v,g,i,g],
+[i,v,v,g,i,i],
+[i,v,v,g,i,v],
+[i,v,v,g,v,g],
+[i,v,v,g,v,i],
+[i,v,v,g,v,v],
+[i,v,v,i,g,g]|R]) :- r6_551(R) .
+r6_551([
+[i,v,v,i,g,i],
+[i,v,v,i,g,v],
+[i,v,v,i,i,g],
+[i,v,v,i,i,i],
+[i,v,v,i,i,v],
+[i,v,v,i,v,g]|R]) :- r6_661(R) .
+r6_661([
+[i,v,v,i,v,i],
+[i,v,v,i,v,v],
+[i,v,v,v,g,g],
+[i,v,v,v,g,i],
+[i,v,v,v,g,v],
+[i,v,v,v,i,g]|R]) :- r6_771(R) .
+r6_771([
+[i,v,v,v,i,i],
+[i,v,v,v,i,v],
+[i,v,v,v,v,g],
+[i,v,v,v,v,i],
+[i,v,v,v,v,v]]) .
diff --git a/src/Tests/xsb/table_tests/expand.P b/src/Tests/xsb/table_tests/expand.P
new file mode 100644
index 0000000..e223171
--- /dev/null
+++ b/src/Tests/xsb/table_tests/expand.P
@@ -0,0 +1,9 @@
+:- [exec].
+:- [kalah_ox].
+%:- import start_forest_view/1 from tables.
+%?- start_forest_view(userout).
+
+% Don't abstract -- no finite model.
+?- set_prolog_flag(max_table_subgoal_size,200000).
+?- set_prolog_flag(max_table_subgoal_size_action,error).
+test :- exec,fail.
diff --git a/src/Tests/xsb/table_tests/expand_old b/src/Tests/xsb/table_tests/expand_old
new file mode 100644
index 0000000..e69de29
diff --git a/src/Tests/xsb/table_tests/kalah_ox.P b/src/Tests/xsb/table_tests/kalah_ox.P
new file mode 100644
index 0000000..6376044
--- /dev/null
+++ b/src/Tests/xsb/table_tests/kalah_ox.P
@@ -0,0 +1,226 @@
+ :- table(play_2 / 2) .
+play_2([ _164 , _165 ], _309 ) :- initialize_3( _345 , _347 ) ,  _345  = [ _164 , _171 , _172 ] , displaygame_2( _388 , _390 ) ,  _388  = [ _171 , _172 ] , play_3( _429 , _431 ) ,  _429  = [ _171 , _172 , _165 ] , compute([[ _171 , _172 , _165 ],[ _171 , _172 ],[ _164 , _171 , _172 ]],[ _431 , _390 , _347 ],[ _164 , _165 ], _309 ) .
+ :- table(play_3 / 2) .
+play_3([ _164 , _165 , _166 ], _268 ) :- gameover_3( _306 , _308 ) ,  _306  = [ _164 , _165 , _166 ] , announce_1( _349 , _351 ) ,  _349  = [ _166 ] , compute([[ _166 ],[ _164 , _165 , _166 ]],[ _351 , _308 ],[ _164 , _165 , _166 ], _268 ) .
+play_3([ _164 , _165 , _166 ], _391 ) :- choosemove_3( _429 , _431 ) ,  _429  = [ _164 , _165 , _173 ] , move_3( _472 , _474 ) ,  _472  = [ _173 , _164 , _180 ] , displaygame_2( _515 , _517 ) ,  _515  = [ _180 , _165 ] , nextplayer_2( _556 , _558 ) ,  _556  = [ _165 , _192 ] , play_3( _597 , _599 ) ,  _597  = [ _180 , _192 , _166 ] , compute([[ _180 , _192 , _166 ],[ _165 , _192 ],[ _180 , _165 ],[ _173 , _164 , _180 ],[ _164 , _165 , _173 ]],[ _599 , _558 , _517 , _474 , _431 ],[ _164 , _165 , _166 ], _391 ) .
+ :- table(choosemove_3 / 2) .
+choosemove_3([ _164 , _200 , _166 ], _343 ) :- iff_1( _381 , _383 ) ,  _381  = [ _200 ] , lookahead_1( _420 , _422 ) ,  _420  = [ _171 ] , iff_1( _459 , _461 ) ,  _459  = [ _260 ] , iff_1( _498 , _500 ) ,  _498  = [ _268 ] , alphabeta_6( _537 , _539 ) ,  _537  = [ _171 , _164 , _260 , _268 , _166 , _178 ] , compute([[ _171 , _164 , _260 , _268 , _166 , _178 ],[ _268 ],[ _260 ],[ _171 ],[ _200 ]],[ _539 , _500 , _461 , _422 , _383 ],[ _164 , _200 , _166 ], _343 ) .
+choosemove_3([ _164 , _190 , _166 ], _246 ) :- iff_1( _284 , _286 ) ,  _284  = [ _190 ] , genlegal_1( _323 , _325 ) ,  _323  = [ _166 ] , compute([[ _166 ],[ _190 ]],[ _325 , _286 ],[ _164 , _190 , _166 ], _246 ) .
+ :- table(alphabeta_6 / 2) .
+alphabeta_6([ _198 , _165 , _166 , _167 , _168 , _169 ], _270 ) :- iff_1( _314 , _316 ) ,  _314  = [ _198 ] , value_2( _353 , _355 ) ,  _353  = [ _165 , _169 ] , compute([[ _165 , _169 ],[ _198 ]],[ _355 , _316 ],[ _198 , _165 , _166 , _167 , _168 , _169 ], _270 ) .
+alphabeta_6([ _164 , _165 , _166 , _167 , _168 , _169 ], _597 ) :- iff_1( _641 , _643 ) ,  _641  = [ _281 ] , myis_2( _680 , _682 ) ,  _680  = [ _164 , _281 ] , allmoves_2( _721 , _723 ) ,  _721  = [ _165 , _181 ] , iff_2( _762 , _764 ) ,  _762  = [ _337 , _167 ] , myis_2( _803 , _805 ) ,  _803  = [ _186 , _337 ] , iff_2( _844 , _846 ) ,  _844  = [ _368 , _166 ] , myis_2( _885 , _887 ) ,  _885  = [ _195 , _368 ] , iff_2( _926 , _928 ) ,  _926  = [ _399 , _164 ] , myis_2( _967 , _969 ) ,  _967  = [ _204 , _399 ] , iff_1( _1008 , _1010 ) ,  _1008  = [ _447 ] , iff_3( _1047 , _1049 ) ,  _1047  = [ _455 , _168 , _169 ] , evaluateandchoose_7( _1090 , _1092 ) ,  _1090  = [ _181 , _165 , _204 , _186 , _195 , _447 , _455 ] , compute([[ _181 , _165 , _204 , _186 , _195 , _447 , _455 ],[ _455 , _168 , _169 ],[ _447 ],[ _204 , _399 ],[ _399 , _164 ],[ _195 , _368 ],[ _368 , _166 ],[ _186 , _337 ],[ _337 , _167 ],[ _165 , _181 ],[ _164 , _281 ],[ _281 ]],[ _1092 , _1049 , _1010 , _969 , _928 , _887 , _846 , _805 , _764 , _723 , _682 , _643 ],[ _164 , _165 , _166 , _167 , _168 , _169 ], _597 ) .
+ :- table(allmoves_2 / 2) .
+allmoves_2([ _164 , _190 ], _251 ) :- iff_2( _287 , _289 ) ,  _287  = [ _190 , _166 ] , move_2( _328 , _330 ) ,  _328  = [ _164 , _166 ] , compute([[ _164 , _166 ],[ _190 , _166 ]],[ _330 , _289 ],[ _164 , _190 ], _251 ) .
+allmoves_2([ _164 , _196 ], _289 ) :- iff_3( _325 , _327 ) ,  _325  = [ _196 , _166 , _167 ] , move_2( _368 , _370 ) ,  _368  = [ _164 , _166 ] , allmoves_2( _409 , _411 ) ,  _409  = [ _164 , _167 ] , compute([[ _164 , _167 ],[ _164 , _166 ],[ _196 , _166 , _167 ]],[ _411 , _370 , _327 ],[ _164 , _196 ], _289 ) .
+ :- table(evaluateandchoose_7 / 2) .
+evaluateandchoose_7([ _236 , _165 , _166 , _167 , _168 , _169 , _170 ], _486 ) :- iff_3( _532 , _534 ) ,  _532  = [ _236 , _171 , _172 ] , move_3( _575 , _577 ) ,  _575  = [ _171 , _165 , _179 ] , alphabeta_6( _618 , _620 ) ,  _618  = [ _166 , _179 , _167 , _168 , _188 , _189 ] , iff_2( _667 , _669 ) ,  _667  = [ _356 , _189 ] , myis_2( _708 , _710 ) ,  _708  = [ _194 , _356 ] , cutoff_9( _749 , _751 ) ,  _749  = [ _171 , _194 , _166 , _167 , _168 , _172 , _165 , _169 , _170 ] , compute([[ _171 , _194 , _166 , _167 , _168 , _172 , _165 , _169 , _170 ],[ _194 , _356 ],[ _356 , _189 ],[ _166 , _179 , _167 , _168 , _188 , _189 ],[ _171 , _165 , _179 ],[ _236 , _171 , _172 ]],[ _751 , _710 , _669 , _620 , _577 , _534 ],[ _236 , _165 , _166 , _167 , _168 , _169 , _170 ], _486 ) .
+evaluateandchoose_7([ _197 , _162 , _163 , _164 , _165 , _166 , _215 ], _269 ) :- iff_1( _315 , _317 ) ,  _315  = [ _197 ] , iff_3( _354 , _356 ) ,  _354  = [ _215 , _166 , _164 ] , compute([[ _215 , _166 , _164 ],[ _197 ]],[ _356 , _317 ],[ _197 , _162 , _163 , _164 , _165 , _166 , _215 ], _269 ) .
+ :- table(cutoff_9 / 2) .
+cutoff_9([ _164 , _165 , _166 , _167 , _168 , _169 , _170 , _171 , _226 ], _297 ) :- iff_3( _347 , _349 ) ,  _347  = [ _226 , _164 , _165 ] , myis_2( _390 , _392 ) ,  _390  = [ _165 , _168 ] , compute([[ _165 , _168 ],[ _226 , _164 , _165 ]],[ _392 , _349 ],[ _164 , _165 , _166 , _167 , _168 , _169 , _170 , _171 , _226 ], _297 ) .
+cutoff_9([ _164 , _165 , _166 , _167 , _168 , _169 , _170 , _171 , _172 ], _369 ) :- myis_2( _419 , _421 ) ,  _419  = [ _167 , _165 ] , myis_2( _460 , _462 ) ,  _460  = [ _165 , _168 ] , evaluateandchoose_7( _501 , _503 ) ,  _501  = [ _169 , _170 , _166 , _165 , _168 , _164 , _172 ] , compute([[ _169 , _170 , _166 , _165 , _168 , _164 , _172 ],[ _165 , _168 ],[ _167 , _165 ]],[ _503 , _462 , _421 ],[ _164 , _165 , _166 , _167 , _168 , _169 , _170 , _171 , _172 ], _369 ) .
+cutoff_9([ _164 , _165 , _166 , _167 , _168 , _169 , _170 , _171 , _172 ], _334 ) :- myis_2( _384 , _386 ) ,  _384  = [ _165 , _167 ] , evaluateandchoose_7( _425 , _427 ) ,  _425  = [ _169 , _170 , _166 , _167 , _168 , _171 , _172 ] , compute([[ _169 , _170 , _166 , _167 , _168 , _171 , _172 ],[ _165 , _167 ]],[ _427 , _386 ],[ _164 , _165 , _166 , _167 , _168 , _169 , _170 , _171 , _172 ], _334 ) .
+ :- table(move_2 / 2) .
+move_2([ _164 , _217 ], _373 ) :- iff_3( _409 , _411 ) ,  _409  = [ _217 , _166 , _167 ] , iff_1( _452 , _454 ) ,  _452  = [ _245 ] , member_2( _491 , _493 ) ,  _491  = [ _166 , _245 ] , stonesinhole_3( _532 , _534 ) ,  _532  = [ _166 , _164 , _192 ] , extendmove_4( _575 , _577 ) ,  _575  = [ _192 , _166 , _164 , _167 ] , compute([[ _192 , _166 , _164 , _167 ],[ _166 , _164 , _192 ],[ _166 , _245 ],[ _245 ],[ _217 , _166 , _167 ]],[ _577 , _534 , _493 , _454 , _411 ],[ _164 , _217 ], _373 ) .
+move_2([ _196 , _204 ], _256 ) :- iff_4( _292 , _294 ) ,  _292  = [ _196 , _165 , _166 , _167 ] , iff_1( _337 , _339 ) ,  _337  = [ _204 ] , compute([[ _204 ],[ _196 , _165 , _166 , _167 ]],[ _339 , _294 ],[ _196 , _204 ], _256 ) .
+ :- table(member_2 / 2) .
+member_2([ _161 , _183 ], _219 ) :- iff_3( _255 , _257 ) ,  _255  = [ _183 , _161 , _164 ] , compute([[ _183 , _161 , _164 ]],[ _257 ],[ _161 , _183 ], _219 ) .
+member_2([ _164 , _190 ], _254 ) :- iff_3( _290 , _292 ) ,  _290  = [ _190 , _166 , _167 ] , member_2( _333 , _335 ) ,  _333  = [ _164 , _167 ] , compute([[ _164 , _167 ],[ _190 , _166 , _167 ]],[ _335 , _292 ],[ _164 , _190 ], _254 ) .
+ :- table(stonesinhole_3 / 2) .
+stonesinhole_3([ _164 , _203 , _166 ], _329 ) :- iff_5( _367 , _369 ) ,  _367  = [ _203 , _168 , _169 , _170 , _171 ] , nthmember_3( _414 , _416 ) ,  _414  = [ _164 , _168 , _166 ] , iff_1( _457 , _459 ) ,  _457  = [ _263 ] , myis_2( _496 , _498 ) ,  _496  = [ _166 , _263 ] , compute([[ _166 , _263 ],[ _263 ],[ _164 , _168 , _166 ],[ _203 , _168 , _169 , _170 , _171 ]],[ _498 , _459 , _416 , _369 ],[ _164 , _203 , _166 ], _329 ) .
+ :- table(extendmove_4 / 2) .
+extendmove_4([ _164 , _165 , _166 , _201 ], _283 ) :- iff_1( _323 , _325 ) ,  _323  = [ _201 ] , iff_2( _362 , _364 ) ,  _362  = [ _230 , _165 ] , myis_2( _403 , _405 ) ,  _403  = [ _164 , _230 ] , compute([[ _164 , _230 ],[ _230 , _165 ],[ _201 ]],[ _405 , _364 , _325 ],[ _164 , _165 , _166 , _201 ], _283 ) .
+extendmove_4([ _164 , _165 , _166 , _167 ], _346 ) :- iff_2( _386 , _388 ) ,  _386  = [ _239 , _165 ] , myis_2( _427 , _429 ) ,  _427  = [ _164 , _239 ] , distributestones_4( _468 , _470 ) ,  _468  = [ _164 , _165 , _166 , _184 ] , move_2( _513 , _515 ) ,  _513  = [ _184 , _167 ] , compute([[ _184 , _167 ],[ _164 , _165 , _166 , _184 ],[ _164 , _239 ],[ _239 , _165 ]],[ _515 , _470 , _429 , _388 ],[ _164 , _165 , _166 , _167 ], _346 ) .
+ :- table(move_3 / 2) .
+move_3([ _207 , _165 , _166 ], _354 ) :- iff_3( _392 , _394 ) ,  _392  = [ _207 , _167 , _168 ] , stonesinhole_3( _435 , _437 ) ,  _435  = [ _167 , _165 , _175 ] , distributestones_4( _478 , _480 ) ,  _478  = [ _175 , _167 , _165 , _183 ] , move_3( _523 , _525 ) ,  _523  = [ _168 , _183 , _166 ] , compute([[ _168 , _183 , _166 ],[ _175 , _167 , _165 , _183 ],[ _167 , _165 , _175 ],[ _207 , _167 , _168 ]],[ _525 , _480 , _437 , _394 ],[ _207 , _165 , _166 ], _354 ) .
+move_3([ _189 , _165 , _166 ], _252 ) :- iff_1( _290 , _292 ) ,  _290  = [ _189 ] , swap_2( _329 , _331 ) ,  _329  = [ _165 , _166 ] , compute([[ _165 , _166 ],[ _189 ]],[ _331 , _292 ],[ _189 , _165 , _166 ], _252 ) .
+ :- table(distributestones_4 / 2) .
+distributestones_4([ _164 , _165 , _166 , _167 ], _298 ) :- distributemyholes_5( _338 , _340 ) ,  _338  = [ _164 , _165 , _166 , _175 , _176 ] , distributeyourholes_3( _385 , _387 ) ,  _385  = [ _176 , _175 , _167 ] , compute([[ _176 , _175 , _167 ],[ _164 , _165 , _166 , _175 , _176 ]],[ _387 , _340 ],[ _164 , _165 , _166 , _167 ], _298 ) .
+ :- table(distributemyholes_5 / 2) .
+distributemyholes_5([ _164 , _165 , _241 , _249 , _168 ], _515 ) :- iff_5( _557 , _559 ) ,  _557  = [ _241 , _170 , _171 , _172 , _173 ] , iff_5( _604 , _606 ) ,  _604  = [ _249 , _175 , _176 , _172 , _173 ] , iff_2( _651 , _653 ) ,  _651  = [ _282 , _165 ] , myis_2( _692 , _694 ) ,  _692  = [ _164 , _282 ] , pickupanddistribute_4( _733 , _735 ) ,  _733  = [ _165 , _164 , _170 , _175 ] , iff_2( _778 , _780 ) ,  _778  = [ _348 , _171 ] , myis_2( _819 , _821 ) ,  _819  = [ _176 , _348 ] , iff_3( _860 , _862 ) ,  _860  = [ _378 , _164 , _165 ] , myis_2( _903 , _905 ) ,  _903  = [ _168 , _378 ] , compute([[ _168 , _378 ],[ _378 , _164 , _165 ],[ _176 , _348 ],[ _348 , _171 ],[ _165 , _164 , _170 , _175 ],[ _164 , _282 ],[ _282 , _165 ],[ _249 , _175 , _176 , _172 , _173 ],[ _241 , _170 , _171 , _172 , _173 ]],[ _905 , _862 , _821 , _780 , _735 , _694 , _653 , _606 , _559 ],[ _164 , _165 , _241 , _249 , _168 ], _515 ) .
+distributemyholes_5([ _164 , _165 , _237 , _167 , _247 ], _501 ) :- iff_5( _543 , _545 ) ,  _543  = [ _237 , _170 , _171 , _172 , _173 ] , iff_1( _590 , _592 ) ,  _590  = [ _247 ] , pickupanddistribute_4( _629 , _631 ) ,  _629  = [ _165 , _164 , _170 , _181 ] , checkcapture_7( _674 , _676 ) ,  _674  = [ _165 , _164 , _181 , _189 , _172 , _191 , _192 ] , updatekalah_5( _725 , _727 ) ,  _725  = [ _192 , _165 , _164 , _171 , _201 ] , iff_5( _772 , _774 ) ,  _772  = [ _400 , _189 , _201 , _191 , _173 ] , checkiffinished_2( _819 , _821 ) ,  _819  = [ _400 , _167 ] , compute([[ _400 , _167 ],[ _400 , _189 , _201 , _191 , _173 ],[ _192 , _165 , _164 , _171 , _201 ],[ _165 , _164 , _181 , _189 , _172 , _191 , _192 ],[ _165 , _164 , _170 , _181 ],[ _247 ],[ _237 , _170 , _171 , _172 , _173 ]],[ _821 , _774 , _727 , _676 , _631 , _592 , _545 ],[ _164 , _165 , _237 , _167 , _247 ], _501 ) .
+ :- table(checkcapture_7 / 2) .
+checkcapture_7([ _164 , _165 , _166 , _167 , _168 , _169 , _170 ], _632 ) :- iff_3( _678 , _680 ) ,  _678  = [ _290 , _164 , _165 ] , myis_2( _721 , _723 ) ,  _721  = [ _175 , _290 ] , iff_2( _762 , _764 ) ,  _762  = [ _321 , _175 ] , myis_2( _803 , _805 ) ,  _803  = [ _184 , _321 ] , nthmember_3( _844 , _846 ) ,  _844  = [ _184 , _168 , _195 ] , iff_1( _887 , _889 ) ,  _887  = [ _382 ] , myis_2( _926 , _928 ) ,  _926  = [ _195 , _382 ] , iff_1( _967 , _969 ) ,  _967  = [ _419 ] , nsubstitute_4( _1006 , _1008 ) ,  _1006  = [ _184 , _166 , _419 , _167 ] , iff_1( _1051 , _1053 ) ,  _1051  = [ _460 ] , nsubstitute_4( _1090 , _1092 ) ,  _1090  = [ _175 , _168 , _460 , _169 ] , iff_2( _1135 , _1137 ) ,  _1135  = [ _494 , _195 ] , myis_2( _1176 , _1178 ) ,  _1176  = [ _170 , _494 ] , compute([[ _170 , _494 ],[ _494 , _195 ],[ _175 , _168 , _460 , _169 ],[ _460 ],[ _184 , _166 , _419 , _167 ],[ _419 ],[ _195 , _382 ],[ _382 ],[ _184 , _168 , _195 ],[ _184 , _321 ],[ _321 , _175 ],[ _175 , _290 ],[ _290 , _164 , _165 ]],[ _1178 , _1137 , _1092 , _1053 , _1008 , _969 , _928 , _889 , _846 , _805 , _764 , _723 , _680 ],[ _164 , _165 , _166 , _167 , _168 , _169 , _170 ], _632 ) .
+checkcapture_7([ _161 , _162 , _198 , _163 , _208 , _165 , _218 ], _267 ) :- iffequal_2( _313 , _315 ) ,  _313  = [ _198 , _163 ] , iffequal_2( _354 , _356 ) ,  _354  = [ _208 , _165 ] , iff_1( _395 , _397 ) ,  _395  = [ _218 ] , compute([[ _218 ],[ _208 , _165 ],[ _198 , _163 ]],[ _397 , _356 , _315 ],[ _161 , _162 , _198 , _163 , _208 , _165 , _218 ], _267 ) .
+ :- table(checkiffinished_2 / 2) .
+checkiffinished_2([ _210 , _218 ], _388 ) :- iff_5( _424 , _426 ) ,  _424  = [ _210 , _167 , _168 , _169 , _170 ] , iff_4( _471 , _473 ) ,  _471  = [ _218 , _167 , _168 , _175 ] , zero_1( _516 , _518 ) ,  _516  = [ _167 ] , sumlist_2( _555 , _557 ) ,  _555  = [ _169 , _186 ] , iff_3( _596 , _598 ) ,  _596  = [ _290 , _170 , _186 ] , myis_2( _639 , _641 ) ,  _639  = [ _175 , _290 ] , compute([[ _175 , _290 ],[ _290 , _170 , _186 ],[ _169 , _186 ],[ _167 ],[ _218 , _167 , _168 , _175 ],[ _210 , _167 , _168 , _169 , _170 ]],[ _641 , _598 , _557 , _518 , _473 , _426 ],[ _210 , _218 ], _388 ) .
+checkiffinished_2([ _210 , _218 ], _388 ) :- iff_5( _424 , _426 ) ,  _424  = [ _210 , _167 , _168 , _169 , _170 ] , iff_4( _471 , _473 ) ,  _471  = [ _218 , _169 , _173 , _170 ] , zero_1( _516 , _518 ) ,  _516  = [ _169 ] , sumlist_2( _555 , _557 ) ,  _555  = [ _167 , _186 ] , iff_3( _596 , _598 ) ,  _596  = [ _290 , _168 , _186 ] , myis_2( _639 , _641 ) ,  _639  = [ _173 , _290 ] , compute([[ _173 , _290 ],[ _290 , _168 , _186 ],[ _167 , _186 ],[ _169 ],[ _218 , _169 , _173 , _170 ],[ _210 , _167 , _168 , _169 , _170 ]],[ _641 , _598 , _557 , _518 , _473 , _426 ],[ _210 , _218 ], _388 ) .
+checkiffinished_2([ _179 , _161 ], _205 ) :- iffequal_2( _241 , _243 ) ,  _241  = [ _179 , _161 ] , compute([[ _179 , _161 ]],[ _243 ],[ _179 , _161 ], _205 ) .
+ :- table(updatekalah_5 / 2) .
+updatekalah_5([ _198 , _165 , _166 , _210 , _167 ], _302 ) :- iff_1( _344 , _346 ) ,  _344  = [ _198 ] , iffequal_2( _383 , _385 ) ,  _383  = [ _210 , _167 ] , iff_2( _424 , _426 ) ,  _424  = [ _242 , _166 ] , myis_2( _465 , _467 ) ,  _465  = [ _165 , _242 ] , compute([[ _165 , _242 ],[ _242 , _166 ],[ _210 , _167 ],[ _198 ]],[ _467 , _426 , _385 , _346 ],[ _198 , _165 , _166 , _210 , _167 ], _302 ) .
+updatekalah_5([ _207 , _165 , _166 , _167 , _168 ], _349 ) :- iff_1( _391 , _393 ) ,  _391  = [ _207 ] , iff_2( _430 , _432 ) ,  _430  = [ _246 , _166 ] , myis_2( _471 , _473 ) ,  _471  = [ _165 , _246 ] , iff_2( _512 , _514 ) ,  _512  = [ _276 , _167 ] , myis_2( _553 , _555 ) ,  _553  = [ _168 , _276 ] , compute([[ _168 , _276 ],[ _276 , _167 ],[ _165 , _246 ],[ _246 , _166 ],[ _207 ]],[ _555 , _514 , _473 , _432 , _393 ],[ _207 , _165 , _166 , _167 , _168 ], _349 ) .
+updatekalah_5([ _164 , _165 , _166 , _167 , _168 ], _327 ) :- iff_1( _369 , _371 ) ,  _369  = [ _237 ] , myis_2( _408 , _410 ) ,  _408  = [ _164 , _237 ] , iff_3( _449 , _451 ) ,  _449  = [ _267 , _167 , _164 ] , myis_2( _492 , _494 ) ,  _492  = [ _168 , _267 ] , compute([[ _168 , _267 ],[ _267 , _167 , _164 ],[ _164 , _237 ],[ _237 ]],[ _494 , _451 , _410 , _371 ],[ _164 , _165 , _166 , _167 , _168 ], _327 ) .
+ :- table(distributeyourholes_3 / 2) .
+distributeyourholes_3([ _182 , _190 , _162 ], _230 ) :- iff_1( _268 , _270 ) ,  _268  = [ _182 ] , iffequal_2( _307 , _309 ) ,  _307  = [ _190 , _162 ] , compute([[ _190 , _162 ],[ _182 ]],[ _309 , _270 ],[ _182 , _190 , _162 ], _230 ) .
+distributeyourholes_3([ _164 , _219 , _227 ], _448 ) :- iff_5( _486 , _488 ) ,  _486  = [ _219 , _168 , _169 , _170 , _171 ] , iff_5( _533 , _535 ) ,  _533  = [ _227 , _168 , _169 , _175 , _171 ] , iff_1( _580 , _582 ) ,  _580  = [ _254 ] , myis_2( _619 , _621 ) ,  _619  = [ _254 , _164 ] , iff_1( _660 , _662 ) ,  _660  = [ _287 ] , myis_2( _699 , _701 ) ,  _699  = [ _164 , _287 ] , nonzero_1( _740 , _742 ) ,  _740  = [ _168 ] , distribute_3( _779 , _781 ) ,  _779  = [ _164 , _170 , _175 ] , compute([[ _164 , _170 , _175 ],[ _168 ],[ _164 , _287 ],[ _287 ],[ _254 , _164 ],[ _254 ],[ _227 , _168 , _169 , _175 , _171 ],[ _219 , _168 , _169 , _170 , _171 ]],[ _781 , _742 , _701 , _662 , _621 , _582 , _535 , _488 ],[ _164 , _219 , _227 ], _448 ) .
+distributeyourholes_3([ _164 , _230 , _238 ], _546 ) :- iff_5( _584 , _586 ) ,  _584  = [ _230 , _168 , _169 , _170 , _171 ] , iff_5( _631 , _633 ) ,  _631  = [ _238 , _168 , _169 , _175 , _171 ] , iff_1( _678 , _680 ) ,  _678  = [ _267 ] , myis_2( _717 , _719 ) ,  _717  = [ _164 , _267 ] , iff_1( _758 , _760 ) ,  _758  = [ _298 ] , distribute_3( _797 , _799 ) ,  _797  = [ _298 , _170 , _175 ] , iff_2( _840 , _842 ) ,  _840  = [ _334 , _164 ] , myis_2( _881 , _883 ) ,  _881  = [ _194 , _334 ] , iff_1( _922 , _924 ) ,  _922  = [ _368 ] , iff_5( _961 , _963 ) ,  _961  = [ _376 , _168 , _169 , _175 , _171 ] , distributestones_4( _1008 , _1010 ) ,  _1008  = [ _194 , _368 , _376 , _203 ] , compute([[ _194 , _368 , _376 , _203 ],[ _376 , _168 , _169 , _175 , _171 ],[ _368 ],[ _194 , _334 ],[ _334 , _164 ],[ _298 , _170 , _175 ],[ _298 ],[ _164 , _267 ],[ _267 ],[ _238 , _168 , _169 , _175 , _171 ],[ _230 , _168 , _169 , _170 , _171 ]],[ _1010 , _963 , _924 , _883 , _842 , _799 , _760 , _719 , _680 , _633 , _586 ],[ _164 , _230 , _238 ], _546 ) .
+distributeyourholes_3([ _164 , _218 , _226 ], _400 ) :- iff_5( _438 , _440 ) ,  _438  = [ _218 , _168 , _169 , _170 , _171 ] , iff_4( _485 , _487 ) ,  _485  = [ _226 , _168 , _169 , _176 ] , zero_1( _530 , _532 ) ,  _530  = [ _168 ] , sumlist_2( _569 , _571 ) ,  _569  = [ _170 , _187 ] , iff_4( _610 , _612 ) ,  _610  = [ _299 , _164 , _187 , _171 ] , myis_2( _655 , _657 ) ,  _655  = [ _176 , _299 ] , compute([[ _176 , _299 ],[ _299 , _164 , _187 , _171 ],[ _170 , _187 ],[ _168 ],[ _226 , _168 , _169 , _176 ],[ _218 , _168 , _169 , _170 , _171 ]],[ _657 , _612 , _571 , _532 , _487 , _440 ],[ _164 , _218 , _226 ], _400 ) .
+ :- table(pickupanddistribute_4 / 2) .
+pickupanddistribute_4([ _197 , _165 , _207 , _215 ], _315 ) :- iff_1( _355 , _357 ) ,  _355  = [ _197 ] , iff_3( _394 , _396 ) ,  _394  = [ _207 , _168 , _169 ] , iff_2( _437 , _439 ) ,  _437  = [ _215 , _171 ] , distribute_3( _478 , _480 ) ,  _478  = [ _165 , _169 , _171 ] , compute([[ _165 , _169 , _171 ],[ _215 , _171 ],[ _207 , _168 , _169 ],[ _197 ]],[ _480 , _439 , _396 , _357 ],[ _197 , _165 , _207 , _215 ], _315 ) .
+pickupanddistribute_4([ _164 , _165 , _217 , _225 ], _416 ) :- iff_3( _456 , _458 ) ,  _456  = [ _217 , _168 , _169 ] , iff_2( _499 , _501 ) ,  _499  = [ _225 , _171 ] , iff_1( _540 , _542 ) ,  _540  = [ _255 ] , myis_2( _579 , _581 ) ,  _579  = [ _164 , _255 ] , iff_2( _620 , _622 ) ,  _620  = [ _286 , _164 ] , myis_2( _661 , _663 ) ,  _661  = [ _182 , _286 ] , pickupanddistribute_4( _702 , _704 ) ,  _702  = [ _182 , _165 , _169 , _171 ] , compute([[ _182 , _165 , _169 , _171 ],[ _182 , _286 ],[ _286 , _164 ],[ _164 , _255 ],[ _255 ],[ _225 , _171 ],[ _217 , _168 , _169 ]],[ _704 , _663 , _622 , _581 , _542 , _501 , _458 ],[ _164 , _165 , _217 , _225 ], _416 ) .
+ :- table(distribute_3 / 2) .
+distribute_3([ _182 , _190 , _162 ], _230 ) :- iff_1( _268 , _270 ) ,  _268  = [ _182 ] , iffequal_2( _307 , _309 ) ,  _307  = [ _190 , _162 ] , compute([[ _190 , _162 ],[ _182 ]],[ _309 , _270 ],[ _182 , _190 , _162 ], _230 ) .
+distribute_3([ _164 , _220 , _228 ], _467 ) :- iff_3( _505 , _507 ) ,  _505  = [ _220 , _167 , _168 ] , iff_3( _548 , _550 ) ,  _548  = [ _228 , _169 , _170 ] , iff_1( _591 , _593 ) ,  _591  = [ _257 ] , myis_2( _630 , _632 ) ,  _630  = [ _164 , _257 ] , iff_2( _671 , _673 ) ,  _671  = [ _288 , _164 ] , myis_2( _712 , _714 ) ,  _712  = [ _181 , _288 ] , iff_2( _753 , _755 ) ,  _753  = [ _319 , _167 ] , myis_2( _794 , _796 ) ,  _794  = [ _169 , _319 ] , distribute_3( _835 , _837 ) ,  _835  = [ _181 , _168 , _170 ] , compute([[ _181 , _168 , _170 ],[ _169 , _319 ],[ _319 , _167 ],[ _181 , _288 ],[ _288 , _164 ],[ _164 , _257 ],[ _257 ],[ _228 , _169 , _170 ],[ _220 , _167 , _168 ]],[ _837 , _796 , _755 , _714 , _673 , _632 , _593 , _550 , _507 ],[ _164 , _220 , _228 ], _467 ) .
+distribute_3([ _161 , _184 , _192 ], _236 ) :- iff_1( _274 , _276 ) ,  _274  = [ _184 ] , iff_1( _313 , _315 ) ,  _313  = [ _192 ] , compute([[ _192 ],[ _184 ]],[ _315 , _276 ],[ _161 , _184 , _192 ], _236 ) .
+ :- table(value_2 / 2) .
+value_2([ _194 , _165 ], _291 ) :- iff_5( _327 , _329 ) ,  _327  = [ _194 , _167 , _168 , _169 , _170 ] , iff_3( _374 , _376 ) ,  _374  = [ _223 , _168 , _170 ] , myis_2( _417 , _419 ) ,  _417  = [ _165 , _223 ] , compute([[ _165 , _223 ],[ _223 , _168 , _170 ],[ _194 , _167 , _168 , _169 , _170 ]],[ _419 , _376 , _329 ],[ _194 , _165 ], _291 ) .
+ :- table(gameover_3 / 2) .
+gameover_3([ _202 , _165 , _212 ], _333 ) :- iff_2( _371 , _373 ) ,  _371  = [ _202 , _169 ] , iff_1( _412 , _414 ) ,  _412  = [ _212 ] , pieces_1( _451 , _453 ) ,  _451  = [ _176 ] , iff_2( _490 , _492 ) ,  _490  = [ _260 , _176 ] , myis_2( _531 , _533 ) ,  _531  = [ _169 , _260 ] , compute([[ _169 , _260 ],[ _260 , _176 ],[ _176 ],[ _212 ],[ _202 , _169 ]],[ _533 , _492 , _453 , _414 , _373 ],[ _202 , _165 , _212 ], _333 ) .
+gameover_3([ _202 , _210 , _165 ], _336 ) :- iff_5( _374 , _376 ) ,  _374  = [ _202 , _168 , _169 , _170 , _171 ] , iffequal_2( _421 , _423 ) ,  _421  = [ _210 , _165 ] , pieces_1( _462 , _464 ) ,  _462  = [ _176 ] , iff_2( _501 , _503 ) ,  _501  = [ _260 , _176 ] , myis_2( _542 , _544 ) ,  _542  = [ _169 , _260 ] , compute([[ _169 , _260 ],[ _260 , _176 ],[ _176 ],[ _210 , _165 ],[ _202 , _168 , _169 , _170 , _171 ]],[ _544 , _503 , _464 , _423 , _376 ],[ _202 , _210 , _165 ], _336 ) .
+gameover_3([ _208 , _165 , _166 ], _358 ) :- iff_5( _396 , _398 ) ,  _396  = [ _208 , _168 , _169 , _170 , _171 ] , pieces_1( _443 , _445 ) ,  _443  = [ _176 ] , iff_2( _482 , _484 ) ,  _482  = [ _261 , _176 ] , myis_2( _523 , _525 ) ,  _523  = [ _171 , _261 ] , nextplayer_2( _564 , _566 ) ,  _564  = [ _165 , _166 ] , compute([[ _165 , _166 ],[ _171 , _261 ],[ _261 , _176 ],[ _176 ],[ _208 , _168 , _169 , _170 , _171 ]],[ _566 , _525 , _484 , _445 , _398 ],[ _208 , _165 , _166 ], _358 ) .
+ :- table(announce_1 / 2) .
+announce_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+announce_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+announce_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+ :- table(nthmember_3 / 2) .
+nthmember_3([ _164 , _209 , _166 ], _380 ) :- iff_3( _418 , _420 ) ,  _418  = [ _209 , _167 , _168 ] , iff_1( _461 , _463 ) ,  _461  = [ _240 ] , myis_2( _500 , _502 ) ,  _500  = [ _164 , _240 ] , iff_2( _541 , _543 ) ,  _541  = [ _271 , _164 ] , myis_2( _582 , _584 ) ,  _582  = [ _179 , _271 ] , nthmember_3( _623 , _625 ) ,  _623  = [ _179 , _168 , _166 ] , compute([[ _179 , _168 , _166 ],[ _179 , _271 ],[ _271 , _164 ],[ _164 , _240 ],[ _240 ],[ _209 , _167 , _168 ]],[ _625 , _584 , _543 , _502 , _463 , _420 ],[ _164 , _209 , _166 ], _380 ) .
+nthmember_3([ _184 , _192 , _164 ], _244 ) :- iff_1( _282 , _284 ) ,  _282  = [ _184 ] , iff_3( _321 , _323 ) ,  _321  = [ _192 , _164 , _165 ] , compute([[ _192 , _164 , _165 ],[ _184 ]],[ _323 , _284 ],[ _184 , _192 , _164 ], _244 ) .
+ :- table(nsubstitute_4 / 2) .
+nsubstitute_4([ _189 , _197 , _163 , _207 ], _277 ) :- iff_1( _317 , _319 ) ,  _317  = [ _189 ] , iff_3( _356 , _358 ) ,  _356  = [ _197 , _165 , _166 ] , iff_3( _399 , _401 ) ,  _399  = [ _207 , _163 , _166 ] , compute([[ _207 , _163 , _166 ],[ _197 , _165 , _166 ],[ _189 ]],[ _401 , _358 , _319 ],[ _189 , _197 , _163 , _207 ], _277 ) .
+nsubstitute_4([ _164 , _215 , _166 , _225 ], _419 ) :- iff_3( _459 , _461 ) ,  _459  = [ _215 , _168 , _169 ] , iff_3( _502 , _504 ) ,  _502  = [ _225 , _168 , _171 ] , iff_1( _545 , _547 ) ,  _545  = [ _255 ] , myis_2( _584 , _586 ) ,  _584  = [ _164 , _255 ] , iff_2( _625 , _627 ) ,  _625  = [ _286 , _164 ] , myis_2( _666 , _668 ) ,  _666  = [ _182 , _286 ] , nsubstitute_4( _707 , _709 ) ,  _707  = [ _182 , _169 , _166 , _171 ] , compute([[ _182 , _169 , _166 , _171 ],[ _182 , _286 ],[ _286 , _164 ],[ _164 , _255 ],[ _255 ],[ _225 , _168 , _171 ],[ _215 , _168 , _169 ]],[ _709 , _668 , _627 , _586 , _547 , _504 , _461 ],[ _164 , _215 , _166 , _225 ], _419 ) .
+ :- table(nextplayer_2 / 2) .
+nextplayer_2([ _179 , _187 ], _230 ) :- iff_1( _266 , _268 ) ,  _266  = [ _179 ] , iff_1( _305 , _307 ) ,  _305  = [ _187 ] , compute([[ _187 ],[ _179 ]],[ _307 , _268 ],[ _179 , _187 ], _230 ) .
+nextplayer_2([ _179 , _187 ], _230 ) :- iff_1( _266 , _268 ) ,  _266  = [ _179 ] , iff_1( _305 , _307 ) ,  _305  = [ _187 ] , compute([[ _187 ],[ _179 ]],[ _307 , _268 ],[ _179 , _187 ], _230 ) .
+ :- table(legal_1 / 2) .
+legal_1([ _196 ], _350 ) :- iff_3( _384 , _386 ) ,  _384  = [ _196 , _165 , _166 ] , iff_1( _427 , _429 ) ,  _427  = [ _221 ] , myis_2( _466 , _468 ) ,  _466  = [ _221 , _165 ] , iff_1( _507 , _509 ) ,  _507  = [ _254 ] , myis_2( _546 , _548 ) ,  _546  = [ _165 , _254 ] , legal_1( _587 , _589 ) ,  _587  = [ _166 ] , compute([[ _166 ],[ _165 , _254 ],[ _254 ],[ _221 , _165 ],[ _221 ],[ _196 , _165 , _166 ]],[ _589 , _548 , _509 , _468 , _429 , _386 ],[ _196 ], _350 ) .
+legal_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+ :- table(genlegal_1 / 2) .
+genlegal_1([ _202 ], _308 ) :- iff_3( _342 , _344 ) ,  _342  = [ _202 , _165 , _166 ] , iff_1( _385 , _387 ) ,  _385  = [ _229 ] , member_2( _424 , _426 ) ,  _424  = [ _165 , _229 ] , genlegal_1( _465 , _467 ) ,  _465  = [ _166 ] , compute([[ _166 ],[ _165 , _229 ],[ _229 ],[ _202 , _165 , _166 ]],[ _467 , _426 , _387 , _344 ],[ _202 ], _308 ) .
+genlegal_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+ :- table(swap_2 / 2) .
+swap_2([ _189 , _197 ], _264 ) :- iff_5( _300 , _302 ) ,  _300  = [ _189 , _164 , _165 , _166 , _167 ] , iff_5( _347 , _349 ) ,  _347  = [ _197 , _166 , _167 , _164 , _165 ] , compute([[ _197 , _166 , _167 , _164 , _165 ],[ _189 , _164 , _165 , _166 , _167 ]],[ _349 , _302 ],[ _189 , _197 ], _264 ) .
+ :- table(displaygame_2 / 2) .
+displaygame_2([ _164 , _187 ], _240 ) :- iff_1( _276 , _278 ) ,  _276  = [ _187 ] , show_1( _315 , _317 ) ,  _315  = [ _164 ] , compute([[ _164 ],[ _187 ]],[ _317 , _278 ],[ _164 , _187 ], _240 ) .
+displaygame_2([ _164 , _193 ], _275 ) :- iff_1( _311 , _313 ) ,  _311  = [ _193 ] , swap_2( _350 , _352 ) ,  _350  = [ _164 , _171 ] , show_1( _391 , _393 ) ,  _391  = [ _171 ] , compute([[ _171 ],[ _164 , _171 ],[ _193 ]],[ _393 , _352 , _313 ],[ _164 , _193 ], _275 ) .
+ :- table(show_1 / 2) .
+show_1([ _204 ], _350 ) :- iff_5( _384 , _386 ) ,  _384  = [ _204 , _166 , _167 , _168 , _169 ] , reverse_2( _431 , _433 ) ,  _431  = [ _166 , _175 ] , writestones_1( _472 , _474 ) ,  _472  = [ _175 ] , writekalahs_2( _511 , _513 ) ,  _511  = [ _167 , _169 ] , writestones_1( _552 , _554 ) ,  _552  = [ _168 ] , compute([[ _168 ],[ _167 , _169 ],[ _175 ],[ _166 , _175 ],[ _204 , _166 , _167 , _168 , _169 ]],[ _554 , _513 , _474 , _433 , _386 ],[ _204 ], _350 ) .
+ :- table(writestones_1 / 2) .
+writestones_1([ _164 ], _215 ) :- displayholes_1( _249 , _251 ) ,  _249  = [ _164 ] , compute([[ _164 ]],[ _251 ],[ _164 ], _215 ) .
+ :- table(displayholes_1 / 2) .
+displayholes_1([ _189 ], _271 ) :- iff_3( _305 , _307 ) ,  _305  = [ _189 , _165 , _166 ] , writepile_1( _348 , _350 ) ,  _348  = [ _165 ] , displayholes_1( _387 , _389 ) ,  _387  = [ _166 ] , compute([[ _166 ],[ _165 ],[ _189 , _165 , _166 ]],[ _389 , _350 , _307 ],[ _189 ], _271 ) .
+displayholes_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+ :- table(writepile_1 / 2) .
+writepile_1([ _164 ], _269 ) :- iff_1( _303 , _305 ) ,  _303  = [ _209 ] , myis_2( _342 , _344 ) ,  _342  = [ _164 , _209 ] , wr_1( _383 , _385 ) ,  _383  = [ _164 ] , compute([[ _164 ],[ _164 , _209 ],[ _209 ]],[ _385 , _344 , _305 ],[ _164 ], _269 ) .
+writepile_1([ _164 ], _269 ) :- iff_1( _303 , _305 ) ,  _303  = [ _209 ] , myis_2( _342 , _344 ) ,  _342  = [ _164 , _209 ] , wr_1( _383 , _385 ) ,  _383  = [ _164 ] , compute([[ _164 ],[ _164 , _209 ],[ _209 ]],[ _385 , _344 , _305 ],[ _164 ], _269 ) .
+ :- table(writekalahs_2 / 2) .
+writekalahs_2([ _164 , _165 ], _250 ) :- wr_1( _286 , _288 ) ,  _286  = [ _164 ] , wr_1( _325 , _327 ) ,  _325  = [ _165 ] , compute([[ _165 ],[ _164 ]],[ _327 , _288 ],[ _164 , _165 ], _250 ) .
+ :- table(zero_1 / 2) .
+zero_1([ _188 ], _217 ) :- iff_1( _251 , _253 ) ,  _251  = [ _188 ] , compute([[ _188 ]],[ _253 ],[ _188 ], _217 ) .
+ :- table(nonzero_1 / 2) .
+nonzero_1([ _164 ], _252 ) :- iff_1( _286 , _288 ) ,  _286  = [ _215 ] , myis_2( _325 , _327 ) ,  _325  = [ _164 , _215 ] , compute([[ _164 , _215 ],[ _215 ]],[ _327 , _288 ],[ _164 ], _252 ) .
+ :- table(reverse_2 / 2) .
+reverse_2([ _164 , _165 ], _252 ) :- iff_1( _288 , _290 ) ,  _288  = [ _212 ] , rev_3( _327 , _329 ) ,  _327  = [ _164 , _212 , _165 ] , compute([[ _164 , _212 , _165 ],[ _212 ]],[ _329 , _290 ],[ _164 , _165 ], _252 ) .
+ :- table(rev_3 / 2) .
+rev_3([ _182 , _190 , _162 ], _230 ) :- iff_1( _268 , _270 ) ,  _268  = [ _182 ] , iffequal_2( _307 , _309 ) ,  _307  = [ _190 , _162 ] , compute([[ _190 , _162 ],[ _182 ]],[ _309 , _270 ],[ _182 , _190 , _162 ], _230 ) .
+rev_3([ _194 , _165 , _166 ], _293 ) :- iff_3( _331 , _333 ) ,  _331  = [ _194 , _167 , _168 ] , iff_3( _374 , _376 ) ,  _374  = [ _228 , _167 , _165 ] , rev_3( _417 , _419 ) ,  _417  = [ _168 , _228 , _166 ] , compute([[ _168 , _228 , _166 ],[ _228 , _167 , _165 ],[ _194 , _167 , _168 ]],[ _419 , _376 , _333 ],[ _194 , _165 , _166 ], _293 ) .
+ :- table(sumlist_2 / 2) .
+sumlist_2([ _164 , _165 ], _252 ) :- iff_1( _288 , _290 ) ,  _288  = [ _212 ] , sumlist_3( _327 , _329 ) ,  _327  = [ _164 , _212 , _165 ] , compute([[ _164 , _212 , _165 ],[ _212 ]],[ _329 , _290 ],[ _164 , _165 ], _252 ) .
+ :- table(sumlist_3 / 2) .
+sumlist_3([ _182 , _190 , _162 ], _230 ) :- iff_1( _268 , _270 ) ,  _268  = [ _182 ] , iffequal_2( _307 , _309 ) ,  _307  = [ _190 , _162 ] , compute([[ _190 , _162 ],[ _182 ]],[ _309 , _270 ],[ _182 , _190 , _162 ], _230 ) .
+sumlist_3([ _201 , _165 , _166 ], _326 ) :- iff_3( _364 , _366 ) ,  _364  = [ _201 , _167 , _168 ] , iff_2( _407 , _409 ) ,  _407  = [ _234 , _165 ] , myis_2( _448 , _450 ) ,  _448  = [ _173 , _234 ] , sumlist_3( _489 , _491 ) ,  _489  = [ _168 , _173 , _166 ] , compute([[ _168 , _173 , _166 ],[ _173 , _234 ],[ _234 , _165 ],[ _201 , _167 , _168 ]],[ _491 , _450 , _409 , _366 ],[ _201 , _165 , _166 ], _326 ) .
+ :- table(lookahead_1 / 2) .
+lookahead_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+lookahead_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+ :- table(initialize_3 / 2) .
+initialize_3([ _187 , _195 , _203 ], _260 ) :- iff_1( _298 , _300 ) ,  _298  = [ _187 ] , iff_1( _337 , _339 ) ,  _337  = [ _195 ] , iff_1( _376 , _378 ) ,  _376  = [ _203 ] , compute([[ _203 ],[ _195 ],[ _187 ]],[ _378 , _339 , _300 ],[ _187 , _195 , _203 ], _260 ) .
+initialize_3([ _187 , _195 , _203 ], _260 ) :- iff_1( _298 , _300 ) ,  _298  = [ _187 ] , iff_1( _337 , _339 ) ,  _337  = [ _195 ] , iff_1( _376 , _378 ) ,  _376  = [ _203 ] , compute([[ _203 ],[ _195 ],[ _187 ]],[ _378 , _339 , _300 ],[ _187 , _195 , _203 ], _260 ) .
+ :- table(pieces_1 / 2) .
+pieces_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+pieces_1([ _176 ], _205 ) :- iff_1( _239 , _241 ) ,  _239  = [ _176 ] , compute([[ _176 ]],[ _241 ],[ _176 ], _205 ) .
+ :- table(myis_2 / 2) .
+myis_2([ _179 , _187 ], _230 ) :- iff_1( _266 , _268 ) ,  _266  = [ _179 ] , iff_1( _305 , _307 ) ,  _305  = [ _187 ] , compute([[ _187 ],[ _179 ]],[ _307 , _268 ],[ _179 , _187 ], _230 ) .
+ :- table(wr_1 / 2) .
+wr_1([ _161 ], _186 ) :- compute([],[],[ _161 ], _186 ) .
+exec :- wr_1( _163 , _164 ) .
+exec :- myis_2( _163 , _164 ) .
+exec :- pieces_1( _163 , _164 ) .
+exec :- initialize_3( _163 , _164 ) .
+exec :- lookahead_1( _163 , _164 ) .
+exec :- sumlist_3( _163 , _164 ) .
+exec :- sumlist_2( _163 , _164 ) .
+exec :- rev_3( _163 , _164 ) .
+exec :- reverse_2( _163 , _164 ) .
+exec :- nonzero_1( _163 , _164 ) .
+exec :- zero_1( _163 , _164 ) .
+exec :- writekalahs_2( _163 , _164 ) .
+exec :- writepile_1( _163 , _164 ) .
+exec :- displayholes_1( _163 , _164 ) .
+exec :- writestones_1( _163 , _164 ) .
+exec :- show_1( _163 , _164 ) .
+exec :- swap_2( _163 , _164 ) .
+exec :- displaygame_2( _163 , _164 ) .
+exec :- member_2( _163 , _164 ) .
+exec :- genlegal_1( _163 , _164 ) .
+exec :- legal_1( _163 , _164 ) .
+exec :- nextplayer_2( _163 , _164 ) .
+exec :- nsubstitute_4( _163 , _164 ) .
+exec :- nthmember_3( _163 , _164 ) .
+exec :- announce_1( _163 , _164 ) .
+exec :- gameover_3( _163 , _164 ) .
+exec :- value_2( _163 , _164 ) .
+exec :- distribute_3( _163 , _164 ) .
+exec :- pickupanddistribute_4( _163 , _164 ) .
+exec :- checkiffinished_2( _163 , _164 ) .
+exec :- updatekalah_5( _163 , _164 ) .
+exec :- checkcapture_7( _163 , _164 ) .
+exec :- distributemyholes_5( _163 , _164 ) .
+exec :- distributeyourholes_3( _163 , _164 ) .
+exec :- distributestones_4( _163 , _164 ) .
+exec :- stonesinhole_3( _163 , _164 ) .
+exec :- move_3( _163 , _164 ) .
+exec :- extendmove_4( _163 , _164 ) .
+exec :- move_2( _163 , _164 ) .
+exec :- allmoves_2( _163 , _164 ) .
+exec :- cutoff_9( _163 , _164 ) .
+exec :- evaluateandchoose_7( _163 , _164 ) .
+exec :- alphabeta_6( _163 , _164 ) .
+exec :- choosemove_3( _163 , _164 ) .
+exec :- play_3( _163 , _164 ) .
+exec :- play_2( _163 , _164 ) .
+
+
+show :- wr_1( _163 , _164 ) , write(wr_1( _163 , _164 )) , nl , fail .
+show :- myis_2( _163 , _164 ) , write(myis_2( _163 , _164 )) , nl , fail .
+show :- pieces_1( _163 , _164 ) , write(pieces_1( _163 , _164 )) , nl , fail .
+show :- initialize_3( _163 , _164 ) , write(initialize_3( _163 , _164 )) , nl , fail .
+show :- lookahead_1( _163 , _164 ) , write(lookahead_1( _163 , _164 )) , nl , fail .
+show :- sumlist_3( _163 , _164 ) , write(sumlist_3( _163 , _164 )) , nl , fail .
+show :- sumlist_2( _163 , _164 ) , write(sumlist_2( _163 , _164 )) , nl , fail .
+show :- rev_3( _163 , _164 ) , write(rev_3( _163 , _164 )) , nl , fail .
+show :- reverse_2( _163 , _164 ) , write(reverse_2( _163 , _164 )) , nl , fail .
+show :- nonzero_1( _163 , _164 ) , write(nonzero_1( _163 , _164 )) , nl , fail .
+show :- zero_1( _163 , _164 ) , write(zero_1( _163 , _164 )) , nl , fail .
+show :- writekalahs_2( _163 , _164 ) , write(writekalahs_2( _163 , _164 )) , nl , fail .
+show :- writepile_1( _163 , _164 ) , write(writepile_1( _163 , _164 )) , nl , fail .
+show :- displayholes_1( _163 , _164 ) , write(displayholes_1( _163 , _164 )) , nl , fail .
+show :- writestones_1( _163 , _164 ) , write(writestones_1( _163 , _164 )) , nl , fail .
+show :- show_1( _163 , _164 ) , write(show_1( _163 , _164 )) , nl , fail .
+show :- displaygame_2( _163 , _164 ) , write(displaygame_2( _163 , _164 )) , nl , fail .
+show :- swap_2( _163 , _164 ) , write(swap_2( _163 , _164 )) , nl , fail .
+show :- genlegal_1( _163 , _164 ) , write(genlegal_1( _163 , _164 )) , nl , fail .
+show :- legal_1( _163 , _164 ) , write(legal_1( _163 , _164 )) , nl , fail .
+show :- nextplayer_2( _163 , _164 ) , write(nextplayer_2( _163 , _164 )) , nl , fail .
+show :- nsubstitute_4( _163 , _164 ) , write(nsubstitute_4( _163 , _164 )) , nl , fail .
+show :- nthmember_3( _163 , _164 ) , write(nthmember_3( _163 , _164 )) , nl , fail .
+show :- announce_1( _163 , _164 ) , write(announce_1( _163 , _164 )) , nl , fail .
+show :- gameover_3( _163 , _164 ) , write(gameover_3( _163 , _164 )) , nl , fail .
+show :- value_2( _163 , _164 ) , write(value_2( _163 , _164 )) , nl , fail .
+show :- distribute_3( _163 , _164 ) , write(distribute_3( _163 , _164 )) , nl , fail .
+show :- pickupanddistribute_4( _163 , _164 ) , write(pickupanddistribute_4( _163 , _164 )) , nl , fail .
+show :- distributeyourholes_3( _163 , _164 ) , write(distributeyourholes_3( _163 , _164 )) , nl , fail .
+show :- updatekalah_5( _163 , _164 ) , write(updatekalah_5( _163 , _164 )) , nl , fail .
+show :- checkiffinished_2( _163 , _164 ) , write(checkiffinished_2( _163 , _164 )) , nl , fail .
+show :- checkcapture_7( _163 , _164 ) , write(checkcapture_7( _163 , _164 )) , nl , fail .
+show :- distributemyholes_5( _163 , _164 ) , write(distributemyholes_5( _163 , _164 )) , nl , fail .
+show :- distributestones_4( _163 , _164 ) , write(distributestones_4( _163 , _164 )) , nl , fail .
+show :- move_3( _163 , _164 ) , write(move_3( _163 , _164 )) , nl , fail .
+show :- extendmove_4( _163 , _164 ) , write(extendmove_4( _163 , _164 )) , nl , fail .
+show :- stonesinhole_3( _163 , _164 ) , write(stonesinhole_3( _163 , _164 )) , nl , fail .
+show :- member_2( _163 , _164 ) , write(member_2( _163 , _164 )) , nl , fail .
+show :- move_2( _163 , _164 ) , write(move_2( _163 , _164 )) , nl , fail .
+show :- cutoff_9( _163 , _164 ) , write(cutoff_9( _163 , _164 )) , nl , fail .
+show :- evaluateandchoose_7( _163 , _164 ) , write(evaluateandchoose_7( _163 , _164 )) , nl , fail .
+show :- allmoves_2( _163 , _164 ) , write(allmoves_2( _163 , _164 )) , nl , fail .
+show :- alphabeta_6( _163 , _164 ) , write(alphabeta_6( _163 , _164 )) , nl , fail .
+show :- choosemove_3( _163 , _164 ) , write(choosemove_3( _163 , _164 )) , nl , fail .
+show :- play_3( _163 , _164 ) , write(play_3( _163 , _164 )) , nl , fail .
+show :- play_2( _163 , _164 ) , write(play_2( _163 , _164 )) , nl , fail .
diff --git a/src/Tests/xsb/table_tests/test_calldepth.P b/src/Tests/xsb/table_tests/test_calldepth.P
new file mode 100644
index 0000000..588f5dc
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_calldepth.P
@@ -0,0 +1,30 @@
+
+:- import xsb_error_get_tag/2 from error_handler.
+
+%test:-
+%	test_fail,write('fail succeeded!').
+test:-
+     catch(test_error,E,
+           ( xsb_error_get_tag(E,T),
+             numbervars(T, 0, _, [singletons(true)]),
+             format('~p~n', [error(T)])
+           )).
+
+%test_fail:-
+%	abolish_all_tables,
+%	set_prolog_flag(max_table_subgoal_size,4),
+%	set_prolog_flag(max_table_subgoal_size_action,failure),
+%	p(_X).
+
+test_error:-
+	abolish_all_tables,
+	set_prolog_flag(max_table_subgoal_size,4),
+	set_prolog_flag(max_table_subgoal_size_action,error),
+	p(_X).
+
+:- table p/1.
+p(X):- p(f(X)).
+
+
+
+
diff --git a/src/Tests/xsb/table_tests/test_calldepth_old b/src/Tests/xsb/table_tests/test_calldepth_old
new file mode 100644
index 0000000..ab48480
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_calldepth_old
@@ -0,0 +1 @@
+error(resource_error(tripwire(max_table_subgoal_size,xsb_test_calldepth:p(_))))
diff --git a/src/Tests/xsb/table_tests/test_cyclic_tabling.P b/src/Tests/xsb/table_tests/test_cyclic_tabling.P
new file mode 100644
index 0000000..5efce81
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_cyclic_tabling.P
@@ -0,0 +1,39 @@
+:- import close_open_tables/1 from machine.
+
+:- set_prolog_flag(max_table_answer_size,25).
+:- set_prolog_flag(max_table_subgoal_size,25).
+:- set_prolog_flag(max_table_subgoal_size_action,error).
+
+:- table p/1.
+p(X):- X = f(X).
+
+:- table r/1.
+r(X):- make_term(100,X).
+
+make_term(0,0):-!.
+make_term(N,f(X)):-
+	N1 is N - 1,
+	make_term(N1,X).
+
+test:- set_prolog_flag(unify_with_occurs_check,off),fail.
+test:- catch(r(_X),error(_Type,context(_Msg,_)),writeln(caught_r)),fail.
+test:- catch(p(_X),error(_Type,context(_Msg,_)),writeln(caught_p)),fail.
+test:- X = f(X),catch(s(X),error(_Type,context(_Msg,_)),writeln(caught_s_1)),fail.
+test:- make_term(100,X),catch(s(X),error(_Type,context(_Msg,_)),writeln(caught_s_2)),fail.
+test:- close_open_tables(non_memory_error),fail.
+test:- abolish_all_tables,fail.
+test:- test_uwoc, fail.
+test:- set_prolog_flag(unify_with_occurs_check,off),
+       set_prolog_flag(max_table_answer_size,infinite),
+       set_prolog_flag(max_table_subgoal_size,infinite),
+       fail.
+test.
+
+test_uwoc:- set_prolog_flag(unify_with_occurs_check,on),fail.
+test_uwoc:- catch(r(_X),error(_Type,context(_Msg,_)),writeln(uwoc_caught_r)),fail.
+test_uwoc:- catch(p(_X),error(_Type,context(_Msg,_)),writeln(uwoc_caught_p)),fail.
+test_uwoc:- X = f(X),catch(s(X),error(_Type,context(_Msg,_)),writeln(uwoc_caught_s_1)),fail.
+test_uwoc:- make_term(100,X),catch(s(X),error(_Type,context(_Msg,_)),writeln(uwoc_caught_s_2)),fail.
+
+:- table s/1.
+s(_).
diff --git a/src/Tests/xsb/table_tests/test_cyclic_tabling_old b/src/Tests/xsb/table_tests/test_cyclic_tabling_old
new file mode 100644
index 0000000..1d4055b
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_cyclic_tabling_old
@@ -0,0 +1,6 @@
+caught_p
+caught_r
+caught_s_1
+caught_s_2
+uwoc_caught_r
+uwoc_caught_s_2
diff --git a/src/Tests/xsb/table_tests/test_large_tabled_terms.P b/src/Tests/xsb/table_tests/test_large_tabled_terms.P
new file mode 100644
index 0000000..a6c4a74
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_large_tabled_terms.P
@@ -0,0 +1,92 @@
+
+/* Test of handling large subgoals and answers */
+
+test:- test_large_ground_subgoal,writeln(test_large_ground_subgoal),fail.
+test:- test_large_ground_answer,writeln(test_large_ground_answer),fail.
+test:- test_subgoal_abstraction(50000,_L),writeln(test_subgoal_abstraction),fail.
+test:- test_answer_abstraction(50000,_L),writeln(test_answer_abstraction),fail.
+test:- test_subgoal_answer_abstraction(50000,_L,_M),writeln(test_subgoal_answer_abstraction),fail.
+test:- catch(test_var_limit(1900,_L2),_E,writeln(subgoal_var_limit_one_caught)),fail. %new
+test:- catch(test_var_limit(100000,_L2),_E,writeln(subgoal_var_limit_two_tested)),fail.
+test:- catch(a_var(100000,_L2),_E,writeln(answer_var_limit_tested)),fail.
+test.
+
+%---------
+
+test_large_ground_subgoal:- makelist(50000,X),s(X).
+:-table s/1.
+s(_X).
+
+%---------
+
+test_large_ground_answer:- a(50000,_X).
+:- table a/2.
+a(N,X):- makelist(N,X).
+
+%---------
+
+:-table sa/1 as subgoal_abstract(10).
+sa(_X).
+
+test_subgoal_abstraction(N,L):-
+   abolish_all_tables,
+   set_prolog_flag(max_table_subgoal_size_action,abstract),
+   makelist(N,L),
+   sa(L).
+
+:- table r/2.
+r(N,L):- makelist(N,L).
+
+%---------
+
+test_answer_abstraction(N,L):-
+   abolish_all_tables,
+   set_prolog_flag(max_table_answer_size,10),
+   set_prolog_flag(max_table_answer_size_action,bounded_rationality),
+   r(N,L).
+
+%---------
+
+:- table b/3 as subgoal_abstract(10).
+b(N,_L,M):- makelist(N,M).
+
+test_subgoal_answer_abstraction(N,L,M):-
+   abolish_all_tables,
+   set_prolog_flag(max_table_subgoal_size_action,abstract),
+   set_prolog_flag(max_table_answer_size,10),
+   set_prolog_flag(max_table_answer_size_action,bounded_rationality),
+   makelist(N,L),
+   b(N,L,M).
+
+test_var_limit(N):-
+    set_prolog_flag(max_table_subgoal_var_num,N),
+    set_prolog_flag(max_table_answer_var_num,N),
+    test_var_limit(N,_L2).
+
+test_var_limit(N,L2):-
+   set_prolog_flag(max_table_subgoal_size,10000000),
+   set_prolog_flag(max_table_answer_size,10000000),
+   abolish_all_tables,
+   makevarlist(N,L1),
+   s(L1),
+   makevarlist(N,L2),
+   s(L2),
+   L1 = L2,
+   writeln(test_var_limit_1_succeeded).
+
+%---------
+
+test_large_nonground_answer:- a(50000,_X).
+:- table a_var/2.
+a_var(N,X):-
+   makevarlist(N,X),
+   writeln(test_a_var_succeeded).
+
+%---------
+
+makelist(0,[]):- !.
+makelist(N,[N|T]):- N1 is N - 1, makelist(N1,T).
+
+makevarlist(0,[]):- !.
+makevarlist(N,[_N|T]):- N1 is N - 1, makevarlist(N1,T).
+
diff --git a/src/Tests/xsb/table_tests/test_large_tabled_terms_old b/src/Tests/xsb/table_tests/test_large_tabled_terms_old
new file mode 100644
index 0000000..3569a1f
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_large_tabled_terms_old
@@ -0,0 +1,8 @@
+test_large_ground_subgoal
+test_large_ground_answer
+test_subgoal_abstraction
+test_answer_abstraction
+test_subgoal_answer_abstraction
+test_var_limit_1_succeeded
+test_var_limit_1_succeeded
+test_a_var_succeeded
diff --git a/src/Tests/xsb/table_tests/test_maxans_decl_old b/src/Tests/xsb/table_tests/test_maxans_decl_old
index 451ab75..5d341a6 100644
--- a/src/Tests/xsb/table_tests/test_maxans_decl_old
+++ b/src/Tests/xsb/table_tests/test_maxans_decl_old
@@ -3,4 +3,4 @@
 get_residual(p(3,3),[])
 get_residual(p(4,4),[])
 get_residual(p(5,5),[])
-get_residual(p(A,B),[restraint_number_of_answers])
+get_residual(p(A,B),[answer_count_restraint])
diff --git a/src/Tests/xsb/table_tests/test_negcycle.P b/src/Tests/xsb/table_tests/test_negcycle.P
new file mode 100644
index 0000000..088f6ad
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_negcycle.P
@@ -0,0 +1,73 @@
+
+:- table p/1.
+p(_X).
+
+:- table q/1 as subgoal_abstract(2).
+q(_X).
+
+% error -- "deep" terms
+test:- set_prolog_flag(unify_with_occurs_check,off),fail.
+test:- set_prolog_flag(max_table_subgoal_size_action,error),set_prolog_flag(max_table_subgoal_size,2),fail.
+test:- catch(p(f(f(f(1)))),_E,(writeln(error(e1)),fail)),writeln(success(e1)),fail.
+test:- abolish_table_pred(p/1),fail.
+test:- catch(p(f(f(f(1)))),_E,(writeln(error(e2)),fail)),writeln(success(e2)),fail.
+test:- abolish_table_call(p(f(f(f(1))))),fail.
+test:- abolish_all_tables,fail.
+%
+% error -- cyclic terms
+test:- X = f(X),catch(p(X),_E,(writeln(error(ce1)),fail)),writeln(success(ce1)),fail.
+test:- abolish_table_pred(p/1),fail.
+test:- X = f(X),catch(p(X),_E,(writeln(error(ce2)),fail)),writeln(success(ce2)),fail.
+test:- X = f(X),catch(abolish_table_call(p(X)),_E,(writeln(error(ce3)),fail)),fail.
+test:- abolish_all_tables,fail.
+%
+% error -- "deep" terms / tnot
+test:- catch(tnot(p(f(f(f(1))))),_E,(writeln(error(e3)),fail)),writeln(success(e3)),fail.
+test:- abolish_table_pred(p/1),fail.
+test:- catch(tnot(p(f(f(f(1))))),_E,(writeln(error(e4)),fail)),writeln(success(e4)),fail.
+test:- abolish_table_call(p(f(f(f(1))))),fail.
+test:- abolish_all_tables,fail.
+%
+% error -- cyclic terms / tnot
+test:- X = f(X),catch(tnot(p(X)),_E,(writeln(error(ce4)),fail)),writeln(success(ce4)),fail.
+test:- abolish_table_pred(p/1),fail.
+test:- X = f(X),catch(tnot(p(X)),_E,(writeln(error(ce5)),fail)),writeln(success(ce5)),fail.
+test:- X = f(X),catch(abolish_table_call(p(X)),_E,(writeln(error(ce6)),fail)),fail.
+test:- abolish_all_tables,fail.
+%
+%% abstraction -- "deep" terms
+test:- set_prolog_flag(max_table_subgoal_size_action,abstract),fail.
+test:- catch(q(f(f(f(1)))),_E,(writeln(error(a1)),fail)),writeln(success(a1)),fail.
+test:- abolish_table_pred(q/1),fail.
+test:- catch(q(f(f(f(1)))),_E,(writeln(error(a2)),fail)),writeln(success(a2)),fail.
+test:- abolish_table_call(q(f(f(f(1))))),fail.
+test:- abolish_all_tables,fail.
+%
+% abstraction -- cyclic terms
+test:- X = f(X),catch(q(X),_E,(writeln(error(ca1)),fail)),writeln(success(ca1)),fail.
+test:- abolish_table_pred(q/1),fail.
+test:- X = f(X),catch(q(X),_E,(writeln(error(ca2)),fail)),writeln(success(ca2)),fail.
+test:- X = f(X),catch(abolish_table_call(q(X)),_E,(writeln(error(cae3)),fail)),fail.
+test:- abolish_all_tables,fail.
+%
+% abstraction -- "deep" terms / tnot
+test:- catch(tnot(q(f(f(f(1))))),_E,(writeln(error(a3)),fail)),writeln(success(a3)),fail.
+test:- abolish_table_pred(q/1),fail.
+test:- catch(tnot(q(f(f(f(1))))),_E,(writeln(error(a4)),fail)),writeln(success(a4)),fail.
+test:- abolish_table_call(q(f(f(f(1))))),fail.
+test:- abolish_all_tables,fail.
+%%
+% abstraction -- cyclic terms / tnot
+test:- X = f(X),catch(tnot(q(X)),_E,(writeln(error(ca4)),fail)),writeln(success(ca3)),fail.
+test:- abolish_table_pred(q/1),fail.
+test:- X = f(X),catch(tnot(q(X)),_E,(writeln(error(ca4)),fail)),writeln(success(ca4)),fail.
+test:- X = f(X),catch(abolish_table_call(q(X)),_E,(writeln(error(cae4)),fail)),fail.
+test:- abolish_all_tables,fail.
+%
+%TBD: floundering goals are not yet detected properly
+%test:- catch(tnot(q(_X)),_E,(writeln(error(f1)),fail)),fail.
+%%
+test:- X = f(X),catch(tnot(X),_E,(writeln(error(c1)),fail)),fail.
+%%
+test:- set_prolog_flag(max_table_subgoal_size_action,error),fail.
+test.
diff --git a/src/Tests/xsb/table_tests/test_negcycle_old b/src/Tests/xsb/table_tests/test_negcycle_old
new file mode 100644
index 0000000..1315e55
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_negcycle_old
@@ -0,0 +1,21 @@
+error(a3)
+error(a4)
+error(c1)
+error(ca4)
+error(ca4)
+error(cae3)
+error(cae4)
+error(ce1)
+error(ce2)
+error(ce3)
+error(ce4)
+error(ce5)
+error(ce6)
+error(e1)
+error(e2)
+error(e3)
+error(e4)
+success(a1)
+success(a2)
+success(ca1)
+success(ca2)
diff --git a/src/Tests/xsb/table_tests/test_tda.P b/src/Tests/xsb/table_tests/test_tda.P
new file mode 100644
index 0000000..2a86605
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_tda.P
@@ -0,0 +1,209 @@
+
+/*
+ Need to test out doubles for p3/p7
+ */
+
+:- compiler_options([spec_off]).
+
+%:- set_prolog_flag(max_table_subgoal_size_action,failure).
+:- set_prolog_flag(max_table_subgoal_size_action,abstract).
+:- set_prolog_flag(max_table_subgoal_size,2).
+%:- import start_forest_view/1 from tables.
+%?- start_forest_view(userout).
+
+%--------------------
+:- table p1/1.
+p1(X):- Y = f(X),p1(Y).
+p1(1).
+
+%--------------------
+:- table p11/1.
+p11(X):- p11(f(X)).
+p11(1).
+
+%--------------------
+:- table p12/1.
+p12(X):- Y = [X],
+	% writeln(calling(p12(Y))),
+	p12(Y).
+p12(1).
+
+%--------------------
+:- table p2/1.
+p2(1).
+p2(X):- Y = f(X),p2(Y).
+
+%--------------------
+:- table p21/1.
+p21(1).
+p21(X):- p21(f(X)).
+
+%--------------------
+:- table p22/1.
+p22(1).
+p22(X):- p22([X]).
+
+%--------------------
+:- table p3/1.
+p3(X):- %writeln(entering_clause(X)),
+	p3(f(X)).
+%	writeln(succeeded_clause(X)).
+p3(X):- %writeln(entering_fact(X)),
+	X = f(1).
+	%writeln(succeeded_fact(X)).
+%p3(X):- X = f(1).
+
+%p3(f(f(f(f(f(f(1))))))).
+%p3(f(f(f(f(f(1)))))).
+%--------------------
+:- table p31/1.
+p31(X):-
+	%writeln(calling([X])),
+	p31([X]).
+p31([1]).
+
+%--------------------
+
+:- table p4/1.
+%p4(f(f(f(f(f(f(1))))))).
+p4(f(1)).
+p4(X):-
+	%writeln(calling(p4(f(X)))),
+	p4(f(X)).
+
+%--------------------
+
+:- table p41/1.
+p41([1]).
+p41(X):-
+	%writeln(calling(p41([X]))),
+	p41([X]).
+
+%--------------------
+
+:- table p5/1.
+p5(f(g(f(1)))).
+p5(f(g(f(2)))).
+
+%--------------------
+
+:- table p6/1.
+p6(_X).
+p6(X):- p6(f(X)).
+
+%--------------------
+
+:- table p7/1.
+p7(X):- p7(f(X)).
+p7(_X).
+
+%--------------------
+
+:- table d1/2.
+d1(1,1).
+d1(X,Y):- d1(f(X),f(Y)).
+
+%--------------------
+
+:- table d11/2.
+d11(1,1).
+d11(X,Y):- d11([X],[Y]).
+
+%--------------------
+
+:- table d2/2.
+d2(X,Y):- d2(f(X),f(Y)).
+d2(1,1).
+
+%--------------------
+
+:- table p8/1.
+p8(X):- p8(f(X)).
+p8(f(f(f(1)))).
+p8(f(f(g(2)))).
+p8(f(f(f(3)))).
+p8(f(f(g(4)))).
+
+%--------------------
+
+%--------------------
+:- table n1/1.
+
+n1(X):- tnot(n1(f(X))).
+n1(1).
+
+%--------------------
+
+test:- setof(X,p1(X),Xs),
+       (Xs == [1] -> writeln('>>>>>succeeded(p1)')
+        ; writeln('>>>>>failed(p1)') ),fail.
+test:- setof(X,p11(X),Xs),
+       (Xs == [1] -> writeln('>>>>>succeeded(p11)')
+        ; writeln('>>>>>failed(p11)') ),fail.
+test:- setof(X,p2(X),Xs),
+       (Xs == [1] -> writeln('>>>>>succeeded(p2)')
+        ; writeln('>>>>>failed(p2)') ),fail.
+test:- setof(X,p21(X),Xs),
+       (Xs == [1] -> writeln('>>>>>succeeded(p21)')
+        ; writeln('>>>>>failed(p21)') ),fail.
+test:- setof(X,p3(X),Xs),
+       (Xs == [1,f(1)] -> writeln('>>>>>succeeded(p3)')
+        ; writeln('>>>>>failed(p3)') ),fail.
+test:- setof(X,p31(X),Xs),
+       (Xs == [1,[1]] -> writeln('>>>>>succeeded(p31)')
+        ; writeln('>>>>>failed(p31)') ),fail.
+test:- setof(X,p4(X),Xs),
+       (Xs == [1,f(1)] -> writeln('>>>>>succeeded(p4)')
+        ; writeln('>>>>>failed(p4)') ),fail.
+test:- setof(X,p41(X),Xs),
+       (Xs == [1,[1]] -> writeln('>>>>>succeeded(p41)')
+        ; writeln('>>>>>failed(p41)') ),fail.
+test:- test5.
+test:- test5a.
+test:- test5b.
+test:- test6.
+test:- test7.
+test:- testd1.
+test:- testd11.
+test.
+
+test5:- abolish_all_tables,
+	setof(X,p5(f(g(f(X)))),Xs),
+	(Xs == [1,2] -> writeln('>>>>>succeeded(p5)')
+         ; writeln('>>>>>failed(p5)') ),fail.
+test5a:- abolish_all_tables,
+	 (p5(_),fail ; true),
+	 setof(X,p5(f(g(f(X)))),Xs),
+	 (Xs == [1,2] -> writeln('>>>>>succeeded(p5a)')
+          ; writeln('>>>>>failed(p5a)') ),fail.
+test5b:- abolish_all_tables,
+	 (p5(_),fail ; true),
+	 findall(1,p5(f(g(f(3)))),Xs),
+	 (Xs == [] -> writeln('>>>>>succeeded(p5b)')
+          ; writeln('>>>>>failed(p5b)') ),fail.
+
+test6:- abolish_all_tables,
+	 (p6(_),fail ; true),
+	 findall(X,get_residual(p6(X),_Y),Xs),
+	 (Xs = [_,f(_),f(f(_))] -> writeln('>>>>>succeeded(p6)')
+          ; writeln('>>>>>failed(p6)') ),fail.
+
+test7:- abolish_all_tables,
+	 (p7(_),fail ; true),
+	 findall(X,get_residual(p7(X),_Y),Xs),
+	 (Xs = [_,f(_),f(f(_))] -> writeln('>>>>>succeeded(p7)')
+          ; writeln('>>>>>failed(p7)') ),fail.
+
+testd1:- abolish_all_tables,
+	 setof([X,Y],d1(X,Y),Xs),
+	 (Xs = [[1,1]] -> writeln('>>>>>succeeded(d1)')
+          ; writeln('>>>>>failed(d1)') ),fail.
+testd11:- abolish_all_tables,
+	 setof([X,Y],d11(X,Y),Xs),
+	 (Xs = [[1,1]] -> writeln('>>>>>succeeded(d11)')
+          ; writeln('>>>>>failed(d11)') ),fail.
+
+testd2:- abolish_all_tables,
+	 setof([X,Y],d2(X,Y),Xs),
+	 (Xs = [[1,1]] -> writeln('>>>>>succeeded(d2)')
+          ; writeln('>>>>>failed(d2)') ),fail.
diff --git a/src/Tests/xsb/table_tests/test_tda_i.P b/src/Tests/xsb/table_tests/test_tda_i.P
new file mode 100644
index 0000000..b98e4de
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_tda_i.P
@@ -0,0 +1,209 @@
+
+/*
+ Need to test out doubles for p3/p7
+ */
+
+:- compiler_options([spec_off]).
+
+:- set_prolog_flag(max_table_subgoal_size_action,abstract).
+%:- set_prolog_flag(max_table_subgoal_depth,2).
+
+%:- import start_forest_view/1 from tables.
+%?- start_forest_view(userout).
+
+%--------------------
+:- table p1/1 as subgoal_abstract(2).
+p1(X):- Y = f(X),p1(Y).
+p1(1).
+
+%--------------------
+:- table p11/1 as subgoal_abstract(2).
+p11(X):- p11(f(X)).
+p11(1).
+
+%--------------------
+:- table p12/1 as subgoal_abstract(2).
+p12(X):- Y = [X],
+	% writeln(calling(p12(Y))),
+	p12(Y).
+p12(1).
+
+%--------------------
+:- table p2/1 as subgoal_abstract(2).
+p2(1).
+p2(X):- Y = f(X),p2(Y).
+
+%--------------------
+:- table p21/1 as subgoal_abstract(2).
+p21(1).
+p21(X):- p21(f(X)).
+
+%--------------------
+:- table p22/1 as subgoal_abstract(2).
+p22(1).
+p22(X):- p22([X]).
+
+%--------------------
+:- table p3/1 as subgoal_abstract(2).
+p3(X):- %writeln(entering_clause(X)),
+	p3(f(X)).
+%	writeln(succeeded_clause(X)).
+p3(X):- %writeln(entering_fact(X)),
+	X = f(1).
+	%writeln(succeeded_fact(X)).
+%p3(X):- X = f(1).
+
+%p3(f(f(f(f(f(f(1))))))).
+%p3(f(f(f(f(f(1)))))).
+%--------------------
+:- table p31/1 as subgoal_abstract(2).
+p31(X):-
+	%writeln(calling([X])),
+	p31([X]).
+p31([1]).
+
+%--------------------
+
+:- table p4/1 as subgoal_abstract(2).
+%p4(f(f(f(f(f(f(1))))))).
+p4(f(1)).
+p4(X):-
+	%writeln(calling(p4(f(X)))),
+	p4(f(X)).
+
+%--------------------
+
+:- table p41/1 as subgoal_abstract(2).
+p41([1]).
+p41(X):-
+	%writeln(calling(p41([X]))),
+	p41([X]).
+
+%--------------------
+
+:- table p5/1 as subgoal_abstract(2).
+p5(f(g(f(1)))).
+p5(f(g(f(2)))).
+
+%--------------------
+
+:- table p6/1 as subgoal_abstract(2).
+p6(_X).
+p6(X):- p6(f(X)).
+
+%--------------------
+
+:- table p7/1 as subgoal_abstract(2).
+p7(X):- p7(f(X)).
+p7(_X).
+
+%--------------------
+
+:- table d1/2 as subgoal_abstract(2).
+d1(1,1).
+d1(X,Y):- d1(f(X),f(Y)).
+
+%--------------------
+
+:- table d11/2 as subgoal_abstract(2).
+d11(1,1).
+d11(X,Y):- d11([X],[Y]).
+
+%--------------------
+
+:- table d2/2 as subgoal_abstract(2).
+d2(X,Y):- d2(f(X),f(Y)).
+d2(1,1).
+
+%--------------------
+
+:- table p8/1 as subgoal_abstract(2).
+p8(X):- p8(f(X)).
+p8(f(f(f(1)))).
+p8(f(f(g(2)))).
+p8(f(f(f(3)))).
+p8(f(f(g(4)))).
+
+%--------------------
+
+%--------------------
+:- table n1/1 as subgoal_abstract(2).
+
+n1(X):- tnot(n1(f(X))).
+n1(1).
+
+%--------------------
+
+test:- setof(X,p1(X),Xs),
+       (Xs == [1] -> writeln('>>>>>succeeded(p1)')
+        ; writeln('>>>>>failed(p1)') ),fail.
+test:- setof(X,p11(X),Xs),
+       (Xs == [1] -> writeln('>>>>>succeeded(p11)')
+        ; writeln('>>>>>failed(p11)') ),fail.
+test:- setof(X,p2(X),Xs),
+       (Xs == [1] -> writeln('>>>>>succeeded(p2)')
+        ; writeln('>>>>>failed(p2)') ),fail.
+test:- setof(X,p21(X),Xs),
+       (Xs == [1] -> writeln('>>>>>succeeded(p21)')
+        ; writeln('>>>>>failed(p21)') ),fail.
+test:- setof(X,p3(X),Xs),
+       (Xs == [1,f(1)] -> writeln('>>>>>succeeded(p3)')
+        ; writeln('>>>>>failed(p3)') ),fail.
+test:- setof(X,p31(X),Xs),
+       (Xs == [1,[1]] -> writeln('>>>>>succeeded(p31)')
+        ; writeln('>>>>>failed(p31)') ),fail.
+test:- setof(X,p4(X),Xs),
+       (Xs == [1,f(1)] -> writeln('>>>>>succeeded(p4)')
+        ; writeln('>>>>>failed(p4)') ),fail.
+test:- setof(X,p41(X),Xs),
+       (Xs == [1,[1]] -> writeln('>>>>>succeeded(p41)')
+        ; writeln('>>>>>failed(p41)') ),fail.
+test:- test5.
+test:- test5a.
+test:- test5b.
+test:- test6.
+test:- test7.
+test:- testd1.
+test:- testd11.
+test.
+
+test5:- abolish_all_tables,
+	setof(X,p5(f(g(f(X)))),Xs),
+	(Xs == [1,2] -> writeln('>>>>>succeeded(p5)')
+         ; writeln('>>>>>failed(p5)') ),fail.
+test5a:- abolish_all_tables,
+	 (p5(_),fail ; true),
+	 setof(X,p5(f(g(f(X)))),Xs),
+	 (Xs == [1,2] -> writeln('>>>>>succeeded(p5a)')
+          ; writeln('>>>>>failed(p5a)') ),fail.
+test5b:- abolish_all_tables,
+	 (p5(_),fail ; true),
+	 findall(1,p5(f(g(f(3)))),Xs),
+	 (Xs == [] -> writeln('>>>>>succeeded(p5b)')
+          ; writeln('>>>>>failed(p5b)') ),fail.
+
+test6:- abolish_all_tables,
+	 (p6(_),fail ; true),
+	 findall(X,get_residual(p6(X),_Y),Xs),
+	 (Xs = [_,f(_),f(f(_))] -> writeln('>>>>>succeeded(p6)')
+          ; writeln('>>>>>failed(p6)') ),fail.
+
+test7:- abolish_all_tables,
+	 (p7(_),fail ; true),
+	 findall(X,get_residual(p7(X),_Y),Xs),
+	 (Xs = [_,f(_),f(f(_))] -> writeln('>>>>>succeeded(p7)')
+          ; writeln('>>>>>failed(p7)') ),fail.
+
+testd1:- abolish_all_tables,
+	 setof([X,Y],d1(X,Y),Xs),
+	 (Xs = [[1,1]] -> writeln('>>>>>succeeded(d1)')
+          ; writeln('>>>>>failed(d1)') ),fail.
+testd11:- abolish_all_tables,
+	 setof([X,Y],d11(X,Y),Xs),
+	 (Xs = [[1,1]] -> writeln('>>>>>succeeded(d11)')
+          ; writeln('>>>>>failed(d11)') ),fail.
+
+testd2:- abolish_all_tables,
+	 setof([X,Y],d2(X,Y),Xs),
+	 (Xs = [[1,1]] -> writeln('>>>>>succeeded(d2)')
+          ; writeln('>>>>>failed(d2)') ),fail.
diff --git a/src/Tests/xsb/table_tests/test_tda_i_old b/src/Tests/xsb/table_tests/test_tda_i_old
new file mode 100644
index 0000000..724fe66
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_tda_i_old
@@ -0,0 +1,15 @@
+>>>>>succeeded(d1)
+>>>>>succeeded(d11)
+>>>>>succeeded(p1)
+>>>>>succeeded(p11)
+>>>>>succeeded(p2)
+>>>>>succeeded(p21)
+>>>>>succeeded(p3)
+>>>>>succeeded(p31)
+>>>>>succeeded(p4)
+>>>>>succeeded(p41)
+>>>>>succeeded(p5)
+>>>>>succeeded(p5a)
+>>>>>succeeded(p5b)
+>>>>>succeeded(p6)
+>>>>>succeeded(p7)
diff --git a/src/Tests/xsb/table_tests/test_tda_old b/src/Tests/xsb/table_tests/test_tda_old
new file mode 100644
index 0000000..724fe66
--- /dev/null
+++ b/src/Tests/xsb/table_tests/test_tda_old
@@ -0,0 +1,15 @@
+>>>>>succeeded(d1)
+>>>>>succeeded(d11)
+>>>>>succeeded(p1)
+>>>>>succeeded(p11)
+>>>>>succeeded(p2)
+>>>>>succeeded(p21)
+>>>>>succeeded(p3)
+>>>>>succeeded(p31)
+>>>>>succeeded(p4)
+>>>>>succeeded(p41)
+>>>>>succeeded(p5)
+>>>>>succeeded(p5a)
+>>>>>succeeded(p5b)
+>>>>>succeeded(p6)
+>>>>>succeeded(p7)
diff --git a/src/Tests/xsb/table_tests/xsb_test_tables.pl b/src/Tests/xsb/table_tests/xsb_test_tables.pl
index 2ebee6e..527b7db 100644
--- a/src/Tests/xsb/table_tests/xsb_test_tables.pl
+++ b/src/Tests/xsb/table_tests/xsb_test_tables.pl
@@ -53,11 +53,22 @@
                )).
 
 run_table_test(Test) :-
+    reset_table_defaults,
     xsb_test(table_tests,Test,xsb_test_tables:swi_test(Test)).
 
 swi_test(M:_P) :-
     abolish_all_tables,
-    M:test.
+    M:test,
+    reset_table_defaults.
+
+reset_table_defaults :-
+    set_prolog_flag(max_table_answer_size, infinite),
+    set_prolog_flag(max_table_answer_size_action, error),
+    set_prolog_flag(max_table_subgoal_size, infinite),
+    set_prolog_flag(max_table_subgoal_size_action, error),
+    set_prolog_flag(max_answers_for_subgoal, infinite),
+    set_prolog_flag(max_answers_for_subgoal_action, error).
+
 
 :- begin_tests(xsb_test_tables, [sto(rational_trees)]).
 
@@ -68,23 +79,30 @@
 table_test(abol_test3a).        % atp gc diff preds
 table_test(abol_test3b).        % atp gc diff preds + valid
 table_test(abol_test3c).        % atp gc diff preds + valid + multiple gcs
-table_test(atc_test).
 table_test(abolish_cascade).	% cascading abolish for subgoals with gc etc.
 table_test(abolish_cascade_pred).
 table_test(abolish_cycle).
 table_test(abolish_dag).
 table_test(abolish_neg_cycle).
 table_test(abolish_neg_dag).
+table_test(atc_test).
+table_test(concomp).
+table_test(expand).
+table_test(ins).
+table_test(large_arity_tables).
+table_test(lrbug).
+table_test(pps).
 table_test(pred_abolish_cycle).
 table_test(pred_abolish_dag).
 table_test(recursive_aboltest).
-table_test(ins).
-table_test(large_arity_tables).
-table_test(concomp).
-table_test(lrbug).
 table_test(tabbug1).
-table_test(pps).
 table_test(test_3vwfs_1).       % WFS with answer subsumption
-%table_test(test_maxans_decl).   % max_answers(Count) restraint
+table_test(test_calldepth).
+table_test(test_cyclic_tabling).% Cyclic term handling
+table_test(test_large_tabled_terms).
+table_test(test_maxans_decl).   % max_answers(Count) restraint
+table_test(test_negcycle).
+table_test(test_tda).		% subgoal_abstract restraint (abstract)
+table_test(test_tda_i).		% subgoal_abstract restraint (abstract)
 
 :- end_tests(xsb_test_tables).
diff --git a/src/os/pl-os.c b/src/os/pl-os.c
index 5d2401b..cb97fb8 100644
--- a/src/os/pl-os.c
+++ b/src/os/pl-os.c
@@ -1087,6 +1087,8 @@
 	if ( d->canonical != d->name )
 	  remove_string(d->canonical);
 	PL_free(d);
+
+	return;
       }
     }
 
diff --git a/src/os/pl-prologflag.c b/src/os/pl-prologflag.c
index 96ddddc..0a6e708 100644
--- a/src/os/pl-prologflag.c
+++ b/src/os/pl-prologflag.c
@@ -1715,6 +1715,40 @@
   setGITVersion();
 }
 
+static int
+abi_version_dict(term_t dict)
+{ GET_LD
+  const atom_t keys[] = { ATOM_foreign_interface,
+			  ATOM_record,
+			  ATOM_qlf,
+			  ATOM_qlf_min_load,
+			  ATOM_vmi,
+			  ATOM_built_in };
+  term_t values = PL_new_term_refs(6);
+
+  return ( PL_unify_integer(values+0, PL_version(PL_VERSION_FLI)) &&
+	   PL_unify_integer(values+1, PL_version(PL_VERSION_REC)) &&
+	   PL_unify_integer(values+2, PL_version(PL_VERSION_QLF)) &&
+	   PL_unify_integer(values+3, PL_version(PL_VERSION_QLF_LOAD)) &&
+	   PL_unify_integer(values+4, PL_version(PL_VERSION_VM)) &&
+	   PL_unify_integer(values+5, PL_version(PL_VERSION_BUILT_IN)) &&
+
+	   PL_put_dict(dict, ATOM_abi, 6, keys, values) );
+}
+
+
+void
+setABIVersionPrologFlag(void)
+{ GET_LD
+  fid_t fid = PL_open_foreign_frame();
+  term_t t = PL_new_term_ref();
+
+  if ( abi_version_dict(t) )
+    setPrologFlag("abi_version", FF_READONLY|FT_TERM, t);
+
+  PL_discard_foreign_frame(fid);
+}
+
 
 void
 cleanupPrologFlags(void)
diff --git a/src/os/pl-text.c b/src/os/pl-text.c
index 647e630..63a0bb3 100644
--- a/src/os/pl-text.c
+++ b/src/os/pl-text.c
@@ -75,15 +75,19 @@
 }
 
 
-void
+int
 PL_save_text(PL_chars_t *text, int flags)
 { if ( (flags & BUF_MALLOC) && text->storage != PL_CHARS_MALLOC )
   { size_t bl = bufsize_text(text, text->length+1);
     void *new = PL_malloc(bl);
 
-    memcpy(new, text->text.t, bl);
-    text->text.t = new;
-    text->storage = PL_CHARS_MALLOC;
+    if ( new )
+    { memcpy(new, text->text.t, bl);
+      text->text.t = new;
+      text->storage = PL_CHARS_MALLOC;
+    } else
+    { return FALSE;
+    }
   } else if ( text->storage == PL_CHARS_LOCAL )
   { Buffer b = findBuffer(BUF_RING);
     size_t bl = bufsize_text(text, text->length+1);
@@ -102,6 +106,8 @@
 
     text->storage = PL_CHARS_RING;
   }
+
+  return TRUE;
 }
 
 
@@ -120,6 +126,8 @@
       { memcpy(text->buf, text->text.t, bl);
 	text->text.t = text->buf;
 	text->storage = PL_CHARS_LOCAL;
+      } else if ( (flags&BUF_NORING) )
+      { return PL_save_text(text, BUF_MALLOC);
       } else
       { Buffer b = findBuffer(BUF_RING);
 
@@ -345,7 +353,7 @@
 
 	Sclose(fd);
 
-	return TRUE;
+	goto out;
       } else
       { Sclose(fd);
 	if ( r != text->buf )
@@ -358,7 +366,11 @@
   { goto error;
   }
 
-  succeed;
+out:
+  if ( (flags&BUF_NORING) && text->storage == PL_CHARS_RING )
+    return PL_save_text(text, BUF_MALLOC);
+
+  return TRUE;
 
 maybe_write:
   if ( (flags & (CVT_WRITE|CVT_WRITE_CANONICAL)) )
diff --git a/src/os/pl-text.h b/src/os/pl-text.h
index 0078cea..9897eab 100644
--- a/src/os/pl-text.h
+++ b/src/os/pl-text.h
@@ -79,7 +79,7 @@
 int	PL_concat_text(int n, PL_chars_t **text, PL_chars_t *result);
 
 void	PL_free_text(PL_chars_t *text);
-void	PL_save_text(PL_chars_t *text, int flags);
+int	PL_save_text(PL_chars_t *text, int flags);
 
 COMMON(int)		PL_get_text__LD(term_t l, PL_chars_t *text, int flags ARG_LD);
 COMMON(atom_t)		textToAtom(PL_chars_t *text);
diff --git a/src/parms.h.cmake b/src/parms.h.cmake
index 726c313..b7ac923 100644
--- a/src/parms.h.cmake
+++ b/src/parms.h.cmake
@@ -1,5 +1,6 @@
 #define PLHOME		  "@PLHOME@"
 #cmakedefine PLSHAREDHOME "@PLSHAREDHOME@"
+#cmakedefine PLPKGNAME    "@SWIPL_PKG_NAME@"
 #define PLARCH            "@PLARCH@"
 #define C_CC              "@C_CC@"
 #define C_CXX             "@C_CXX@"
diff --git a/src/pl-arith.c b/src/pl-arith.c
index 65a5de5..e93d228 100644
--- a/src/pl-arith.c
+++ b/src/pl-arith.c
@@ -3573,7 +3573,7 @@
 	return TRUE;
       }
 
-      if ( n1->value.f <= PLMAXINT && n1->value.f >= PLMININT )
+      if ( n1->value.f <= (float)PLMAXINT && n1->value.f >= (float)PLMININT )
       { if ( n1->value.f > 0 )
 	{ r->value.i = (int64_t)(n1->value.f + 0.5);
 	  if ( r->value.i < 0 )		/* Why can this happen? */
diff --git a/src/pl-attvar.c b/src/pl-attvar.c
index f570309..69a64ba 100644
--- a/src/pl-attvar.c
+++ b/src/pl-attvar.c
@@ -507,15 +507,14 @@
 
 int
 saveWakeup(wakeup_state *state, int forceframe ARG_LD)
-{ Word h;
-
-  state->flags = 0;
+{ state->flags = 0;
   state->outofstack = LD->outofstack;
 
-  if ( *(h=valTermRef(LD->attvar.head)) ||
+  if ( *valTermRef(LD->attvar.head) ||
        exception_term ||
        forceframe )
   { term_t s;
+    Word h;
 
     if ( !(state->fid = PL_open_foreign_frame()) )
       return FALSE;			/* no space! */
@@ -527,7 +526,7 @@
       exception_term = 0;
     }
 
-    if ( *h )
+    if ( *(h=valTermRef(LD->attvar.head)) )
     { state->flags |= WAKEUP_STATE_WAKEUP;
       s = PL_new_term_refs(2);
 
diff --git a/src/pl-dict.c b/src/pl-dict.c
index 0df281b..c1c836d 100644
--- a/src/pl-dict.c
+++ b/src/pl-dict.c
@@ -141,12 +141,6 @@
 }
 
 
-static inline int
-is_key(word w)
-{ return isAtom(w) || isTaggedInt(w);
-}
-
-
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 dict_lookup_ptr() returns a pointer to the value for a given key
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
@@ -199,12 +193,12 @@
   if ( count > 0 )
   { data++;			/* skip to key */
     deRef2(data, n1);
-    if ( !is_key(*n1) )
+    if ( !is_dict_key(*n1) )
       return -1;
 
     for(; count > 1; count--, data += 2, n1=n2)
     { deRef2(data+2, n2);
-      if ( !is_key(*n2) )
+      if ( !is_dict_key(*n2) )
 	return -1;
       if ( *n1 < *n2 )
 	continue;
@@ -591,7 +585,7 @@
 { Word p = valTermRef(t);
 
   deRef(p);
-  if ( is_key(*p) )
+  if ( is_dict_key(*p) )
   { *np = *p;
     return TRUE;
   }
@@ -616,7 +610,7 @@
     { Word np, vp;
 
       deRef2(&f->arguments[0], np);
-      if ( is_key(*np) )
+      if ( is_dict_key(*np) )
       { *name = *np;
 	deRef2(&f->arguments[1], vp);
 	*value = linkVal(vp);
@@ -1161,7 +1155,7 @@
 	return FALSE;
 
       deRef(np);
-      if ( is_key(*np) )
+      if ( is_dict_key(*np) )
       { Word vp;
 
 	if ( (vp=dict_lookup_ptr(dict, *np PASS_LD)) )
@@ -1652,6 +1646,29 @@
 	  return FALSE;
         goto retry;
     }
+  }
+
+  return FALSE;
+}
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Part of FLI
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+int
+PL_get_dict_key(atom_t key, term_t dict, term_t value)
+{ GET_LD
+  word d;
+  Word vp;
+
+  if ( !is_dict_key(key) )
+    return -1;
+  if ( !get_dict_ex(dict, &d, FALSE PASS_LD) )
+    return FALSE;
+  if ( (vp=dict_lookup_ptr(d, key PASS_LD)) )
+  { *valTermRef(value) = linkVal(vp);
+    return TRUE;
   }
 
   return FALSE;
diff --git a/src/pl-dict.h b/src/pl-dict.h
index ff7f4ae..afc97de 100644
--- a/src/pl-dict.h
+++ b/src/pl-dict.h
@@ -63,4 +63,9 @@
   return ( fd->name == ATOM_dict && fd->arity%2 == 1 );
 }
 
+static inline int
+is_dict_key(word w)
+{ return isAtom(w) || isTaggedInt(w);
+}
+
 #endif /*PL_DICT_H_INCLUDED*/
diff --git a/src/pl-ext.c b/src/pl-ext.c
index 2f0cfdd..a88765e 100644
--- a/src/pl-ext.c
+++ b/src/pl-ext.c
@@ -204,6 +204,21 @@
 };
 
 
+#define SIGNATURE_SEED (0x1a3be34a)
+
+static unsigned int
+predicate_signature(const Definition def)
+{ char str[256];
+
+  Ssprintf(str, "%s/%d/%d",
+	   stringAtom(def->functor->name),
+	   (int)def->functor->arity,
+	   def->flags);
+
+  return MurmurHashAligned2(str, strlen(str), SIGNATURE_SEED);
+}
+
+
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 The extensions chain is used   to allow calling PL_register_extensions()
 *before* PL_initialise() to get foreign   extensions in embedded systems
@@ -324,6 +339,9 @@
 
       def->impl.foreign.function = f->function;
       createForeignSupervisor(def, f->function);
+
+      if ( !extensions_loaded )
+	GD->foreign.signature ^= predicate_signature(def);
     } else
     { assert(0);
     }
diff --git a/src/pl-fli.c b/src/pl-fli.c
index fb71b16..5fd18aa 100644
--- a/src/pl-fli.c
+++ b/src/pl-fli.c
@@ -3846,6 +3846,53 @@
 
 
 		 /*******************************
+		 *	       DICT		*
+		 *******************************/
+
+int
+PL_put_dict(term_t t, atom_t tag,
+	    size_t len, const atom_t *keys, term_t values)
+{ GET_LD
+  Word p, p0;
+  size_t size = len*2+2;
+
+  if ( (p0=p=allocGlobal(size)) )
+  { *p++ = dict_functor(len);
+    if ( tag )
+    { if ( isAtom(tag) )
+      { *p++ = tag;
+      } else
+      { invalid:
+	gTop -= size;
+	return -1;
+      }
+    } else
+    { setVar(*p++);
+    }
+
+    for(; len-- > 0; keys++, values++)
+    { *p++ = linkVal(valTermRef(values));
+      if ( is_dict_key(*keys) )
+	*p++ = *keys;
+      else
+	goto invalid;
+    }
+
+    if ( dict_order(p0, TRUE PASS_LD) )
+    { setHandle(t, consPtr(p0, TAG_COMPOUND|STG_GLOBAL));
+      DEBUG(CHK_SECURE, checkStacks(NULL));
+      return TRUE;
+    }
+
+    gTop -= size;
+    return -2;
+  }
+
+  return FALSE;
+}
+
+
+		 /*******************************
 		 *	       TYPE		*
 		 *******************************/
 
@@ -4591,6 +4638,10 @@
 
   return FALSE;
 }
+
+#ifndef SIGABRT
+#define SIGABRT 6			/* exit 134 --> aborted */
+#endif
 
 void
 PL_abort_process(void)
@@ -5299,6 +5350,25 @@
 
 
 		 /*******************************
+		 *	      VERSION		*
+		 *******************************/
+
+unsigned int
+PL_version(int which)
+{ switch(which)
+  { case PL_VERSION_SYSTEM:	return PLVERSION;
+    case PL_VERSION_FLI:	return PL_FLI_VERSION;
+    case PL_VERSION_REC:	return PL_REC_VERSION;
+    case PL_VERSION_QLF:	return PL_QLF_VERSION;
+    case PL_VERSION_QLF_LOAD:	return PL_QLF_LOADVERSION;
+    case PL_VERSION_VM:		return VM_SIGNATURE;
+    case PL_VERSION_BUILT_IN:	return GD->foreign.signature;
+    default:			return 0;
+  }
+}
+
+
+		 /*******************************
 		 *	       INIT		*
 		 *******************************/
 
diff --git a/src/pl-funcs.h b/src/pl-funcs.h
index 03df634..ac7cfb2 100644
--- a/src/pl-funcs.h
+++ b/src/pl-funcs.h
@@ -439,6 +439,7 @@
 COMMON(int)		setBackQuotes(atom_t a, unsigned int *flagp);
 COMMON(int)		setRationalSyntax(atom_t a, unsigned int *flagp);
 COMMON(void)		initPrologFlags(void);
+COMMON(void)		setABIVersionPrologFlag(void);
 COMMON(void)		cleanupPrologFlags(void);
 
 /* pl-pro.c */
diff --git a/src/pl-global.h b/src/pl-global.h
index 24095b9..f74a472 100644
--- a/src/pl-global.h
+++ b/src/pl-global.h
@@ -3,7 +3,7 @@
     Author:        Jan Wielemaker
     E-mail:        J.Wielemaker@vu.nl
     WWW:           http://www.swi-prolog.org
-    Copyright (c)  1997-2019, University of Amsterdam
+    Copyright (c)  1997-2020, University of Amsterdam
                               VU University Amsterdam
 			      CWI, Amsterdam
     All rights reserved.
@@ -239,6 +239,7 @@
     InitialiseHandle initialise_tail;
     PL_dispatch_hook_t dispatch_events; /* PL_dispatch_hook() */
 
+    unsigned int  signature;		/* Foreign predicate signature */
     int		  _loaded;		/* system extensions are loaded */
   } foreign;
 
diff --git a/src/pl-index.c b/src/pl-index.c
index 993f580..b60c691 100644
--- a/src/pl-index.c
+++ b/src/pl-index.c
@@ -1057,12 +1057,6 @@
       cref = cref->next;
     }
   }
-
-  DEBUG(CHK_SECURE,
-	{ for(cref=clist->first_clause; cref; cref=cref->next)
-	  { assert(false(cref->value.clause, CL_ERASED));
-	  }
-	});
 
   clist->erased_clauses = 0; /* see (*) */
 }
diff --git a/src/pl-init.c b/src/pl-init.c
index a582e9c..746575e 100644
--- a/src/pl-init.c
+++ b/src/pl-init.c
@@ -3,7 +3,7 @@
     Author:        Jan Wielemaker
     E-mail:        J.Wielemaker@vu.nl
     WWW:           http://www.swi-prolog.org
-    Copyright (c)  2012-2019, University of Amsterdam
+    Copyright (c)  2012-2020, University of Amsterdam
                               VU University Amsterdam
 			      CWI, Amsterdam
     All rights reserved.
@@ -116,17 +116,37 @@
 
 
 static const char *
+optcmp(const char *av, const char *opt)
+{ for(; *av && *opt && *av != '='; av++, opt++)
+  { if ( *av == *opt ||
+	 (*av == '-' && *opt == '_') ||
+	 (*av == '_' && *opt == '-') )
+      continue;
+
+    return NULL;
+  }
+
+  if ( !*opt )
+  { if ( *av == '=' )
+      av++;
+    return av;
+  } else
+  { return NULL;
+  }
+}
+
+
+static const char *
 longopt(const char *opt, int argc, const char **argv)
-{ size_t optlen = strlen(opt);
-
-  for(; argc > 0; argc--, argv++)
+{ for(; argc > 0; argc--, argv++)
   { const char *a = argv[0];
+    const char *v;
 
     if ( *a++ == '-' && *a++ == '-' )
     { if ( *a == EOS )		/* --: end of args */
 	return NULL;
-      if ( strncmp(a, opt, optlen) == 0 && a[optlen] == '=' )
-	return &a[optlen+1];
+      if ( (v=optcmp(a, opt)) && *v )
+	return v;
     }
   }
 
@@ -136,18 +156,22 @@
 
 static const char *
 is_longopt(const char *optstring, const char *name)
-{ size_t len = strlen(name);
-
-  if ( strncmp(optstring, name, len) == 0 )
-  { if ( optstring[len] == '=' )
-      return &optstring[len+1];
-    if ( optstring[len] == EOS )
-      return "";
+{ const char *v;
+
+  if ( (v=optcmp(optstring, name)) )
+  { return *v ? v : "";
   }
 
   return NULL;
 }
 
+
+static const char *
+skip_wsep(const char *s)
+{ if ( *s == '-' || *s == '_' )
+    s++;
+  return s;
+}
 
 static int
 is_bool_opt(const char *opt, const char *name, int *val)
@@ -169,16 +193,8 @@
     }
 
     return -1;
-  } else if ( strncmp(opt, "no-", 3) == 0 &&
-	      (optval=is_longopt(opt+3,name)) )
-  { if ( *optval == EOS )
-    { *val = FALSE;
-      return TRUE;
-    }
-
-    return -1;
   } else if ( strncmp(opt, "no", 2) == 0 &&
-	      (optval=is_longopt(opt+2,name)) )
+	      (optval=is_longopt(skip_wsep(opt+2),name)) )
   { if ( *optval == EOS )
     { *val = FALSE;
       return TRUE;
@@ -1114,10 +1130,11 @@
     "%s: Usage:\n",
     "    1) %s [options] prolog-file ... [-- arg ...]\n",
     "    2) %s [options] [-o executable] -c prolog-file ...\n",
-    "    3) %s --help     Display this message (also -h)\n",
-    "    4) %s --version  Display version information\n",
-    "    4) %s --arch     Display architecture\n",
-    "    6) %s --dump-runtime-variables[=format]\n"
+    "    3) %s --help         Display this message (also -h)\n",
+    "    4) %s --version      Display version information\n",
+    "    5) %s --abi-version  Display ABI version key\n",
+    "    6) %s --arch         Display architecture\n",
+    "    7) %s --dump-runtime-variables[=format]\n"
     "                        Dump link info in sh(1) format\n",
     "\n",
     "Options:\n",
@@ -1138,22 +1155,23 @@
     "    --quiet[=bool] (-q)      Do (not) suppress informational messages\n",
     "    --traditional            Disable extensions of version 7\n",
     "    --home=DIR               Use DIR as SWI-Prolog home\n",
-    "    --stack_limit=size[BKMG] Specify maximum size of Prolog stacks\n",
-    "    --table_space=size[BKMG] Specify maximum size of SLG tables\n",
+    "    --stack-limit=size[BKMG] Specify maximum size of Prolog stacks\n",
+    "    --table-space=size[BKMG] Specify maximum size of SLG tables\n",
 #ifdef O_PLMT
-    "    --shared_table_space=size[BKMG] Maximum size of shared SLG tables\n",
+    "    --shared-table-space=size[BKMG] Maximum size of shared SLG tables\n",
 #endif
     "    --pce[=bool]             Make the xpce gui available\n",
     "    --pldoc[=port]           Start PlDoc server [at port]\n",
 #ifdef __WINDOWS__
-    "    --win_app	          Behave as Windows application\n",
+    "    --win-app	          Behave as Windows application\n",
 #endif
 #ifdef O_DEBUG
     "    -d topic,topic,...       Enable C-source DEBUG channels\n",
 #endif
     "\n",
     "Boolean options may be written as --name=bool, --name, --no-name ",
-    "or --noname\n",
+    "or --noname.\n",
+    "Both '-' or '_' are accepted as word-separator for long options.\n",
     NULL
   };
   const cline *lp = lines;
@@ -1198,6 +1216,23 @@
 }
 
 
+#ifndef PLPKGNAME
+#define PLPKGNAME "swipl"
+#endif
+
+static int
+abi_version(void)
+{ setupProlog();
+  Sprintf(PLPKGNAME "-abi-%d-%d-%08x-%08x\n",
+	  PL_FLI_VERSION,
+	  PL_QLF_LOADVERSION,
+	  GD->foreign.signature,
+	  VM_SIGNATURE);
+
+  return TRUE;
+}
+
+
 static int
 arch(void)
 { Sprintf("%s\n", PLARCH);
@@ -1208,15 +1243,19 @@
 
 static int
 giveVersionInfo(const char *a)
-{ if ( a[0] != '-' || a[1] != '-' )
+{ const char *v;
+
+  if ( *a++ != '-' || *a++ != '-' )
     return FALSE;
 
-  if ( streq(a, "--help") )
+  if ( (v=is_longopt(a, "help")) && !*v )
     return usage();
-  if ( streq(a, "--arch") )
+  if ( (v=is_longopt(a, "arch")) && !*v )
     return arch();
-  if ( streq(a, "--version") )
+  if ( (v=is_longopt(a, "version")) && !*v )
     return version();
+  if ( (v=is_longopt(a, "abi_version")) && !*v )
+    return abi_version();
 
   return FALSE;
 }
diff --git a/src/pl-rec.c b/src/pl-rec.c
index 924f333..4e52f42 100644
--- a/src/pl-rec.c
+++ b/src/pl-rec.c
@@ -601,7 +601,8 @@
 
 	  mark.term = f;
 	  mark.fdef = f->definition;
-	  pushSegStack(&LD->cycle.lstack, mark, cycle_mark);
+	  if ( !pushSegStack(&LD->cycle.lstack, mark, cycle_mark) )
+	    return FALSE;
 	  f->definition = (functor_t)consUInt(info->size);
 				  /* overflow test (should not be possible) */
 	  DEBUG(CHK_SECURE, assert(valUInt(f->definition) == (uintptr_t)info->size));
@@ -615,7 +616,8 @@
 		   Sdprintf("Added %s/%d\n",
 			    stringAtom(valueFunctor(functor)->name),
 			    arityFunctor(functor)));
-	pushWorkAgenda(agenda, arity, f->arguments);
+	if ( !pushWorkAgenda(agenda, arity, f->arguments) )
+	  return FALSE;
 	continue;
       }
       default:
@@ -686,6 +688,7 @@
   size_t size;
   size_t rsize = SIZERECORD(flags);
   term_agenda agenda;
+  int rc;
 
   DEBUG(CHK_SECURE, checkData(valTermRef(t)));
 
@@ -698,30 +701,34 @@
   info.lock = !(info.external || (flags&R_NOLOCK));
 
   initTermAgenda(&agenda, 1, valTermRef(t));
-  compile_term_to_heap(&agenda, &info PASS_LD);
+  rc = compile_term_to_heap(&agenda, &info PASS_LD);
   clearTermAgenda(&agenda);
   restoreVars(&info);
   unvisit(PASS_LD1);
 
-  size = rsize + sizeOfBuffer(&info.code);
-  if ( allocate )
-    record = (*allocate)(closure, size);
-  else
-    record = PL_malloc_atomic_unmanaged(size);
-
-  if ( record )
-  {
+  if ( rc )
+  { size = rsize + sizeOfBuffer(&info.code);
+    if ( allocate )
+      record = (*allocate)(closure, size);
+    else
+      record = PL_malloc_atomic_unmanaged(size);
+
+    if ( record )
+    {
 #ifdef REC_MAGIC
-    record->magic = REC_MAGIC;
+      record->magic = REC_MAGIC;
 #endif
-    record->gsize = (unsigned int)info.size; /* only 28-bit */
-    record->nvars = info.nvars;
-    record->size  = (int)size;
-    record->flags = flags;
-    if ( flags & R_DUPLICATE )
-    { record->references = 1;
-    }
-    memcpy(addPointer(record, rsize), info.code.base, sizeOfBuffer(&info.code));
+      record->gsize = (unsigned int)info.size; /* only 28-bit */
+      record->nvars = info.nvars;
+      record->size  = (int)size;
+      record->flags = flags;
+      if ( flags & R_DUPLICATE )
+      { record->references = 1;
+      }
+      memcpy(addPointer(record, rsize), info.code.base, sizeOfBuffer(&info.code));
+    }
+  } else
+  { record = NULL;
   }
   discardBuffer(&info.code);
 
@@ -750,7 +757,6 @@
 #define	REC_GROUND  0x10		/* Record is ground */
 #define	REC_VMASK   0xe0		/* Version mask */
 #define REC_VSHIFT     5		/* shift for version mask */
-#define	REC_VERSION 0x03		/* Version id */
 
 #define REC_SZMASK  (REC_32|REC_64)	/* SIZE_MASK */
 
@@ -760,7 +766,7 @@
 #define REC_SZ REC_32
 #endif
 
-#define REC_HDR		(REC_SZ|(REC_VERSION<<REC_VSHIFT))
+#define REC_HDR		(REC_SZ|(PL_REC_VERSION<<REC_VSHIFT))
 #define REC_COMPAT(m)	(((m)&(REC_VMASK|REC_SZMASK)) == REC_HDR)
 
 typedef struct record_data
@@ -1844,7 +1850,7 @@
       if ( !b.version_map )
       { Sdprintf("PL_recorded_external(): "
 		 "Incompatible version (%d, current %d)\n",
-		 save_version, REC_VERSION);
+		 save_version, PL_REC_VERSION);
 	fail;
       }
     }
diff --git a/src/pl-setup.c b/src/pl-setup.c
index 4a27674..b80b924 100644
--- a/src/pl-setup.c
+++ b/src/pl-setup.c
@@ -141,6 +141,7 @@
 #ifdef O_LOCALE
   initLocale();
 #endif
+  setABIVersionPrologFlag();
   GD->io_initialised = TRUE;
   GD->clauses.cgc_space_factor  = 8;
   GD->clauses.cgc_stack_factor  = 0.03;
diff --git a/src/pl-string.c b/src/pl-string.c
index f23b796..d856a18 100644
--- a/src/pl-string.c
+++ b/src/pl-string.c
@@ -282,7 +282,7 @@
 { PRED_LD
   PL_chars_t input, sep, pad;
   int rc = FALSE;
-  int flags = CVT_ATOM|CVT_STRING|CVT_LIST|CVT_EXCEPTION;
+  int flags = CVT_ATOM|CVT_STRING|CVT_LIST|CVT_EXCEPTION|BUF_NORING;
 
   input.storage = PL_CHARS_VIRGIN;
     sep.storage = PL_CHARS_VIRGIN;
diff --git a/src/pl-tabling.c b/src/pl-tabling.c
index af2b17d..388c355 100644
--- a/src/pl-tabling.c
+++ b/src/pl-tabling.c
@@ -138,6 +138,7 @@
 static int	add_answer_count_restraint(void);
 static int	add_radial_restraint(void);
 static int	tbl_wl_tripwire(worklist *wl, atom_t action, atom_t wire);
+static int	tbl_pred_tripwire(Definition def, atom_t action, atom_t wire);
 
 #define WL_IS_SPECIAL(wl)  (((intptr_t)(wl)) & 0x1)
 #define WL_IS_WORKLIST(wl) ((wl) && !WL_IS_SPECIAL(wl))
@@ -2198,7 +2199,11 @@
 
     for(; pp < ep; pp++)
     { Word ap = *pp;
-      *p++ = makeRefG(ap);
+
+      if ( isVar(*ap) )
+	*p++ = makeRefG(ap);
+      else
+	*p++ = *ap;
     }
 
     if ( PL_is_variable(ret) )
@@ -2237,7 +2242,22 @@
 #define AT_SHARED		0x0004	/* find a shared table */
 #define AT_PRIVATE		0x0008	/* find a private table */
 #define AT_NOCLAIM		0x0010	/* Do not claim ownership */
+
+
+#define AT_ABSTRACT		0x0020	/* subgoal_abstract(N) tabling */
 #define AT_SCOPE_MASK (AT_SHARED|AT_PRIVATE)
+
+static inline size_t
+pred_max_table_subgoal_size(const Definition def ARG_LD)
+{ size_t limit;
+
+  limit = def->tabling ? def->tabling->subgoal_abstract : (size_t)-1;
+  if ( limit == (size_t)-1 )
+    limit = LD->tabling.restraint.max_table_subgoal_size;
+
+  return limit;
+}
+
 
 static trie *
 get_answer_table(Definition def, term_t t, term_t ret, atom_t *clrefp,
@@ -2250,6 +2270,7 @@
   tmp_buffer vars;
   mark m;
   int shared;
+  size_abstract sa = {.from_depth = 2, .size = (size_t)-1};
 
 #ifdef O_PLMT
   if ( (flags & AT_SCOPE_MASK) )
@@ -2271,16 +2292,39 @@
   shared = FALSE;
 #endif
 
+  if ( def )			/* otherwise we don't need it anyway */
+    sa.size = pred_max_table_subgoal_size(def PASS_LD);
   variants = variant_table(shared PASS_LD);
   initBuffer(&vars);
 
 retry:
   Mark(m);
   v = valTermRef(t);
-  rc = trie_lookup(variants, NULL, &node, v, (flags&AT_CREATE), &vars PASS_LD);
-
-  if ( rc == TRUE )
-  { if ( node->value )
+  rc = trie_lookup_abstract(variants, NULL, &node, v, (flags&AT_CREATE),
+			    &sa, &vars PASS_LD);
+
+  if ( rc > 0 )
+  { if ( rc == TRIE_ABSTRACTED )
+    { atom_t action = LD->tabling.restraint.max_table_subgoal_size_action;
+
+      DEBUG(MSG_TABLING_RESTRAINT,
+	    Sdprintf("Trapped by subgoal size restraint\n"));
+      if ( action == ATOM_abstract && !(flags&AT_ABSTRACT) )
+	action = ATOM_error;
+
+      if ( action != ATOM_abstract )
+      { if ( tbl_pred_tripwire(def, action, ATOM_max_table_subgoal_size) )
+	{ sa.size = (size_t)-1;
+	  emptyBuffer(&vars);
+	  goto retry;
+	} else
+	{ discardBuffer(&vars);
+	  return NULL;
+	}
+      }
+    }
+
+    if ( node->value )
     { atrie = symbol_trie(node->value);
     } else if ( (flags&AT_CREATE) )
     { atom_t symb;
@@ -3046,9 +3090,12 @@
 { if ( !wrapper )
     wrapper = PL_new_term_ref();
 
-  if ( unify_trie_term(atrie->data.variant, NULL, wrapper PASS_LD) )
-  { int flags = true(atrie, TRIE_ISSHARED) ? AT_SHARED : AT_PRIVATE;
-    return ( get_answer_table(NULL, wrapper, skeleton,
+  if ( atrie->data.variant && wrapper &&
+       unify_trie_term(atrie->data.variant, NULL, wrapper PASS_LD) )
+  { worklist *wl = atrie->data.worklist;
+    Definition def = WL_IS_WORKLIST(wl) ? wl->predicate : NULL;
+    int flags = true(atrie, TRIE_ISSHARED) ? AT_SHARED : AT_PRIVATE;
+    return ( get_answer_table(def, wrapper, skeleton,
 			      NULL, flags|AT_NOCLAIM PASS_LD) != NULL);
   }
 
@@ -3291,7 +3338,7 @@
   { Word kp;
     trie_node *node;
     atom_t action;
-    size_t abstract;
+    size_abstract sa = {.from_depth = 2};
     int rc;
 
 #ifdef O_PLMT
@@ -3302,9 +3349,9 @@
     if ( true(wl->table, TRIE_ISMAP) )
       return wkl_mode_add_answer(wl, A2, A3 PASS_LD);
 
-    abstract = pred_max_table_answer_size(wl->predicate PASS_LD);
+    sa.size = pred_max_table_answer_size(wl->predicate PASS_LD);
     rc = trie_lookup_abstract(wl->table, NULL, &node, kp,
-			      TRUE, abstract, NULL PASS_LD);
+			      TRUE, &sa, NULL PASS_LD);
     if ( rc > 0 )				/* ok or abstracted */
     { idg_node *idg;
 
@@ -4201,8 +4248,8 @@
  */
 
 static int
-tbl_variant_table(term_t closure, term_t variant, term_t Trie, term_t status, term_t ret,
-		  int flags ARG_LD)
+tbl_variant_table(term_t closure, term_t variant, term_t Trie,
+		  term_t abstract, term_t status, term_t ret, int flags ARG_LD)
 { trie *atrie;
   Definition def = NULL;
   atom_t clref = 0;
@@ -4231,7 +4278,21 @@
 PRED_IMPL("$tbl_variant_table", 5, tbl_variant_table, 0)
 { PRED_LD
 
-  return tbl_variant_table(A1, A2, A3, A4, A5, AT_CREATE PASS_LD);
+  return tbl_variant_table(A1, A2, A3, 0, A4, A5, AT_CREATE PASS_LD);
+}
+
+
+/** '$tbl_abstract_table'(+Closure, :Wrapper, -Trie,
+			  -Abstract, -Status, -Skeleton)
+
+Abstract is one of `0` or a generalization of Wrapper
+*/
+
+static
+PRED_IMPL("$tbl_abstract_table", 6, tbl_abstract_table, 0)
+{ PRED_LD
+
+  return tbl_variant_table(A1, A2, A3, A4, A5, A6, AT_CREATE|AT_ABSTRACT PASS_LD);
 }
 
 
@@ -4239,7 +4300,7 @@
 PRED_IMPL("$tbl_moded_variant_table", 5, tbl_moded_variant_table, 0)
 { PRED_LD
 
-  return tbl_variant_table(A1, A2, A3, A4, A5, AT_CREATE|AT_MODED PASS_LD);
+  return tbl_variant_table(A1, A2, A3, 0, A4, A5, AT_CREATE|AT_MODED PASS_LD);
 }
 
 
@@ -6491,6 +6552,26 @@
 	   PL_put_atom(av+0, wire) &&
 	   PL_put_atom(av+1, action) &&
 	   PL_put_atom(av+2, trie_symbol(wl->table)) &&
+	   PL_call_predicate(NULL, PL_Q_PASS_EXCEPTION, pred, av) );
+}
+
+
+static int
+tbl_pred_tripwire(Definition def, atom_t action, atom_t wire)
+{ GET_LD
+  static predicate_t pred = NULL;
+  term_t av;
+
+  if ( !pred )
+    pred = PL_predicate("tripwire", 3, "$tabling");
+
+  DEBUG(MSG_TABLING_RESTRAINT,
+	Sdprintf("Calling %s\n", procedureName(pred)));
+
+  return ( (av = PL_new_term_refs(3)) &&
+	   PL_put_atom(av+0, wire) &&
+	   PL_put_atom(av+1, action) &&
+	   unify_definition(MODULE_user, av+2, def, 0, GP_QUALIFY) &&
 	   PL_call_predicate(NULL, PL_Q_PASS_EXCEPTION, pred, av) );
 }
 
@@ -6815,6 +6896,7 @@
   PRED_DEF("$tbl_wkl_answer_trie",	2, tbl_wkl_answer_trie,      0)
   PRED_DEF("$tbl_wkl_work",		6, tbl_wkl_work,          NDET)
   PRED_DEF("$tbl_variant_table",	5, tbl_variant_table,	     0)
+  PRED_DEF("$tbl_abstract_table",       6, tbl_abstract_table,       0)
   PRED_DEF("$tbl_existing_variant_table", 5, tbl_existing_variant_table, 0)
   PRED_DEF("$tbl_moded_variant_table",	5, tbl_moded_variant_table,  0)
 #ifdef O_PLMT
diff --git a/src/pl-thread.c b/src/pl-thread.c
index 9f9338b..5c080ff 100644
--- a/src/pl-thread.c
+++ b/src/pl-thread.c
@@ -1861,6 +1861,7 @@
     ldnew->prolog_flag.table	  = copyHTable(ldold->prolog_flag.table);
     PL_UNLOCK(L_PLFLAG);
   }
+  ldnew->tabling.restraint        = ldold->tabling.restraint;
   if ( !ldnew->thread.info->debug )
   { ldnew->_debugstatus.tracing   = FALSE;
     ldnew->_debugstatus.debugging = DBG_OFF;
diff --git a/src/pl-trie.c b/src/pl-trie.c
index c0c8c8e..7294d58 100644
--- a/src/pl-trie.c
+++ b/src/pl-trie.c
@@ -666,17 +666,21 @@
 
 int
 trie_lookup_abstract(trie *trie, trie_node *node, trie_node **nodep,
-		     Word k, int add, size_t abstract, TmpBuffer vars ARG_LD)
+		     Word k, int add, size_abstract *abstract,
+		     TmpBuffer vars ARG_LD)
 { term_agenda_P agenda;
   size_t var_number = 0;
   int rc = TRUE;
   size_t compounds = 0;
   tmp_buffer varb;
+  size_abstract sa = {.from_depth = 1, .size = (size_t)-1};
   size_t aleft = (size_t)-1;
 
   TRIE_STAT_INC(trie, lookups);
   if ( !node )
     node = &trie->root;
+  if ( abstract )
+    sa = *abstract;
 
   initTermAgenda_P(&agenda, 1, k);
   while( node )
@@ -696,20 +700,25 @@
 	break;				/* finished toplevel */
     }
 
-    if ( compounds == 1 )
-      aleft = abstract;
+    if ( compounds == sa.from_depth )
+      aleft = sa.size;
 
     w = *p;
     switch( tag(w) )
     { case TAG_VAR:
 	if ( isVar(w) )
-	{ add_var:
+	{ word w2;
+
+	add_var:
 	  if ( var_number++ == 0 && !vars )
 	  { vars = &varb;
 	    initBuffer(vars);
 	  }
 	  addBuffer(vars, p, Word);
-	  *p = w = ((((word)var_number))<<LMASK_BITS)|TAG_VAR;
+	  w2 = ((((word)var_number))<<LMASK_BITS)|TAG_VAR;
+	  if ( tag(w) == TAG_VAR )
+	    *p = w2;
+	  w = w2;
 	}
         node = follow_node(trie, node, w, add PASS_LD);
 	break;
@@ -762,7 +771,8 @@
 
     for(; pp < ep; pp++)
     { Word vp = *pp;
-      setVar(*vp);
+      if ( tag(*vp) == TAG_VAR )
+	setVar(*vp);
     }
     if ( vars == &varb )
       discardBuffer(vars);
@@ -1302,7 +1312,7 @@
 
 static int
 trie_insert(term_t Trie, term_t Key, term_t Value, trie_node **nodep,
-	    int update, size_t abstract ARG_LD)
+	    int update, size_abstract *abstract ARG_LD)
 { trie *trie;
 
   if ( get_trie(Trie, &trie) )
@@ -1384,7 +1394,7 @@
 PRED_IMPL("trie_insert", 3, trie_insert, 0)
 { PRED_LD
 
-  return trie_insert(A1, A2, A3, NULL, FALSE, (size_t)-1 PASS_LD);
+  return trie_insert(A1, A2, A3, NULL, FALSE, NULL PASS_LD);
 }
 
 /**
@@ -1400,7 +1410,7 @@
 PRED_IMPL("trie_insert", 2, trie_insert, 0)
 { PRED_LD
 
-  return trie_insert(A1, A2, 0, NULL, FALSE, (size_t)-1 PASS_LD);
+  return trie_insert(A1, A2, 0, NULL, FALSE, NULL PASS_LD);
 }
 
 
@@ -1413,10 +1423,10 @@
 static
 PRED_IMPL("$trie_insert_abstract", 3, trie_insert_abstract, 0)
 { PRED_LD
-  size_t size;
-
-  return ( PL_get_size_ex(A2, &size ) &&
-	   trie_insert(A1, A3, 0, NULL, FALSE, size PASS_LD) > 0 );
+  size_abstract sa = {.from_depth = 1};
+
+  return ( PL_get_size_ex(A2, &sa.size ) &&
+	   trie_insert(A1, A3, 0, NULL, FALSE, &sa PASS_LD) > 0 );
 }
 
 
@@ -1433,7 +1443,7 @@
 PRED_IMPL("trie_update", 3, trie_update, 0)
 { PRED_LD
 
-  return trie_insert(A1, A2, A3, NULL, TRUE, (size_t)-1 PASS_LD);
+  return trie_insert(A1, A2, A3, NULL, TRUE, NULL PASS_LD);
 }
 
 
@@ -1453,7 +1463,7 @@
 { PRED_LD
   trie_node *node;
 
-  return ( trie_insert(A1, A2, A3, &node, FALSE, (size_t)-1 PASS_LD) &&
+  return ( trie_insert(A1, A2, A3, &node, FALSE, NULL PASS_LD) &&
 	   PL_unify_pointer(A4, node) );
 }
 
diff --git a/src/pl-trie.h b/src/pl-trie.h
index a104306..f4a3757 100644
--- a/src/pl-trie.h
+++ b/src/pl-trie.h
@@ -132,6 +132,11 @@
     struct idg_node *IDG;		/* Node in the IDG graph */
   } data;
 } trie;
+
+typedef struct size_abstract
+{ int		from_depth;		/* start below depth */
+  size_t	size;			/* limit each term to size */
+} size_abstract;
 
 #define acquire_trie(t) ATOMIC_INC(&(t)->references)
 #define release_trie(t) do { if ( ATOMIC_DEC(&(t)->references) == 0 ) \
@@ -169,7 +174,7 @@
 				term_t term ARG_LD);
 COMMON(int)	trie_lookup_abstract(trie *trie,
 				     trie_node *root, trie_node **nodep, Word k,
-				     int add, size_t abstract,
+				     int add, size_abstract *abstract,
 				     TmpBuffer vars ARG_LD);
 COMMON(int)	trie_error(int rc, term_t culprit);
 COMMON(int)	trie_trie_error(int rc, trie *trie);
@@ -196,7 +201,7 @@
 trie_lookup(trie *trie, trie_node *node, trie_node **nodep,
 	    Word k, int add, TmpBuffer vars ARG_LD)
 { return trie_lookup_abstract(trie, node, nodep, k, add,
-			      (size_t)-1, vars PASS_LD);
+			      NULL, vars PASS_LD);
 }
 
 #endif /*_PL_TRIE_H*/
diff --git a/src/pl-vmi.c b/src/pl-vmi.c
index 4471326..8bf08a5 100644
--- a/src/pl-vmi.c
+++ b/src/pl-vmi.c
@@ -4137,6 +4137,7 @@
       FR->clause = NULL;
       goto exit_checking_wakeup;
     case FALSE:
+      FR->clause = NULL;
       if ( exception_term )
 	THROW_EXCEPTION;
       DEBUG(CHK_SECURE, assert(BFR->value.PC == PC));
diff --git a/src/pl-wic.c b/src/pl-wic.c
index 2a2f870..91e9c64 100644
--- a/src/pl-wic.c
+++ b/src/pl-wic.c
@@ -175,8 +175,6 @@
 first. The last byte has its 0x80 mask set.
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
-#define LOADVERSION 67			/* load all versions later >= X */
-#define VERSION     67			/* save version number */
 #define QLFMAGICNUM 0x716c7374		/* "qlst" on little-endian machine */
 
 #define XR_REF		0		/* reference to previous */
@@ -2823,7 +2821,7 @@
 { IOSTREAM *fd = state->wicFd;
 
   putMagic(saveMagic, fd);
-  putInt64(VERSION, fd);
+  putInt64(PL_QLF_VERSION, fd);
   putInt64(VM_SIGNATURE, fd);
   if ( systemDefaults.home )
     putString(systemDefaults.home, STR_NOLEN, fd);
@@ -3045,8 +3043,8 @@
   if ( cversion )
   { int vm_signature;
 
-    if ( !PL_unify_integer(cversion, VERSION) ||
-	 !PL_unify_integer(minload, LOADVERSION) ||
+    if ( !PL_unify_integer(cversion, PL_QLF_VERSION) ||
+	 !PL_unify_integer(minload, PL_QLF_LOADVERSION) ||
 	 !PL_unify_integer(csig, (int)VM_SIGNATURE) )
       goto out;
 
@@ -3176,7 +3174,7 @@
   initSourceMarks(state);
 
   putMagic(qlfMagic, state->wicFd);
-  putInt64(VERSION, state->wicFd);
+  putInt64(PL_QLF_VERSION, state->wicFd);
   putInt64(VM_SIGNATURE, state->wicFd);
 
   putString(absname, STR_NOLEN, state->wicFd);
@@ -3325,9 +3323,9 @@
 
   if ( !qlfVersion(state, magic, &lversion) )
     return FALSE;
-  if ( lversion < LOADVERSION )
+  if ( lversion < PL_QLF_LOADVERSION )
     return qlfError(state, "incompatible version (file: %d, Prolog: %d)",
-		    lversion, VERSION);
+		    lversion, PL_QLF_VERSION);
   state->saved_version = lversion;
 
   vm_signature = getInt(state->wicFd);
diff --git a/src/pl-wrap.c b/src/pl-wrap.c
index a3855b9..9f441ae 100644
--- a/src/pl-wrap.c
+++ b/src/pl-wrap.c
@@ -361,6 +361,54 @@
 }
 
 
+/** '$wrapped_implementation'(:Goal, +Name, -Wrapped)
+ *
+ *  Calling Wrapped calls the predicate referenced by Goal as seen
+ *  from the wrapper Name.
+ */
+
+static
+PRED_IMPL("$wrapped_implementation", 3, wrapped_implementation,
+	  PL_FA_TRANSPARENT)
+{ PRED_LD
+  Procedure proc;
+  atom_t wname;
+  Code codes;
+  term_t head = PL_new_term_ref();
+
+  if ( !PL_get_atom_ex(A2, &wname) ||
+       !get_procedure(A1, &proc, head, GP_RESOLVE) )
+    return FALSE;
+
+  if ( (codes = find_wrapper(proc->definition, wname)) )
+  { atom_t aref = codes[2];
+    size_t arity = proc->definition->functor->arity;
+
+    if ( arity > 0 )
+    { Word p;
+      term_t impl = PL_new_term_ref();
+
+      if ( (p=allocGlobal(1+arity)) )
+      { Word a = valTermRef(head);
+	size_t i;
+
+	deRef(a);
+	a = valueTerm(*a)->arguments;
+	p[0] = lookupFunctorDef(aref, arity);
+	for(i=0; i<arity; i++)
+	  p[i+1] = linkVal(&a[i]);
+	*valTermRef(impl) = consPtr(p, TAG_COMPOUND|STG_GLOBAL);
+	return PL_unify(A3, impl);
+      }
+    } else
+    { return PL_unify_atom(A3, aref);
+    }
+  }
+
+  return FALSE;
+}
+
+
 /**
  * unwrap_predicate(:Head, ?Name) is semidet.
  *
@@ -426,9 +474,12 @@
 		 *      PUBLISH PREDICATES	*
 		 *******************************/
 
+#define META PL_FA_TRANSPARENT
+
 BeginPredDefs(wrap)
-  PRED_DEF("$c_wrap_predicate",  5, c_wrap_predicate,  PL_FA_TRANSPARENT)
-  PRED_DEF("unwrap_predicate",   2, uwrap_predicate,   PL_FA_TRANSPARENT)
-  PRED_DEF("$wrapped_predicate", 2, wrapped_predicate, PL_FA_TRANSPARENT)
-  PRED_DEF("$closure_predicate", 2, closure_predicate, 0)
+  PRED_DEF("$c_wrap_predicate",	      5, c_wrap_predicate,       META)
+  PRED_DEF("unwrap_predicate",        2, uwrap_predicate,        META)
+  PRED_DEF("$wrapped_predicate",      2, wrapped_predicate,      META)
+  PRED_DEF("$wrapped_implementation", 3, wrapped_implementation, META)
+  PRED_DEF("$closure_predicate",      2, closure_predicate,      0)
 EndPredDefs
diff --git a/src/pl-write.c b/src/pl-write.c
index 0175d54..0cdce04 100644
--- a/src/pl-write.c
+++ b/src/pl-write.c
@@ -817,9 +817,7 @@
   PL_chars_t txt;
   int rc = TRUE;
 
-  PL_get_text(t, &txt, CVT_STRING);
-  if ( txt.storage != PL_CHARS_LOCAL )
-    PL_save_text(&txt, BUF_MALLOC);
+  PL_get_text(t, &txt, CVT_STRING|BUF_NORING);
 
   if ( true(options, PL_WRT_QUOTED) )
   { int quote;
diff --git a/src/swipl.1.in b/src/swipl.1.in
index 5a16f72..15d1de5 100644
--- a/src/swipl.1.in
+++ b/src/swipl.1.in
@@ -68,6 +68,10 @@
 .B \-\-version
 Displays version and architecture information.
 .TP
+.B \-\-abi_version
+Displays ABI version key.  This key indicates binary compatibility of
+various interfaces.
+.TP
 .B \-\-arch
 Prints the architecture identifier.
 .TP