listprologinterpreter/listprologinterpreter1listrecursion4.pl

:- use_module(library(date)).

:- dynamic debug/1.
:- dynamic cut/1.
:- dynamic leash1/1.
:- dynamic types/1.
:- dynamic typestatements/1.
:- dynamic modestatements/1.
:- dynamic sys/1.
:- dynamic equals4/1.
:- dynamic query_box_n/1.
:- dynamic save_debug/1.
:- dynamic saved_debug/1.

:- dynamic lang/1.

:- dynamic retry_back/1.
:- dynamic retry_back_stack/1.
:- dynamic retry_back_stack_n/1.
:- dynamic cumulative_or_current_text/1.
:- dynamic number_of_current_text/1.
:- dynamic html_api_maker_or_terminal/1.

:- dynamic occurs_check/1.

%:- dynamic assertz_functions/1.

command_n_sols(10).

main3:-
time((
test_all00("en",off,NTotal1,Score1),
test_all00("en2",off,NTotal2,Score2),
test_all_bt00("en2",off,NTotal3,Score3),
writeln(test_all00("en",off,NTotal1,Score1)),
writeln(test_all00("en2",off,NTotal2,Score2)),
writeln(test_all_bt00("en2",off,NTotal3,Score3))
)).

/** List Prolog Interpreter **/

interpret(Debug,Query,Functions1,Result) :-
	international_interpret([lang,"en"],
	Debug,Query,Functions1,Result).

international_interpret([lang,Lang],Debug,Query,Functions1,Result) :-
	retractall(lang(_)),
 	assertz(lang(Lang)),
	interpret_1(Debug,Query,Functions1,Result).
	
international_interpret([lang,Lang],Debug,Query,TypeStatements,ModeStatements,Functions1,Result) :-
	retractall(lang(_)),
 	assertz(lang(Lang)),
	interpret_1(Debug,Query,TypeStatements,ModeStatements,Functions1,Result).


interpret_1(Debug,Query,Functions1,Result) :-
	retractall(types(_)),
 	assertz(types(off)),
interpret11(Debug,Query,Functions1,Result).

interpret_1(Debug,Query,TypeStatements,ModeStatements,Functions1,Result) :-
	retractall(types(_)),
 	assertz(types(on)),
	retractall(typestatements(_)),
	
%writeln(here1),
	findall([A,C],(member([A,B],TypeStatements),expand_types(B,[],C)),TypeStatements1),
 	assertz(typestatements(TypeStatements1)),
	retractall(modestatements(_)),
 	assertz(modestatements(ModeStatements)),
interpret11(Debug,Query,Functions1,Result).

interpret11(Debug,Query,Functions,Result) :-
	((not(lang(_Lang1))
	%var(Lang1)
	)->
	(retractall(lang(_)),
 	assertz(lang("en")));
	true),
	load_lang_db,

	query_box(Query,Query1,Functions,Functions1),

%trace,
%writeln1(query_box(Query,Query1,Functions,Functions1)),
%%writeln1([i1]),
	%%writeln1(convert_to_grammar_part1(Functions1,[],Functions2,_)),
	convert_to_grammar_part1(Functions1,[],Functions2,_),
	
	%insert_cuts(Functions2a,Functions2),
	%retractall(assertz_functions(_)),
 	%assertz(assertz_functions(Functions2)),
	%trace,
	%writeln1(convert_to_grammar_part1(Functions1,[],Functions2,_)),
	%writeln1(Functions2),
	%%pp3(Functions2),
	%%writeln1(interpret1(Debug,Query,Functions2,Functions2,Result)),
	
	%writeln1(interpret1(Debug,Query1,Functions2,Functions2,Result1)),
	findall(Result1,interpret1(Debug,Query1,Functions2,Functions2,Result1),Result).
	
query_box(Query,Query1,Functions,Functions1) :-
get_lang_word("n",Dbw_n),

	collect_arguments_body2([Query],[],Arguments1),
	msort(Arguments1,Arguments),
	%trace,
	find_query_box_n(Query_box_n),
	(Arguments=[]->
	(Query1=[[Dbw_n,Query_box_n],[]],
	append(
	[
        [[Dbw_n,Query_box_n],[],":-",
        [
                Query
        ]]
	]
	,        
	Functions,Functions1));
	(Query1=[[Dbw_n,Query_box_n],Arguments],
	append(
	[
        [[Dbw_n,Query_box_n],Arguments,":-",
        [
                Query%,%[[n,trace2]]
        ]]
	]
	,        
	Functions,Functions1))).

interpret1(Debug,Query,Functions1,Functions2,Result) :-
%%writeln1([i11]),
	retractall(debug(_)),
 	assertz(debug(Debug)),
   retractall(cut(_)),
   assertz(cut(off)),
	retractall(leash1(_)),
   assertz(leash1(off)), %% Should normally be off
  	retractall(sys(_)),
 	assertz(sys(1)),
	(not(equals4(_Equals4))->(retractall(equals4(_)),assertz(equals4(on)));true),%equals4(Equals4)),
	%trace,
	(not(save_debug(_))->(retractall(save_debug(_)),assertz(save_debug(off)));true),	  	

	(not(occurs_check(_))->(retractall(occurs_check(_)),assertz(occurs_check(off)));true),


retractall(retry_back(_)),
	  	retractall(retry_back_stack(_)),
	  	retractall(retry_back_stack_n(_)),
	  	retractall(cumulative_or_current_text(_)),
	  	retractall(number_of_current_text(_)),

 	assertz(retry_back(off)), % on - retry/back mode options available in trace mode
 	assertz(retry_back_stack([])), % on - retry/back mode options available in trace mode
 assertz(retry_back_stack_n(0)),
 assertz(cumulative_or_current_text(current)),
 assertz(number_of_current_text(1)),

	%%writeln1(member1(Query,Functions1,Functions2,Result)),
	member1(Query,Functions1,Functions2,Result).
%%member1([_,R],_,[],R).
%%member1(_,_,[],[]).
member1(_Query,_,_,[],_) :- %%writeln1(["The query",Query,"matches no predicates."]),
fail.
member1(Query,Functions,Functions2,Vars8) :-
%%writeln1([m1]),
	(cut(off)->(
        (Query=[Function,Arguments1],
	(Functions2=[[Function,Arguments2,":-",Body]|_Functions3]),
	length(Arguments1,Length),
	length(Arguments2,Length),

	debug_call(Skip,[Function,Arguments1]),

((
checktypes_inputs(Function,Arguments1),
        
        %%writeln1(checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs)),
        %trace,
        %(Function=[n,query_box_1]->true;trace),
        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),
        %notrace,
        %%->ca2 
%writeln1([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
	interpretbody(Functions,Functions2,Vars1,Vars2,Body,true),
	updatevars(FirstArgs,Vars2,[],Result),
	%writeln1(updatevars(FirstArgs,Vars2,[],Result)),
	%trace,
	unique1(Result,[],Vars8)
	%writeln1(unique1(Result,[],Vars8))%,notrace
	)->debug_fail_fail(Skip);debug_fail(Skip,[Function,Arguments1]))
	,
			findresult3(Arguments1,Vars8,[],Result2),
			debug_exit(Skip,[Function,Result2]),

	%trace,
	%%writeln1(updatevars(FirstArgs,Vars2,[],Result)),
	%trace,
	
	%notrace,
        %%reverse(Result,[],Vars7),
	((true->%not(Result=[])->
        %%Result=[Var71|Vars72],
        %%writeln1(unique1(Result,[],Vars8)),
        (true
%%writeln1(["FirstArgs",FirstArgs,"Vars",Vars2,"Result",Result,"Vars7",Vars7,"Vars72",Vars72,"Var71",Var71,"Vars8",Vars8]),
%%writeln1(["Vars8",Vars8]),
	%%writeln1(findresult3(Arguments1,Vars8,[],Result2)),
	%trace,
	
%writeln1([findresult3,"Arguments1",Arguments1,"Vars8",Vars8,"Result2",Result2])
	);(
%%writeln1(here1),
	Vars8=[],Result2=[]))),
%%writeln1(["Arguments1",Arguments1,"Vars2",Vars2,"Result",Result]),
		%trace,
		        checktypes(Function,Result2)

	)
	;
	(%%Query=[Function,_Arguments1],
	%%Functions2=[[Function,_Arguments2,":-",_Body]|Functions3], %% make like previous trunk?
	member11(Query,Functions,Functions2,Vars8))
	);(turncut(off),fail%%,Result=[]
	)).
member11(Query,Functions,Functions2,Result) :-
%%writeln1([m11]),
%%writeln1(["Query",Query,"Functions",Functions,"Functions2",Functions2,"Result",Result]),
	(cut(off)->(
        (Query=[Function],
        (Functions2=[[Function,":-",Body]|_Functions3]),
        debug_call(Skip,[Function]),
	Result=[],
        (interpretbody(Functions,Functions2,[],_Vars2,Body,true)->debug_fail_fail(Skip);debug_fail(Skip,[Function])),
    debug_exit(Skip,[Function])
	);
	(%%Query=[Function],
	%%Functions2=[[Function]|Functions3],
	member12(Query,Functions,Functions2,Result))
	);(turncut(off),fail)).
member12(Query,Functions,Functions2,Vars8) :-
%%writeln1([m12]),
	(cut(off)->(
        (Query=[Function,Arguments1],
        (Functions2=[[Function,Arguments2]|_Functions3]),
        length(Arguments1,Length),
        length(Arguments2,Length),
        
debug_call(Skip,[Function,Arguments1]),
        
        ((
        checktypes_inputs(Function,Arguments1),

        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),
        

%%writeln1([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
	updatevars(FirstArgs,Vars1,[],Result),
        %%reverse(Result,[],Vars7),
        ((%not
        true->%(Result=[])->
        %%Result=[Var71|Vars72],
        (%trace,
        unique1(Result,[],Vars8),%notrace,
        findresult3(Arguments1,Vars8,[],Result2)
        );(
%%writeln1(here2),
	Vars8=[],Result2=[]))))->debug_fail_fail(Skip);
	debug_fail(Skip,[Function,Arguments1])),
	
   debug_exit(Skip,[Function,Result2]),
	checktypes(Function,Result2)

	);
	(%%Query=[Function,_Arguments1],
	%%Functions2=[[Function,_Arguments2]|Functions3],
	member13(Query,Functions,Functions2,Vars8))
	);(turncut(off),fail)).
member13(Query,Functions,Functions2,Result) :-
%%writeln1([m13]),
	(cut(off)->(
        (Query=[Function],
        (Functions2=[[Function]|_Functions3]),
        debug_call(Skip,[Function]),
	Result=[],
        %%interpretbody(Functions,[],_Vars2,Body,true),
        debug_exit(Skip,[Function])
	);%%->true;
	(%%Query=[Function],
	Functions2=[_Function|Functions3],
	member1(Query,Functions,Functions3,Result))
	);(turncut(off),fail)).
interpret2(Query,Functions1,Functions2,Result) :-
%%writeln1(i2),
%%writeln1(["%%interpret2 Query",Query,"Functions1",Functions1,"Functions2",Functions2]),
        member2(Query,Functions1,Functions2,Result).
%%member2([_,R],_,[],R).
%%member2(_,_,[],[]).
member2(_Query,_,_,[],_) :- %%writeln1(["The query",Query,"matches no predicates."]),
fail.
member2(Query,Functions,Functions2,Vars8) :-
%writeln1(member2(Query,Functions,Functions2,Vars8)),
%%writeln1([m2]),
	(cut(off)->(
        (%trace,
        Query=[Function,Arguments1],
        (Functions2=[[Function,Arguments2,":-",Body]|_Functions3]),
        length(Arguments1,Length),
        length(Arguments2,Length),

debug_call(Skip,[Function,Arguments1]),

        ((
        checktypes_inputs(Function,Arguments1),

        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),

        
%%writeln1([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
        interpretbody(Functions,Functions2,Vars1,Vars2,Body,true),
        updatevars(FirstArgs,Vars2,[],Result),
        %trace,
        unique1(Result,[],Vars8)%,notrace
        )->debug_fail_fail(Skip);
        debug_fail(Skip,[Function,Arguments1])), %%**arg2 change
%%writeln1(["Functions",Functions,"Functions2",Functions2,"Vars1",Vars1,"Vars2",Vars2,"Body",Body]),
        %trace,
        
        %%reverse(Result,[],Vars7),
        (true->%not(Result=[])->
        %%Result=[Var71|Vars72],
        (true,
        findresult3(Arguments1,Vars8,[],Result2)
%%writeln1(["Vars2",Vars2,"Result",Result]),
        );(
	%%writeln1(here3),
	Vars8=[],Result2=[])),
   debug_exit(Skip,[Function,Result2]),
   checktypes(Function,Result2)

	);%%->true;
	(%%Query=[Function,_Arguments1],
	%%Functions2=[[Function,_Arguments2,":-",_Body]|Functions3],
	member21(Query,Functions,Functions2,Vars8))
	);(turncut(off),fail)).
member21(Query,Functions,Functions2,Result) :-
%%writeln1([m21]),
	(cut(off)->(
        (Query=[Function],
        (Functions2=[[Function,":-",Body]|_Functions3]),
        Vars1=[],
		  debug_call(Skip,[Function]),
        (interpretbody(Functions,Functions2,Vars1,_Vars2,Body,true)->debug_fail_fail(Skip);
        debug_fail(Skip,[Function])), %%**arg2 change
        debug_exit(Skip,[Function])
	);%%->true;
	(%%Query=[Function],
	%%Functions2=[[Function]|Functions3],
	member22(Query,Functions,Functions2,Result))
	);(turncut(off),fail)).
member22(Query,Functions,Functions2,Vars8) :-
%%writeln1([m22]),
	(cut(off)->(
        (Query=[Function,Arguments1],
        (Functions2=[[Function,Arguments2]|_Functions3]),
        length(Arguments1,Length),
        length(Arguments2,Length),

debug_call(Skip,[Function,Arguments1]),

        ((
        checktypes_inputs(Function,Arguments1),

        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),


%%writeln1([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
        updatevars(FirstArgs,Vars1,[],Result),
        %%reverse(Result,[],Vars7),
        (true->%not(Result=[])->
        %%Result=[Var71|Vars72],
        (%trace,
        unique1(Result,[],Vars8),%notrace,
        findresult3(Arguments1,Vars8,[],Result2)
        );(
%%writeln1(here4),
	Vars8=[],Result2=[])),
	checktypes(Function,Result2)

	)->debug_fail_fail(Skip);
        debug_fail(Skip,[Function,Arguments1])), %%**arg2 change
        	debug_exit(Skip,[Function,Result2])
	
	);%%->true;
	(%%Query=[Function,_Arguments1],
	%%Functions2=[[Function,_Arguments2]|Functions3],
	member23(Query,Functions,Functions2,Vars8))
	);(turncut(off),fail)).
member23(Query,Functions,Functions2,Vars8) :-
%%writeln1([m23]),
	(cut(off)->(
        (Query=[Function],
        (Functions2=[[Function]|_Functions3]),
        	debug_call(Skip,[Function]),
	Vars8=[],
        	debug_exit(Skip,[Function])
	);%%->true;
	(%%Query=[Function],
	Functions2=[_Function|Functions3],
	member2(Query,Functions,Functions3,Vars8))
	);(turncut(off),fail)).

turn_occurs_check(on) :-
	retractall(occurs_check(_)),assertz(occurs_check(on)),!.
turn_occurs_check(off) :-
	retractall(occurs_check(_)),assertz(occurs_check(off)),!.

checkarguments(Variable1a,Variable2a,Vars1,Vars2,_,FirstArgs2) :-
%writeln1(a1checkarguments(Variable1a,Variable2a,Vars1,Vars2,_,FirstArgs2)),
%trace,
%(a1checkarguments(Variable1a,Variable2a,Vars1,Vars2,_,FirstArgs2)=a1checkarguments([[v,a],[[v,b],[v,c]]],[[[v,d],[v,e]],[v,f]],[],_346892,_346906,_346894)->trace;true),

%(not(Variable1a=[[v,a],[v,d]])->trace;true),
%writeln([Variable1a,Variable2a]),
%(Variable2a=[[[v,a],"|",_]|_]->trace;true),
	simplify(Variable1a,Variable1),
	simplify(Variable2a,Variable2),
	(equals4(on)->checkarguments1(Variable1,Variable2,Vars1,Vars2,[],FirstArgs2);
checkarguments2(Variable1,Variable2,Vars1,Vars2,[],FirstArgs2)),
% fail if two bs in a,b c,b in first args
%trace,
/*length(FirstArgs2,L),
findall(FA3,(member([_,FA3],FirstArgs2),not(expression_not_var(FA3))),FA4),sort(FA4,FA5),
findall(FA6,(member([_,FA6],FirstArgs2),expression_not_var(FA6)),FA7),append(FA5,FA7,FA8),length(FA8,L),
*/
%writeln1(a2checkarguments(Variable1a,Variable2a,Vars1,Vars2,_,FirstArgs2)),

!.

checkarguments1(Variable1,Variable2,Vars1,Vars2,_,FirstArgs2) :-
%trace,
%writeln1(checkarguments1(Variable1,Variable2,Vars1,Vars2,_,FirstArgs2)),
occurs_check(Variable1,Variable2),
%notrace,	%trace,
	replace_vars(Variable1,[],Variable1a,[],First_vars1),
	%writeln1(replace_vars(Variable1,[],Variable1a,[],First_vars1)),

	replace_vars(Variable2,[],Variable2a,[],First_vars2),
	%writeln1(replace_vars(Variable2,[],Variable2a,[],First_vars2)),
	
	append(First_vars1,First_vars2,First_vars3),

	%match4_21(Variable2a,Variable1a,Vars1,Vars3),
	match4_new_22(Variable2a,Variable1a,Vars1,Vars3%,standard
	), 	
	
	%writeln1(match4_21(Variable2a,Variable1a,Vars1,Vars3)),
%	match4_21(Arguments2,Arguments1,Vars1,Vars2),

	replace_first_vars1(Vars3,First_vars2,[],Vars2a),
	%writeln1(replace_first_vars1(Vars3,First_vars2,[],Vars2a)),

	replace_vars011(Vars2a,_Variable1a,[],Vars2b), % Vars2b->Vars2
	%writeln1(replace_vars011(Vars2a,_Variable1a,[],Vars2b)),
	
	equals4_first_args(Variable1a,Variable2a,FirstArgs3),
	%writeln1(equals4_first_args(Variable1a,Variable2a,FirstArgs3)),
	
	replace_first_vars1(Vars2b,First_vars1,[],Vars2),
	%writeln1(replace_first_vars1(Vars2b,First_vars1,[],Vars2)),
	%equals4_first_args(Vars2b,Vars2,FirstArgs3),

	replace_first_vars2(FirstArgs3,First_vars3,[],FirstArgs2),
	%writeln1(replace_first_vars2(FirstArgs3,First_vars3,[],FirstArgs2)),	
	!.


checkarguments2([],[],Vars,Vars,FirstArgs,FirstArgs) :- !. 
/*
checkarguments2(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :- %%
%%writeln1(1),
%trace,
	Arguments1=[Value|Arguments3], %% Value may be a number, string, list or tree
	%expressionnotatom3(Value),
	Arguments2=[Variable2|Arguments4],
	%trace,
	(Value=[_,'_']->true;Variable2=[_,'_']),

	%not(var(Variable2)),isvar(Variable2),
	%((Value=[_,'_']->true;Variable2=[_,'_'])->
	%Vars1=Vars3;
	%(
	%get_lang_word("v",Dbw_v),
	putvalue(Variable2,undef,%[Dbw_v,'_'],
	Vars1,Vars3),%)),
	checkarguments2(Arguments3,Arguments4,Vars3,Vars2,FirstArgs1,FirstArgs2),!.
	checkarguments2(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :- %%
%%writeln1(1),
trace,
	Arguments1=[Value|Arguments3], %% Value may be a number, string, list or tree
	%expressionnotatom3(Value),
	Arguments2=[Variable2|Arguments4],
	%trace,
	(Value=undef->true;Variable2=undef),

	%not(var(Variable2)),isvar(Variable2),
	%((Value=[_,'_']->true;Variable2=[_,'_'])->
	%Vars1=Vars3;
	%(
	%get_lang_word("v",Dbw_v),
	Vars1=Vars3,
	%putvalue(Variable2,undef,%[Dbw_v,'_'],
	%Vars1,Vars3),%)),
	checkarguments2(Arguments3,Arguments4,Vars3,Vars2,FirstArgs1,FirstArgs2),!.
	*/
checkarguments2(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :- %%
%%writeln1(1),
%trace,
	Arguments1=[Value|Arguments3], %% Value may be a number, string, list or tree
	expressionnotatom3(Value),
	Arguments2=[Variable2|Arguments4],
	not(var(Variable2)),isvar(Variable2),
	%((Value=[_,'_']->true;Variable2=[_,'_'])->
	%Vars1=Vars3;
	%(
	putvalue(Variable2,Value,Vars1,Vars3),%)),
	checkarguments2(Arguments3,Arguments4,Vars3,Vars2,FirstArgs1,FirstArgs2),!.

checkarguments2(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :- %%A
%%writeln1(2),
        Arguments1=[Variable|Arguments3], %% Value may be a number, string, list or tree
        not(var(Variable)),isvar(Variable),
        Arguments2=[Value|Arguments4],
        expressionnotatom3(Value),
        putvalue(Variable,Value,Vars1,Vars3),
	append(FirstArgs1,[[Variable,Value]],FirstArgs3),
        checkarguments2(Arguments3,Arguments4,Vars3,Vars2,FirstArgs3,FirstArgs2),!.
checkarguments2(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :-
%%writeln1(3),
        Arguments1=[Variable1|Arguments3],
	not(var(Variable1)),isvar(Variable1),
        Arguments2=[Variable2|Arguments4],
	not(var(Variable2)),isvar(Variable2),
	%trace,
	(getvalue(Variable2,Value,Vars1)),%%->true);Value=empty), 
	%%((Value=empty->Value1=Variable2;Value1=Value))),
        putvalue(Variable2,Value,Vars1,Vars3),
        append(FirstArgs1,[[Variable1,Variable2]],FirstArgs3),
        checkarguments2(Arguments3,Arguments4,Vars3,Vars2,FirstArgs3,FirstArgs2),!.
checkarguments2(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :-
%%writeln1(4),
        Arguments1=[Value1|Arguments3],
        expressionnotatom3(Value1),
        Arguments2=[Value1|Arguments4],
        expressionnotatom3(Value1),
        checkarguments2(Arguments3,Arguments4,Vars1,Vars2,FirstArgs1,FirstArgs2),!.


%% checktypes([n,f],[1,"a",[n,a]],[[[n,f],[[t,number],[t,string],[t,predicatename]]]]).
%% checktypes([n,f],[1,1,1],[[[n,f],[[[t,list],[[t,number]]]]]]).
%% checktypes([n,f],[[1]],[[[n,f],[[[t,brackets],[[t,number]]]]]]).
%% checktypes([n,f],[1,"a",2,"b"],[[[n,f],[[[t,list],[[t,number],[t,string]]]]]]).
%% checktypes([n,f],[1,"a"],[[[n,f],[[t,a],[t,b]]],[[t,a],[[t,number]]],[[t,b],[[t,string]]]]).
%% Can write your own "any" type.


checktypes_inputs(Function,Vars1):-%%,TypeStatements1) :-
%%trace,
%%writeln(checktypes(Function,Vars1)),
	get_lang_word("n",Dbw_n),
	get_lang_word("query_box",Dbw_query_box),

	(((%trace,
	types(on),Function=[Dbw_n,Dbw_query_box1],
	not(string_concat(Dbw_query_box,_,Dbw_query_box1)))%,notrace
	)->(typestatements(TypeStatements1),
	modestatements(ModeStatements1),
	checktypes0_inputs(Function,Vars1,TypeStatements1,ModeStatements1));true),!.
checktypes0_inputs(Function,Vars1,_TypeStatements1,_ModeStatements1) :- 
	length(Vars1,L),L is 0,Vars1=[],
	get_lang_word("input type check",Input_type_check),
	(types(on)->debug_types_call([Function,/,~,L,Input_type_check]);true),
	
	
	(types(on)->debug_call(Skip,[Function,Vars1]);true),
		
	(types(on)->debug_exit(Skip,[Function,Vars1]);true),
	(types(on)->(debug_types_exit([Function,/,~,L,Input_type_check]));true),!.
checktypes0_inputs(Function,Vars1,TypeStatements1,ModeStatements1) :-
	length(Vars1,L),
	get_lang_word("input type check",Input_type_check),
	(types(on)->(debug_types_call([Function,/,~,L,Input_type_check]));true),
	
	
	(member([Function|[TypeStatements2]],TypeStatements1),
	member([Function|[ModeStatements2]],ModeStatements1),
	extract_modes1(TypeStatements2,TypeStatements3,Vars1,Vars2,ModeStatements2),
	(types(on)->debug_call(Skip,[Function,Vars2]);true),
	((checktypes1(Vars2,TypeStatements3,TypeStatements3,TypeStatements1))->
	(
	(types(on)->debug_exit(Skip,[Function,Vars2]);true),
	(types(on)->(debug_types_exit([Function,/,~,L,Input_type_check]));true))
	
;(
	(types(on)->debug_fail(Skip,[Function,Vars1]);true),

(types(on)->(debug_types_fail([Function,/,~,L,Input_type_check]));true)))),!.

extract_modes1(TypeStatements1,TypeStatements3,Vars1,Vars2,ModeStatements1) :-
	%%TypeStatements1=[TypeStatements2|TypeStatements3],
	%%trace,
	%%writeln1([TypeStatements1,ModeStatements1]),
	extract_modes2(TypeStatements1,[],TypeStatements3,Vars1,[],Vars2,ModeStatements1),!.
	%%TypeStatements3=[TypeStatements3a|TypeStatements3].
extract_modes2([],TypeStatements2a,TypeStatements2a,[],Vars,Vars,[]) :- !.
%%extract_modes2(_,TypeStatements2a,TypeStatements2a,[],Vars,Vars,[]) :- !.
extract_modes2(TypeStatements1,TypeStatements2a,TypeStatements3,Vars1,Vars2,Vars3,ModeStatements1) :-
	get_lang_word("input",Input),
	ModeStatements1=[Input|ModeStatements3],
	TypeStatements1=[TypeStatements2|TypeStatements3a],
	Vars1=[Vars11|Vars12],
	append(TypeStatements2a,[TypeStatements2],TypeStatements4),
	append(Vars2,[Vars11],Vars4),
	extract_modes2(TypeStatements3a,TypeStatements4,TypeStatements3,Vars12,Vars4,Vars3,ModeStatements3),!.
extract_modes2(TypeStatements1,TypeStatements2a,TypeStatements3,Vars1,Vars2,Vars3,ModeStatements1) :-
	get_lang_word("output",Output),
	ModeStatements1=[Output|ModeStatements3],
	TypeStatements1=[_TypeStatements2|TypeStatements3a],
	Vars1=[_Vars11|Vars12],
	extract_modes2(TypeStatements3a,TypeStatements2a,TypeStatements3,Vars12,Vars2,Vars3,ModeStatements3),!.


checktypes(Function,Vars1):-%%,TypeStatements1) :-
%%writeln(checktypes(Function,Vars1)),
	get_lang_word("n",Dbw_n),
	get_lang_word("query_box",Dbw_query_box),

	((types(on),Function=[Dbw_n,Dbw_query_box1],
	not(string_concat(Dbw_query_box,_,Dbw_query_box1)))%,notrace

	->(typestatements(TypeStatements1),
	checktypes0(Function,Vars1,TypeStatements1));true),!.
checktypes0(Function,Vars1,_TypeStatements1) :- 
	get_lang_word("Type check",Type_check),
	length(Vars1,L),L is 0,Vars1=[],
	(types(on)->(debug_types_call([Function,/,L,Type_check]));true),
	
	
	(types(on)->debug_call(Skip,[Function,Vars1]);true),
		
	(types(on)->debug_exit(Skip,[Function,Vars1]);true),
	(types(on)->(debug_types_exit([Function,/,L,Type_check]));true),!.
		
checktypes0(Function,Vars1,TypeStatements1) :-
	get_lang_word("Type check",Type_check),
	length(Vars1,L),
	(types(on)->(debug_types_call([Function,/,L,Type_check]));true),
	
	
	(types(on)->debug_call(Skip,[Function,Vars1]);true),
	((member([Function|[TypeStatements2]],TypeStatements1),
	checktypes1(Vars1,TypeStatements2,TypeStatements2,TypeStatements1))->
	(
	(types(on)->debug_exit(Skip,[Function,Vars1]);true),
	(types(on)->(debug_types_exit([Function,/,L,Type_check]));true))
	
;(
	(types(on)->debug_fail(Skip,[Function,Vars1]);true),

(types(on)->(debug_types_fail([Function,/,L,Type_check]));true))),!.

checktypes1(Vars1,TypeStatements0,TypeStatements1,TypeStatements4) :-
 findall(-,member("|",Vars1),A),length(A,L),not(L>=2),
checktypes10(Vars1,TypeStatements0,TypeStatements1,TypeStatements4).

checktypes10([],[],_,_) :- !.

	checktypes10(Vars1,TypeStatements1,TypeStatements2,TypeStatements4) :-
get_lang_word("t",T),
%trace,
get_lang_word("list",Dbw_list),
%%writeln(checktypes1(Vars1,TypeStatements1,TypeStatements2,TypeStatements4)),
	Vars1=[Vars2|Vars3],
	list1(Vars2,_,_),
	TypeStatements1=[[[T,Dbw_list]|[TypeStatements3]]|TypeStatements4a],
(types(on)->(%TypeStatements3=[TypeStatements32],
simplify_types([[[T,Dbw_list]|[TypeStatements3]]],[],TypeStatements31),
debug_call(Skip,TypeStatements31));true),

	((checktypes3(Vars2,TypeStatements3,TypeStatements2,TypeStatements4))->
		((types(on)->(debug_exit(Skip,{Vars2}));true),
		checktypes10(Vars3,TypeStatements4a,TypeStatements2,TypeStatements4))
;     (types(on)->(debug_fail(Skip,{Vars2}));true)
)
%%not(variable_name(Vars2)),
	. %% ** in brac as well

checktypes10(Vars1,TypeStatements1,TypeStatements2,TypeStatements4) :-
	get_lang_word("t",T),get_lang_word("list",Dbw_list),
%%writeln(checktypes1(Vars1,TypeStatements1,TypeStatements2,TypeStatements4)),
	%%Vars1=[Vars2|Vars3],
	%%list(Vars1,_,_),%%length(Vars1,1),
	TypeStatements1=[[[T,Dbw_list]|[TypeStatements3]]|_TypeStatements4a],
(types(on)->(%TypeStatements3=[TypeStatements32],
simplify_types([[[T,Dbw_list]|[TypeStatements3]]],[],TypeStatements31),debug_call(Skip,TypeStatements31));true),

	((checktypes3(Vars1,TypeStatements3,TypeStatements2,TypeStatements4))->
		(types(on)->debug_exit(Skip,{Vars1});true)
;     (types(on)->debug_fail(Skip,{Vars1});true)).
	%%checktypes1(Vars3,TypeStatements4a,TypeStatements2,TypeStatements4). %% ** in brac as well
	

checktypes10(Vars1,TypeStatements1,TypeStatements2,TypeStatements4) :-
	get_lang_word("t",T),get_lang_word("brackets",Dbw_brackets),
	TypeStatements1=[[[T,Dbw_brackets]|[TypeStatements3]]|TypeStatements4a],
(types(on)->(%trace,%TypeStatements3=[TypeStatements32],
simplify_types([[[T,Dbw_brackets]|[TypeStatements3]]],[],TypeStatements31),debug_call(Skip,TypeStatements31));true),
	(([Vars2|Vars3]=Vars1,
	checktypes10(Vars2,TypeStatements3,TypeStatements2,TypeStatements4))->
		((types(on)->debug_exit(Skip,Vars1);true),
		checktypes10(Vars3,TypeStatements4a,TypeStatements2,TypeStatements4))
;     (types(on)->debug_fail(Skip,Vars1);true))
%%not(variable_name(Vars2)),
	,!. %% ** in brac as well

/**checktypes1(Vars1,TypeStatements0,TypeStatements1,TypeStatements4) :-
	((number(Vars1)->true);string(Vars1)->true;Vars1=[n,_]),
	%%Vars1=[Vars2|Vars3],
	%%TypeStatements0=[TypeStatements2|TypeStatements3],
	checktypes2(Vars1,TypeStatements0,TypeStatements1,TypeStatements4).
	%%checktypes1(Vars3,TypeStatements3,TypeStatements1,TypeStatements4).

**/

checktypes10(Vars1,TypeStatements0,TypeStatements1,TypeStatements4) :-
	Vars1=Vars3,
	TypeStatements0=["|",TypeStatements3],
	%checktypes2(Vars2,TypeStatements2,TypeStatements1,TypeStatements4),
	%%not(variable_name(Vars2)),
	checktypes10([Vars3],[TypeStatements3],TypeStatements1,TypeStatements4).
checktypes10(Vars1,TypeStatements0,TypeStatements1,TypeStatements4) :-
	Vars1=[Vars2|Vars3],
	TypeStatements0=[TypeStatements2|TypeStatements3],
	checktypes2(Vars2,TypeStatements2,TypeStatements1,TypeStatements4),
	%%not(variable_name(Vars2)),
	checktypes10(Vars3,TypeStatements3,TypeStatements1,TypeStatements4).
	
checktypes2(Vars,TypeStatements1,_TypeStatements2,_C) :-
	get_lang_word("t",T),get_lang_word("number",Dbw_number),

%%writeln(checktypes2(Vars,TypeStatements1,_TypeStatements2,C)),
TypeStatements1=[T,Dbw_number],
(types(on)->debug_call(Skip,[[T,Dbw_number],Vars]);true),
	((number(Vars))->
		(types(on)->debug_exit(Skip,[[T,Dbw_number],Vars]);true)
;     (types(on)->debug_fail(Skip,[[T,Dbw_number],Vars]);true)).
checktypes2(Vars,TypeStatements1,_TypeStatements2,_C) :-
	get_lang_word("t",T),get_lang_word("atom",Dbw_atom),

%%writeln(checktypes2(Vars,TypeStatements1,_TypeStatements2,C)),
TypeStatements1=[T,Dbw_atom],
(types(on)->debug_call(Skip,[[T,Dbw_atom],Vars]);true),
	((atom(Vars))->
		(types(on)->debug_exit(Skip,[[T,Dbw_atom],Vars]);true)
;     (types(on)->debug_fail(Skip,[[T,Dbw_atom],Vars]);true)).
checktypes2(Vars,TypeStatements1,_TypeStatements2,_) :-
	get_lang_word("t",T),get_lang_word("predicatename",Dbw_predicatename),
	get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,

TypeStatements1=[T,Dbw_predicatename],
(types(on)->debug_call(Skip,[[T,Dbw_predicatename],Vars]);true),
	((Vars=[Dbw_n,_])->
		(types(on)->debug_exit(Skip,[[T,Dbw_predicatename],Vars]);true)
;     (types(on)->debug_fail(Skip,[[T,Dbw_predicatename],Vars]);true)).

checktypes2(Vars,TypeStatements1,_TypeStatements2,_) :-
	get_lang_word("t",T),get_lang_word("string",Dbw_string),

TypeStatements1=[T,Dbw_string],
(types(on)->debug_call(Skip,[[T,Dbw_string],Vars]);true),
	((string(Vars))->
		(types(on)->debug_exit(Skip,[[T,Dbw_string],Vars]);true)
;     (types(on)->debug_fail(Skip,[[T,Dbw_string],Vars]);true)).

checktypes2(Vars,TypeStatements1,_TypeStatements2,_) :-
	get_lang_word("t",T),get_lang_word("any",Dbw_any),

TypeStatements1=[T,Dbw_any],
(types(on)->debug_call(Skip,[[T,Dbw_any],Vars]);true),
	((true)->
		(types(on)->debug_exit(Skip,[[T,Dbw_any],Vars]);true)
;     (types(on)->debug_fail(Skip,[[T,Dbw_any],Vars]);true)).

checktypes2(Vars,TypeStatements1,TypeStatements2,TypeStatements4) :-
	get_lang_word("t",T),
	get_lang_word("list",Dbw_list),
	get_lang_word("brackets",Dbw_brackets),
	get_lang_word("number",Dbw_number),
	get_lang_word("predicatename",Dbw_predicatename),
	get_lang_word("string",Dbw_string),
	get_lang_word("any",Dbw_any),

TypeStatements1=[T,Type],(not(Type=Dbw_list),not(Type=Dbw_brackets),not(Type=Dbw_number),not(Type=Dbw_predicatename),not(Type=Dbw_string),not(Type=Dbw_any)),
(types(on)->debug_call(Skip,[[T,Type],Vars]);true),
	((
	%%not(variable_name(Vars)),
	member([[T,Type]|[TypeStatements3]],TypeStatements4),
	(checktypes10(Vars,TypeStatements3,TypeStatements2,TypeStatements4)->true;
		checktypes10([Vars],TypeStatements3,TypeStatements2,TypeStatements4)))->
		(types(on)->debug_exit(Skip,[[T,Type],Vars]);true)
;     (types(on)->debug_fail(Skip,[[T,Type],Vars]);true)).

/**
checktypes2(Vars,TypeStatements1,TypeStatements2,TypeStatements4) :-
	TypeStatements1=[t,Type],
	member([[t,Type]|[TypeStatements3]],TypeStatements4),
	checktypes1([Vars],TypeStatements3,TypeStatements2,TypeStatements4).
**/
checktypes3([],_,_TypeStatements2,_) :- !.
checktypes3(Vars,TypeStatements3,TypeStatements2,TypeStatements6) :-
%%writeln(checktypes3(Vars,TypeStatements3,TypeStatements2,TypeStatements6)),
%delete(TypeStatements3,"|",TypeStatements31),
%trace,
	%findall(L0,length1(TypeStatements3,TypeStatements6,[],_,0,L0),L01),
	%sort(L01,L02),
	%member(L,L02),
	length(TypeStatements3,L),
	length(L1,L),
	append(L1,L2,Vars),
	%%[L10]=L1,
	%%TypeStatements3=[TypeStatements4|TypeStatements5],
	%%findall(L10,(member(L10,L1),checktypes2(L10,TypeStatements4,TypeStatements2,TypeStatements6)),B),
	checktypes10(L1,TypeStatements3,TypeStatements2,TypeStatements6),
	checktypes3(L2,TypeStatements3,TypeStatements2,TypeStatements6).

/*
length1([],_,T,T,L,L).

length1(TypeStatements3,TypeStatements2,T1,T2,L1,L2) :-
	TypeStatements3=["|",B],
	length1(B,TypeStatements2,T1,T2,L1,L2).

length1(TypeStatements3,TypeStatements2,T1,T2,L1,L2) :-
	TypeStatements3=[TypeStatements1|B],
	L3 is L1+1,
	(undefined_type([T,Type])->
	(not(member([T,Type],T1)),append(T1,[[T,Type]],T3),	
	member([TypeStatements1|[TypeStatements4]],TypeStatements2),
length1(TypeStatements4,TypeStatements2,T3,T2,L3,L2));
length1(B,TypeStatements2,T1,T2,L3,L2)).

undefined_type([T,Type]) :-
	get_lang_word("t",T),
	get_lang_word("list",Dbw_list),
	get_lang_word("brackets",Dbw_brackets),
	get_lang_word("number",Dbw_number),
	get_lang_word("predicatename",Dbw_predicatename),
	get_lang_word("string",Dbw_string),
	get_lang_word("any",Dbw_any),

TypeStatements1=[T,Type],
not(Type=Dbw_list),not(Type=Dbw_brackets),not(Type=Dbw_number),not(Type=Dbw_predicatename),not(Type=Dbw_string),not(Type=Dbw_any).

*/


interpretbody(_Functions1,_Functions2,Vars,Vars,[],true) :- true.%%!.



/**
interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
        Body=[[[n,not],Statement]
        ],
	
	writeln1(interpretbody(Functions0,Functions,Vars1,Vars3,Statement,Result2)),
	not(interpretbody(Functions0,Functions,Vars1,Vars3,Statement,Result2)), %% 2->1
        ((Result2=cut)->!;true).
**/

/** *** may need to uncomment
interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
        Body=[Statements1|Statements2],not(Statements1=[[n,not],_]),not(predicate_or_rule_name(Statements1)),
        interpretbody(Functions0,Functions,Vars1,Vars3,Statements1,Result2),
        interpretbody(Functions0,Functions,Vars3,Vars2,Statements2,Result3),
        %%((Result3=cut)->!;true),
        logicalconjunction(Result1,Result2,Result3),!.
**/

interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
        Body=[[Statements1|Statements1a]|Statements2
        ],
	
		not(predicate_or_rule_name(Statements1)),
%%writeln1(interpretbody(Functions0,Functions,Vars1,Vars3,[Statement],Result2)),
	interpretbody(Functions0,Functions,Vars1,Vars3,[Statements1],Result2), %% 2->1
        %%((Result2=cut)->!;true),

	interpretbody(Functions0,Functions,Vars3,Vars4,Statements1a,Result22), %% 2->1
        %%((Result22=cut)->!;true),
        interpretbody(Functions0,Functions,Vars4,Vars2,Statements2,Result3),
       %%((Result3=cut)->!;true),
  %%()      logicalnot(Result2,Result4), 
logicalconjunction(Result1a,Result2,Result22),
logicalconjunction(Result1,Result1a,Result3),
	true.%%!.



        
interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
	get_lang_word("n",Dbw_n),get_lang_word("not",Dbw_not),
        Body=[[[Dbw_n,Dbw_not],[Statement]]|Statements2
        ],

debug_call(Skip,[[Dbw_n,Dbw_not]]),
        (	(not(interpretbody(Functions0,Functions,Vars1,_Vars3,[Statement],Result22)))-> %% 2->1
        %%((Result22=cut)->!;true)),%%->
debug_exit(Skip,[[Dbw_n,Dbw_not]])
;     debug_fail(Skip,[[Dbw_n,Dbw_not]])),
	%%writeln1(interpretbody(Functions0,Functions,Vars1,Vars3,[Statement],Result2)),

        interpretbody(Functions0,Functions,Vars1,Vars2,Statements2,Result32),
        %%((Result32=cut)->!;true),
       logicalnot(Result1a,Result22), 
logicalconjunction(Result1,Result1a,Result32),
	true.%%!.
	
	


interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result0) :-
	get_lang_word("n",Dbw_n),get_lang_word("or",Dbw_or),

        Body=[[[Dbw_n,Dbw_or],[Statements1,Statements2]]|Statements3],
        (interpretbody(Functions0,Functions,Vars1,Vars3,[Statements1],Result1)
        %%((Result1=cut)->!;true)); %% *** changed from 1 to Result2
	%%,((Value1=cut)->!;true))
	;
        interpretbody(Functions0,Functions,Vars1,Vars3,[Statements2],Result2)),%%!. *** changed from 1 to Result2
        %%((Result2=cut)->!;true),

        interpretbody(Functions0,Functions,Vars3,Vars2,Statements3,Result3),
        %%((Result3=cut)->!;true),
        logicaldisjunction(Result1a,Result1,Result2),
        logicalconjunction(Result0,Result1a,Result3),
        	true.%%!.


	%%,((Value=cut)->!;true)).
	%%(logicaldisjunction(Result1,Value1,Value2)->true;(Result1=false)).


interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
	get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,


        Body=[[[Dbw_n,"->"],[Statements1,Statements2]]|Statements3],
        (interpretbody(Functions0,Functions,Vars1,Vars3,[Statements1],Result2)
                %%((Result2=cut)->!;true))
-> 
                interpretbody(Functions0,Functions,Vars3,Vars4,[Statements2],Result22)),
                 %%((Result22=cut)->!;true))),

        interpretbody(Functions0,Functions,Vars4,Vars2,Statements3,Result3),
               %%((Result3=cut)->!;true),
        logicalconjunction(Result1a,Result2,Result22),
        logicalconjunction(Result1,Result1a,Result3),

        	true.%%!.




interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
	get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,

        Body=[[[Dbw_n,"->"],[Statements1,Statements2,Statements2a]]|Statements3],
        ((interpretbody(Functions0,Functions,Vars1,Vars3,[Statements1],Result2)
           %%((Result2=cut)->!;true))
           -> 
                interpretbody(Functions0,Functions,Vars3,Vars4,[Statements2],Result22)
                %%((Result22=cut)->!;true))
                ;
                interpretbody(Functions0,Functions,Vars1,Vars4,[Statements2a],Result23))),
                %%((Result23=cut)->!;true))),

        interpretbody(Functions0,Functions,Vars4,Vars2,Statements3,Result3),
        
                logicalconjunction(Result1a,Result2,Result22),
                logicaldisjunction(Result1b,Result1a,Result23),
                logicalconjunction(Result1,Result1b,Result3),

        %%((Result3=cut)->!;true),
        	true.%%!.


interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
%writeln1(interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1)),
%trace,
	Body=[Statement|Statements],
%%writeln1(["Functions0",Functions0,"Functions",Functions,"Statement",Statement,"Vars1",Vars1,"Vars3",Vars3,"Result2",Result2,"Cut",Cut]),
	not(predicate_or_rule_name(Statement)),
%trace,
	interpretstatement1(_,Functions0,Functions,Statement,Vars1,Vars3,Result2,Cut),
%%writeln1(["here1"]),
%trace,
	((not(Cut=cut))->(Functions2=Functions);(%%trace,
	!,turncut(on))
	), %% cut to interpret1/2 (assertz)
%%writeln1(["here3"]),
	interpretbody(Functions0,Functions2,Vars3,Vars2,Statements,Result3),
	%%((Result3=cut)->!;true),
%%writeln1(["here4"]),
	logicalconjunction(Result1,Result2,Result3)	,true.%%,!.
%%writeln1([Result1,Result2,Result3]).
turncut(State1) :-
	cut(State2),
	retract(cut(State2)),
	assertz(cut(State1)).
turndebug(State1) :-
	debug(State2),
	retract(debug(State2)),
	assertz(debug(State1)).
turnequals4(State1) :-
	(not(equals4(_Equals4))->(retractall(equals4(_)),assertz(equals4(on)));true),
		equals4(State2),
	retract(equals4(State2)),
	assertz(equals4(State1)).
turn_save_debug(State1) :-
	(not(save_debug(_))->(retractall(save_debug(_)),assertz(save_debug(off)));true),
		%save_debug(State2),
	retractall(save_debug(_)),
		assertz(save_debug(State1)),
!.
do_saved_debug(State1) :-
	(not(saved_debug(_))->(retractall(saved_debug(_)),assertz(saved_debug([])));true),
		%saved_debug(State2),
	retractall(saved_debug(_)),
	assertz(saved_debug(State1)),
	!.
logicaldisjunction(true,true,true) :- !.
logicaldisjunction(true,false,true) :- !.
logicaldisjunction(true,true,false) :- !.
logicaldisjunction(false,false,true) :- !.
logicalconjunction(true,true,true) :- !.
logicalconjunction(false,false,true) :- !.
logicalconjunction(false,true,false) :- !.
logicalconjunction(false,false,false) :- !.
logicalnot(Result1,Result2) :-
	true(Result1),false(Result2).
logicalnot(Result1,Result2) :-
        false(Result1),true(Result2).
true(true).
false(false).

%%interpretstatement1(ssi,_F0,[],_,Vars,Vars,true,nocut) :- !
%%writeln1("AND HERE!")
%%	.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_equals4_on]|_],Vars,Vars,true,nocut) :- %writeln(here),
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("equals4_on",Dbw_equals4_on1),Dbw_equals4_on1=Dbw_equals4_on,
turnequals4(on),
!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_equals4_off]|_],Vars,Vars,true,nocut) :- %writeln(here),
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("equals4_off",Dbw_equals4_off1),Dbw_equals4_off1=Dbw_equals4_off,
turnequals4(off),
!.

interpretstatement1(ssi,_F0,_Functions,[[n,trace2]|_],Vars,Vars,true,nocut) :- %writeln(here),
trace,!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_trace]|_],Vars,Vars,true,nocut) :- 
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("trace",Dbw_trace1),Dbw_trace1=Dbw_trace,
turndebug(on),
!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_notrace]|_],Vars,Vars,true,nocut) :- 
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("notrace",Dbw_notrace1),Dbw_notrace1=Dbw_notrace,
turndebug(off),
!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_cut]|_],Vars,Vars,true,cut) :- 
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("cut",Dbw_cut1),Dbw_cut1=Dbw_cut,!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_true]|_],Vars,Vars,_,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("true",Dbw_true1),Dbw_true1=Dbw_true,!.
interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_fail]|_],Vars,Vars,_,nocut) :- 
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("fail",Dbw_fail1),Dbw_fail1=Dbw_fail,
fail.

/**
interpretstatement1(ssi,Functions0,Functions,[[n,not],[Statements]],Vars1,Vars2,Result,nocut) :-
	not(interpretbody(Functions0,Functions,Vars1,Vars2,
		Statements,Result)).

interpretstatement1(ssi,Functions0,Functions,[[n,or],[Statement1,Statement2]],Vars1,Vars2,Result,nocut) :-
	(interpretbody(Functions0,Functions,Vars1,Vars2,
		Statement1,Result1);
		interpretbody(Functions0,Functions,Vars1,Vars2,
		Statement2,Result2)).
**/

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_comment],[_Variable]],Vars,Vars,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("comment",Dbw_comment1),Dbw_comment1=Dbw_comment,!.


interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_atom],[Variable]],Vars,Vars,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("atom",Dbw_atom1),Dbw_atom1=Dbw_atom,

	getvalue(Variable,Value,Vars),
debug_call(Skip,[[Dbw_n,Dbw_atom],[Value]]),
	(atom(Value)->
debug_exit(Skip,[[Dbw_n,Dbw_atom],[Value]])
;     debug_fail(Skip,[[Dbw_n,Dbw_atom],[Value]])),!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_string],[Variable]],Vars,Vars,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("string",Dbw_string1),Dbw_string=Dbw_string1,

        getvalue(Variable,Value,Vars),
debug_call(Skip,[[Dbw_n,Dbw_string],[Value]]),
	(string(Value)->
debug_exit(Skip,[[Dbw_n,Dbw_string],[Value]])
;     debug_fail(Skip,[[Dbw_n,Dbw_string],[Value]])),!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_number],[Variable]],Vars,Vars,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("number",Dbw_number1),Dbw_number1=Dbw_number,
        getvalue(Variable,Value,Vars),
debug_call(Skip,[[Dbw_n,Dbw_number],[Value]]),
	(number(Value)->
debug_exit(Skip,[[Dbw_n,Dbw_number],[Value]])
;     debug_fail(Skip,[[Dbw_n,Dbw_number],[Value]])),!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_letters],[Variable]],Vars,Vars,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("letters",Dbw_letters1),Dbw_letters1=Dbw_letters,

        getvalue(Variable,Value,Vars),
debug_call(Skip,[[Dbw_n,Dbw_letters],[Value]]),
        ((string_codes(Value,Value1),
        phrase(word1(Value1),_))->
debug_exit(Skip,[[Dbw_n,Dbw_letters],[Value]])
;     debug_fail(Skip,[[Dbw_n,Dbw_letters],[Value]])),!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_variable],[Variable]],Vars,Vars,true,nocut) :-
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("variable",Dbw_variable1),
get_lang_word("var",Dbw_variable2)
,(Dbw_variable1=Dbw_variable->true;
Dbw_variable2=Dbw_variable),

debug_call(Skip,[[Dbw_n,Dbw_variable],[Variable]]),
	getvalue(Variable,Value,Vars),
        (isvar(Value)->
debug_exit(Skip,[[Dbw_n,Dbw_variable],[Variable]])
;     debug_fail(Skip,[[Dbw_n,Dbw_variable],[Variable]])),!.

/**interpretstatement1(ssi,_F0,_Functions,[[n,Operator],[Variable1]],Vars1,Vars2,true,nocut) :-
	isop(Operator),
	interpretpart(is,Variable1,Vars1,Vars2),!.
**/


interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Operator],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
	isop(Operator),
	%trace,
	interpretpart(is,Variable1,Variable2,Vars1,Vars2),!.

/**
interpretstatement1(ssi,_F0,_Functions,[[n,Operator],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
%%writeln1(31),
        isop(Operator),
        interpretpart(is,Variable2,Variable1,Vars1,Vars2).
**/

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Operator],[Variable2,Variable3,Variable1]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
	operator(Operator),
%%writeln1(4),
        %trace,
%trace,
        interpretpart(isop,Operator,Variable1,Variable2,Variable3,Vars1,Vars2),!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Operator],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
	comparisonoperator(Operator),
%%writeln1(4),
        interpretpart(iscomparison,Operator,Variable1,Variable2,Vars1,Vars2),!.

%%interpretstatement1(ssi,_F0,_Functions,[Variable2+Variable3,is,Variable1],Vars1,Vars2,true,nocut) :-
%%writeln1(41),
        %%interpretpart(isplus,Variable1,Variable2,Variable3,Vars1,Vars2).

/**interpretstatement1(ssi,_F0,_Functions,[[n,=],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
%%writeln1(5),
        interpretpart(is,Variable1,Variable2,Vars1,Vars2).
**/

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_equals1],[Variable1,[Variable2,Variable3]]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("equals1",Dbw_equals11),Dbw_equals11=Dbw_equals1,

%%writeln1(5),
        interpretpart(match1,Variable1,Variable2,Variable3,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_equals2],[Variable1,[Variable2,Variable3]]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("equals2",Dbw_equals21),Dbw_equals21=Dbw_equals2,

%%writeln1(5),
        interpretpart(match2,Variable1,Variable2,Variable3,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_equals3],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("equals3",Dbw_equals31),Dbw_equals31=Dbw_equals3,
%%writeln1(5),
        interpretpart(match3,Variable1,Variable2,Vars1,Vars2).


interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_equals4],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
%trace,
%writeln1(interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_equals4],[Variable1,Variable2]],Vars1,Vars2,true,nocut)),
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("equals4",Dbw_equals41),Dbw_equals41=Dbw_equals4,
get_lang_word("v",Dbw_v),
get_lang_word("sys1",Dbw_sys1),
%%writeln1(5),
%trace,
         remember_and_turn_off_debug(Debug),
 	%trace,
         (interpretpart(match4,Variable1,Variable2,Vars1,Vars5,_)->true;(turn_back_debug(Debug),
         %fail
         interpretpart(match4,Variable1,Variable2,Vars1,_Vars2,_))),
         
         interpretpart(match4,Variable1,[Dbw_v,Dbw_sys1],Vars5,Vars4,_),

  	  	  getvalue([Dbw_v,Dbw_sys1],Value3,Vars4),
 	  	  
 	  	  turn_back_debug(Debug),
 
 
        interpretpart(match4,Variable1,Variable2,Vars1,Vars2,Value3),!.

%%interpretstatement1(ssi,_F0,_Functions,[[Variable2,Variable3]=Variable1],Vars1,Vars2,true,nocut) :-
%%writeln1(51),
%%        interpretpart(match,Variable1,Variable2,Variable3,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_wrap],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("wrap",Dbw_wrap1),Dbw_wrap1=Dbw_wrap,
%%writeln1(52), wrap
%%writeln([[n,wrap],[Variable1,Variable2]]),
        interpretpart(bracket1,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_unwrap],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("unwrap",Dbw_unwrap1),Dbw_unwrap1=Dbw_unwrap,
%%writeln1(53), unwrap
        interpretpart(bracket2,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_head],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("head",Dbw_head1),Dbw_head1=Dbw_head,

%%writeln1(6),
        interpretpart(head,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_tail],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("tail",Dbw_tail1),Dbw_tail1=Dbw_tail,
%%writeln1(61),
        interpretpart(tail,Variable1,Variable2,Vars1,Vars2).

/*
interpretstatement1(non-ssi,_F0,_Functions,[[Dbw_n,Dbw_member],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("member",Dbw_member1),Dbw_member1=Dbw_member,
%%writeln1(8),
        interpretpart(member2,Variable1,Variable2,Vars1,Vars2).
*/
interpretstatement1(non-ssi,_F0,_Functions,[[Dbw_n,Dbw_member2],[Variable2,Variable1]],Vars1,Vars2,true,nocut) :-
%writeln(here),
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
%trace,
get_lang_word("member2",Dbw_member21),
get_lang_word("member",Dbw_member22),
(Dbw_member21=Dbw_member2->
        interpretpart(member2,Variable2,Variable1,Vars1,Vars2);
(Dbw_member22=Dbw_member2,
%%writeln1(8),

        interpretpart(member2,Variable1,Variable2,Vars1,Vars2))).

interpretstatement1(non-ssi,_F0,_Functions,[[Dbw_n,Dbw_member2],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
%trace,
get_lang_word("member3",Dbw_member21),Dbw_member21=Dbw_member2,
%%writeln1(8),
        interpretpart(member3,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_delete],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("delete",Dbw_delete1),Dbw_delete1=Dbw_delete,
%%writeln1(),
        interpretpart(delete,Variable1,Variable2,Variable3,Vars1,Vars2).
%%** all in form f,[1,1,etc], including + with 0,1

interpretstatement1(non-ssi,_F0,_Functions,[[Dbw_n,Dbw_append],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("append",Dbw_append1),Dbw_append1=Dbw_append,
%%writeln1(9),
        %trace,
        interpretpart(append,Variable1,Variable2,Variable3,Vars1,Vars2).

/*
interpretstatement1(non-ssi,_F0,_Functions,[[Dbw_n,Dbw_stringconcat],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("string_concat",Dbw_stringconcat1),Dbw_stringconcat1=Dbw_stringconcat,
        interpretpart(stringconcat,Variable1,Variable2,Variable3,Vars1,Vars2).
        */

interpretstatement1(non-ssi,_F0,_Functions,[[Dbw_n,Dbw_stringconcat],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("stringconcat",Dbw_stringconcat1),
get_lang_word("string_concat",Dbw_stringconcat2),
(Dbw_stringconcat1=Dbw_stringconcat->true;
Dbw_stringconcat2=Dbw_stringconcat),
        interpretpart(stringconcat,Variable1,Variable2,Variable3,Vars1,Vars2).

/**
interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_stringconcat_1],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("stringconcat1",Dbw_stringconcat1),Dbw_stringconcat1=Dbw_stringconcat_1,

        interpretpart(stringconcat1,Variable1,Variable2,Variable3,Vars1,Vars2).
**/

/**interpretstatement1(ssi,_F0,_Functions,[[n,grammar_part]|Variables1],Vars1,Vars2,true,nocut) :-
%%writeln1(x9),
		  [Variables2]=Variables1,
        interpretpart(grammar_part,Variables2,Vars1,Vars2),!.**/

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_stringtonumber],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("stringtonumber",Dbw_stringtonumber1),Dbw_stringtonumber1=Dbw_stringtonumber,
        interpretpart(stringtonumber,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_random],[Variable1]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("random",Dbw_random1),Dbw_random1=Dbw_random,
        interpretpart(random,Variable1,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_length],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("length",Dbw_length1),Dbw_length1=Dbw_length,
        interpretpart(length,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_ceiling],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("ceiling",Dbw_ceiling1),Dbw_ceiling1=Dbw_ceiling,
        interpretpart(ceiling,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_date],[Year,Month,Day,Hour,Minute,Seconds]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("date",Dbw_date1),Dbw_date1=Dbw_date,
        interpretpart(date,Year,Month,Day,Hour,Minute,Seconds,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_round],[N1,N2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("round",Dbw_round1),Dbw_round1=Dbw_round,
        interpretpart(round,N1,N2,Vars1,Vars2).

/***
interpretstatement1(ssi,Functions0,_Functions,Query1,Vars1,Vars8,true,nocut) :-
%%writeln1("h1/10"),
        Query1=[[n,grammar]|Arguments],
        ((Arguments=[[Grammar1,Phrase1,RuleName|Variables2]],
        %%[Variables3]=Variables2,
        name(RuleName),
		  convert_to_grammar_part1(Grammar1,[],Grammar2))->true;
		  (Grammar2=Functions0,
		  ((Arguments=[[Phrase1,RuleName|Variables2]]
		  %%([Variables3]=Variables2->true;(Variables2=[],Variables3=[]))
		  )))),

%%writeln1(["Arguments",Arguments,"Vars1",Vars1]),

%%substitutevarsA1(Phrase,Vars1,[],Vars3,[],FirstArgs1),

%%Vars3=[[[v,PhraseVarName],PhraseValue]],
%%Vars4=[[[v,vgp1],PhraseValue]],

   append([Phrase1],Variables2,Variables4), %% *** Should V3 be in [] v

substitutevarsA1(Variables4,Vars1,[],Vars2,[],FirstArgs), %%% var to value, after updatevars:  more vars to values, and select argument vars from latest vars
%%writeln1([substitutevarsA1,arguments,Arguments,vars1,Vars1,vars3,Vars3,firstargs,FirstArgs]),
		  
Vars2=[Phrase2|Vars4],
((Phrase2=[]->true;Phrase2=[_A|_B])->End=[];End=""),
		  (not(Vars4=[])->append([RuleName,Phrase2,End],Vars4,Vars5);
		  (Vars5=[RuleName,Phrase2,End])),
		  Query2=[[n,grammar_part],Vars5],
		  ((((terminal(RuleName),  
		  

		  (not(Vars4=[])->append([Phrase2,RuleName],Vars4,Vars52);
		  (Vars52=[Phrase2,RuleName])),
		  
		  (debug(on)->(writeln1([call,[[n,grammar],Vars52],"Press c."]),(leash1(on)->true;(not(get_single_char(97))->true;abort)));true),

      interpretpart(grammar_part,Vars5,[],Result1),
		  
		  	updatevars2(FirstArgs,Result1,[],Vars51),
	updatevars3(Vars2,Vars51,Vars6),
	reverse(Vars6,[],Vars7),
	((not(Vars7=[])->
	%%Vars7=[Var71|Vars72],
	unique1(Vars7,[],Vars8)
)->true;(
%%writeln1(here1),
	Vars8=[]),strip(Vars8,[],Result2))->true)),

        	(debug(on)->(writeln1([exit,[[n,grammar],Result2],"Press c."]),(leash1(on)->true;(not(get_single_char(97))->true;abort)));true)

)->true;(not(terminal(RuleName)),
         %% Bodyvars2?
		          	
		          			  (not(Vars4=[])->append([Phrase2,RuleName],Vars4,Vars52);
		  (Vars52=[Phrase2,RuleName])),

(debug(on)->(writeln1([call,[[n,grammar],Vars52],"Press c."]),(leash1(on)->true;(not(get_single_char(97))->true;abort)));true),

%%        	debug(on)->writeln1([call,[Function,[Vars3]]]),
%%writeln1(["Query2",Query2,"Functions0",Functions0]),
        interpret2(Query2,Grammar2,Grammar2,Result1), 
        	(debug(on)->(writeln1([exit,[[n,grammar],Vars52],"Press c."]),(leash1(on)->true;(not(get_single_char(97))->true;abort)));true),

	updatevars2(FirstArgs,Result1,[],Vars51),
	updatevars3(Vars2,Vars51,Vars6),
	reverse(Vars6,[],Vars7),
	((not(Vars7=[])->
	%%Vars7=[Var71|Vars72],
	unique1(Vars7,[],Vars8)
);(
%%writeln1(here1),
	Vars8=[])))),!.
***/

interpretstatement1(ssi,_Grammar,_Grammar2,[[Dbw_n,grammar_part],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
%get_lang_word("grammar_part",Dbw_grammar_part1),Dbw_grammar_part1=Dbw_grammar_part,


%%writeln1("h1/10"),
%%trace,%%%%****
	interpretpart(grammar_part,[Variable1,Variable2,Variable3],Vars1,Vars2).

interpretstatement1(non-ssi,Functions0,Functions,[[Dbw_n,Dbw_findall],[Variable1,Body,Variable3]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("findall",Dbw_findall1),Dbw_findall1=Dbw_findall,
get_lang_word("v",Dbw_v),

%trace,

%writeln1(interpretstatement1(non-ssi,Functions0,Functions,[[Dbw_n,Dbw_findall],[Variable1,Body,Variable3]],Vars1,Vars2,true,nocut)),

%%writeln1(interpretstatement1(ssi,Functions0,Functions,[[n,findall],[Variable1,Body,Variable3]],Vars1,Vars2,true,nocut)),
%%writeln1("h1/10"),
%%trace,%%%%****
%%	
%trace,
	debug_call(Skip,[[Dbw_n,Dbw_findall],[Variable1,Body,Variable3]]),
((
	findall(Value3,(
	%%trace,
	%%writeln1(	interpretbody(Functions0,Functions,Vars1,Vars3,[Body],Result2)),

%writeln1(	interpretbody(Functions0,Functions,Vars1,Vars3,[Body],_Result2)),
	interpretbody(Functions0,Functions,Vars1,Vars3,[Body],Result2), %% 2->1
	Result2=true,
	%%((Result2=cut)->!;true),
	%%trace,
	%%(cut(on)->(%%notrace,
	%%fail);(%%trace,
	%%true)),%%notrace,
		
	 remember_and_turn_off_debug(Debug),
	%%trace,
find_sys(Sys_name),
        interpretpart(match4,Variable1,[Dbw_v,Sys_name],Vars3,Vars2,_),
%%writeln1(        interpretpart(match4,Variable1,[v,sys1],Vars3,Vars2,_)),
%%interpretstatement1(ssi,Functions0,Functions,[[n,equals4],[Variable1,Variable3]],Vars3,Vars2,true,nocut),
	getvalue([Dbw_v,Sys_name],Value3,Vars2),
	
	 turn_back_debug(Debug)

	),Value3a),
	putvalue(Variable3,Value3a,Vars1,Vars2)
        )->
debug_exit(Skip,[[Dbw_n,Dbw_findall],[Variable1,Body,Value3a]])
;     debug_fail(Skip,[[Dbw_n,Dbw_findall],[Variable1,Body,Variable3]])).


interpretstatement1(ssi,_Functions0,_Functions,[[Dbw_n,Dbw_string_from_file],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("string_from_file",Dbw_string_from_file1),Dbw_string_from_file1=Dbw_string_from_file,
        interpretpart(string_from_file,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,Functions0,Functions,[[Dbw_n,Dbw_maplist],[Variable1,Variable2,Variable3,Variable4]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("maplist",Dbw_maplist1),Dbw_maplist1=Dbw_maplist,

        interpretpart(maplist,Functions0,Functions,Variable1,Variable2,Variable3,Variable4,Vars1,Vars2).


interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_string_length],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("string_length",Dbw_string_length1),Dbw_string_length1=Dbw_string_length,
        interpretpart(string_length,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_sort],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("sort",Dbw_sort1),Dbw_sort1=Dbw_sort,
        interpretpart(sort,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_intersection],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("intersection",Dbw_intersection1),Dbw_intersection1=Dbw_intersection,
        interpretpart(intersection,Variable1,Variable2,Variable3,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_read_string],[Variable1]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("read_string",Dbw_read_string1),
get_lang_word("read_password",Dbw_read_string2),
(Dbw_read_string1=Dbw_read_string->true;Dbw_read_string2=Dbw_read_string),
        interpretpart(read_string,Variable1,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_text_area],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("text_area",Dbw_text_area1),
(Dbw_text_area1=Dbw_text_area),
        interpretpart(text_area,Variable1,Variable2,Variable3,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_writeln],[Variable1]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("writeln",Dbw_writeln1),Dbw_writeln1=Dbw_writeln,
        interpretpart(writeln,Variable1,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_atom_string],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("atom_string",Dbw_atom_string1),Dbw_atom_string1=Dbw_atom_string,
        interpretpart(atom_string,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_get_lang_word],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("get_lang_word",Dbw_get_lang_word1),Dbw_get_lang_word1=Dbw_get_lang_word,
        interpretpart(get_lang_word,Variable1,Variable2,Vars1,Vars2).



interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_shell],[Variable1]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("shell",Dbw_shell1),Dbw_shell1=Dbw_shell,
        interpretpart(shell,Variable1,Vars1,Vars2).


interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_date_time_stamp],[Y,M,D,Ho,Mi,Se,Se2,Variable1]],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("date_time_stamp",Dbw_date_time_stamp1),Dbw_date_time_stamp1=Dbw_date_time_stamp,
        interpretpart(date_time_stamp,Y,M,D,Ho,Mi,Se,Se2,Variable1,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_phrase_from_file],[[[Dbw_n,Dbw_string],[Out]],Path]],Vars1,Vars2,true,nocut) :-
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("phrase_from_file",Dbw_phrase_from_file1),Dbw_phrase_from_file1=Dbw_phrase_from_file,
get_lang_word("string",Dbw_string1),Dbw_string1=Dbw_string,
        interpretpart(phrase_from_file,Out,Path,Vars1,Vars2).

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_assertz],[[[Dbw_n, Var], [In]]]],Vars1,Vars1,true,nocut) :-
%
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("assertz",Dbw_assertz1),Dbw_assertz1=Dbw_assertz,

%assertz(Var(In))
debug_call(Skip,[[Dbw_n,Dbw_assertz],[[[Dbw_n, Var], [In]]]]),

functor(A,Var,1),arg(1,A,In),
dynamic(Var/1),
assertz(A),

debug_exit(Skip,[[Dbw_n,Dbw_assertz],[[[Dbw_n, Var], [In]]]]),

!.




interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_getz],[[[Dbw_n, Var], [Variable1]]]],Vars1,Vars2,true,nocut) :-
%
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("getz",Dbw_getz1),Dbw_getz1=Dbw_getz,
%trace,

%assertz(Var(In))
functor(A,Var,1),
findall(Variable21,(A,
arg(1,A,Variable21)),Variable2),

		%Variable2=Value2,
        getvalue(Variable2,Value2,Vars1),
        %%getvalue(Value1,Value1A,Vars1),
	%%isvalstr(Value1),
	%%isvalstr(Value1A),
	%not(is_empty(Value1)),
	%expression(Value1),
	%is_empty(Value2),
        val1emptyorvalsequal(Value2,Value1),
	%%isval(Value2),
debug_call(Skip,[[Dbw_n,Dbw_getz],[variable]]),
(        putvalue(Variable1,Value2,Vars1,Vars2)->
debug_exit(Skip,[[Dbw_n,Dbw_getz],[Value1]])
;     debug_fail(Skip,[[Dbw_n,Dbw_getz],[Value1]])).


%assertz(A),



interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_retractall],[[[Dbw_n, Var], [In]]]],Vars1,Vars1,true,nocut) :-
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("retractall",Dbw_retractall1),Dbw_retractall1=Dbw_retractall,

%assertz(Var(In))
debug_call(Skip,[[Dbw_n,Dbw_retractall],[[[Dbw_n, Var], [In]]]]),

functor(A,Var,1),arg(1,A,In),
retractall(A),

debug_exit(Skip,[[Dbw_n,Dbw_retractall],[[[Dbw_n, Var], [In]]]]),

!.

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_word11],[Variable1]],Vars1,Vars1,true,nocut) :-
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("word1",Dbw_word1),Dbw_word11=Dbw_word1,
        %trace,
        interpretpart(word1,Variable1,Vars1).

/*
interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_term_to_atom],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("term_to_atom",Dbw_term_to_atom1),Dbw_term_to_atom1=Dbw_term_to_atom,
        %trace,
        interpretpart(term_to_atom,Variable1,Variable2,Vars1,Vars2).
*/
/*
interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_split_on_substring117a],[Variable1,Variable2,Variable3,Variable4]],Vars1,Vars2,true,nocut) :-
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("split_on_substring117a",Dbw_split_on_substring117a1),Dbw_split_on_substring117a1=Dbw_split_on_substring117a,
        %trace,
        interpretpart(split_on_substring117a,Variable1,Variable2,Variable3,Variable4,Vars1,Vars2).


interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_string_strings],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("string_strings",Dbw_string_strings1),Dbw_string_strings1=Dbw_string_strings,
        %trace,
        interpretpart(string_strings,Variable1,Variable2,Vars1,Vars2).
*/
/*
interpretstatement1(non-ssi,_F0,_Functions,[[Dbw_n,Dbw_assertz],[[[Dbw_n,Variable1],[Variable2]]]],Vars1,Vars2,true,nocut) :-
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("assertz",Dbw_assertz1),Dbw_assertz1=Dbw_assertz,
        %trace,
        interpretpart(assertz,Variable1,Variable2,Vars1,Vars2).

interpretstatement1(non-ssi,_F0,_Functions,[[Dbw_n,Dbw_retractall],[[[Dbw_n,Variable1],[Variable2]]]],Vars1,Vars2,true,nocut) :-
%trace,
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("retractall",Dbw_retractall1),Dbw_retractall1=Dbw_retractall,
        %trace,
        interpretpart(retractall,Variable1,Variable2,Vars1,Vars2).
*/

interpretstatement1(ssi,_F0,_Functions,[[Dbw_n,Dbw_command]|Variables2],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
%trace,
(Variables2=[]->Variables=[];Variables2=[Variables]),

%trace,
member([Command,Args],
[
 %["phrase_from_file",[i,i]],
 %["phrase_from_file",[i,i]],
 
 ["term_to_atom",[i,i]],
 ["term_to_atom",[i,o]],
 ["term_to_atom",[o,i]],

 ["open_file_s",[i,o]],
 ["open_string_file_s",[i,o]],

 ["split_on_substring117a",[i,i,i,o]],
 ["string_strings",[i,o]],

 ["working_directory",[i,i]],
 ["working_directory",[o,i]],
 ["directory_files",[o]],
 ["exists_directory",[i]],
 ["exists_file",[i]],

 ["split_string",[i,i,i,o]],
 ["numbers",[i,i,i,o]],
 ["string_atom",[i,o]],
 ["string_atom",[i,i]],
 ["string_atom",[o,i]],
 /*
 ["atom_string",[i,o]],
 ["atom_string",[i,i]],
 ["atom_string",[o,i]],
 */
 ["string_codes",[i,o]],
 ["string_codes",[i,i]],
 ["string_codes",[o,i]],
 ["number_string",[i,o]],
 ["number_string",[i,i]],
 ["number_string",[o,i]],
 ["reverse",[i,o]],
 ["reverse",[i,i]],
 ["reverse",[o,i]],
 ["get_time",[o]],
 ["string_chars",[i,i]],
 ["string_chars",[i,o]],
 ["string_chars",[o,i]],
 ["atom_chars",[i,i]],
 ["atom_chars",[i,o]],
 ["atom_chars",[o,i]],
 ["atom_codes",[i,i]],
 ["atom_codes",[i,o]],
 ["atom_codes",[o,i]],
 ["atom_concat",[i,i,i]],
 ["atom_concat",[i,o,i]],
 ["atom_concat",[o,i,i]],
 ["atom_concat",[o,o,i]],
 ["atom_concat",[i,i,o]],
 ["atomic",[i]],
 ["atom_length",[i,i]],
 ["atom_length",[i,o]],
 /*
 ["sub_atom",[i,i,i,i,i]],
 ["sub_atom",[i,i,i,i,o]],
 ["sub_atom",[i,i,i,o,i]],
 ["sub_atom",[i,i,i,o,o]],
 ["sub_atom",[i,i,o,i,i]],
 ["sub_atom",[i,i,o,i,o]],
 ["sub_atom",[i,i,o,o,o]],
 ["sub_atom",[i,o,i,i,i]],
 ["sub_atom",[i,o,i,i,o]],
 ["sub_atom",[i,o,i,o,i]],
 ["sub_atom",[i,o,i,o,o]],
 ["sub_atom",[i,o,o,i,i]],
 ["sub_atom",[i,o,o,i,o]],
 ["sub_atom",[i,o,o,o,i]],
 ["sub_atom",[i,o,o,o,o]],
 ["sub_string",[i,i,i,i,i]],
 ["sub_string",[i,i,i,i,o]],
 ["sub_string",[i,i,i,o,i]],
 ["sub_string",[i,i,i,o,o]],
 ["sub_string",[i,i,o,i,i]],
 ["sub_string",[i,i,o,i,o]],
 ["sub_string",[i,i,o,o,o]],
 ["sub_string",[i,o,i,i,i]],
 ["sub_string",[i,o,i,i,o]],
 ["sub_string",[i,o,i,o,i]],
 ["sub_string",[i,o,i,o,o]],
 ["sub_string",[i,o,o,i,i]],
 ["sub_string",[i,o,o,i,o]],
 ["sub_string",[i,o,o,o,i]],
 ["sub_string",[i,o,o,o,o]],
  */
 ["char_code",[i,i]],
 ["char_code",[i,o]],
 ["char_code",[o,i]],
 ["number_chars",[i,i]],
 ["number_chars",[i,o]],
 ["number_chars",[o,i]],
 ["number_codes",[i,i]],
 ["number_codes",[i,o]],
 ["number_codes",[o,i]],
 ["close",[i,i]],
 ["close",[i]],
 ["stream_property",[i,i]],
 ["stream_property",[i,o]],
 ["stream_property",[o,i]],
 ["stream_property",[o,o]],

 ["at_end_of_stream",[]],
 ["at_end_of_stream",[i]],
 ["set_stream_position",[i,i]],
 ["compound",[i]],
 ["copy_term",[i,i]],
 ["copy_term",[i,o]],
 ["copy_term",[o,i]],
 ["copy_term",[o,o]],
 ["current_prolog_flag",[i,i]],
 ["current_prolog_flag",[i,o]],
 ["current_prolog_flag",[o,i]],
 ["current_prolog_flag",[o,o]],
 ["current_input",[i]],
 ["current_input",[o]],
 ["current_output",[i]],
 ["current_output",[o]],
 ["float",[i]],
 ["get_byte",[i,i]],
 ["get_byte",[i,o]],
 ["get_byte",[i]],
 ["get_byte",[o]],
 ["peek_byte",[i,i]],
 ["peek_byte",[i,o]],
 ["peek_byte",[i]],
 ["peek_byte",[o]],
 ["put_byte",[i,o]],
 ["put_byte",[o,o]],
 ["put_byte",[i]],
 ["put_byte",[o]],
 
 ["peek_char",[i,i]],
 ["peek_char",[i,o]],
 ["peek_char",[i]],
 ["peek_char",[o]],

 ["peek_code",[i,i]],
 ["peek_code",[i,o]],
 ["peek_code",[i]],
 ["peek_code",[o]],
 
 ["get_char",[i]],
 ["get_char",[o]],
 ["get_char",[i,i]],
 ["get_char",[i,o]],
 ["get_code",[i]],
 ["get_code",[o]],
 ["get_code",[i,i]],
 ["get_code",[i,o]],
 
 ["halt",[]],
 ["halt",[i]],

 ["set_prolog_flag",[i,i]],
 ["integer",[i]],
 ["set_input",[i]],
 ["set_output",[i]],
 ["open",[i,i,o,i]],
 ["open",[i,i,o]],
 ["nonvar",[i]],

 ["sin",[i,i]],
 ["sin",[i,o]],
 ["cos",[i,o]],
 ["cos",[i,i]],
 ["atan",[i,i]],
 ["atan",[i,o]],
 %["exp",[i,i]],
 %["exp",[i,o]],
 ["log",[i,i]],
 ["log",[i,o]],
 ["sqrt",[i,i]],
 ["sqrt",[i,o]],

 ["put_char",[i,i]],
 ["put_char",[i]],
 ["put_code",[i,i]],
 ["put_code",[i]],
 ["nl",[]],
 ["nl",[i]],
 
 ["read_term",[i,i,i]],
 ["read_term",[i,o,i]],
 ["read_term",[i,i]],
 ["read_term",[i,o]],
 ["read",[i,i]],
 ["read",[i,o]],
 ["read",[i]],
 ["read",[o]],

 %["write_term",[i,i,i]],
 %["write_term",[i,i]],
 ["write",[i,i]],
 ["write",[i]],
 ["writeq",[i,i]],
 ["writeq",[i]],
 %["write_canonical",[i,i]],
 %["write_canonical",[i]],

 ["abs",[i,i]],
 ["abs",[i,o]],
 ["sign",[i,i]],
 ["sign",[i,o]],
 ["floor",[i,i]],
 ["floor",[i,o]],
 ["round",[i,i]],
 ["round",[i,o]]
 %["ceiling",[i,o]]
]),

get_lang_word(Command,Dbw_command1),Dbw_command1=Dbw_command,

%(Dbw_command=string_chars->trace;true),
 %trace,

        interpretpart(command,Command,Args,Variables,Vars1,Vars2).


interpretstatement1(non-ssi,_F0,_Functions,[[Dbw_n,Dbw_command]|Variables2],Vars1,Vars2,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
%trace,
(Variables2=[]->Variables=[];Variables2=[Variables]),

%trace,
member([Command,Args],
[
 %["phrase_from_file",[i,i]],
 %["phrase_from_file",[i,i]],
 /*["numbers",[i,i,i,o]],
 ["string_atom",[i,o]],
 ["string_atom",[i,i]],
 ["string_atom",[o,i]],
 ["atom_string",[i,o]],
 ["atom_string",[i,i]],
 ["atom_string",[o,i]],
 ["string_codes",[i,o]],
 ["string_codes",[i,i]],
 ["string_codes",[o,i]],
 ["number_string",[i,o]],
 ["number_string",[i,i]],
 ["number_string",[o,i]],
 ["reverse",[i,o]],
 ["reverse",[i,i]],
 ["reverse",[o,i]],
 ["get_time",[o]],
 ["string_chars",[i,i]],
 ["string_chars",[i,o]],
 ["string_chars",[o,i]],
 ["atom_chars",[i,i]],
 ["atom_chars",[i,o]],
 ["atom_chars",[o,i]],
 ["atom_codes",[i,i]],
 ["atom_codes",[i,o]],
 ["atom_codes",[o,i]],
 ["atom_concat",[i,i,i]],
 ["atom_concat",[i,o,i]],
 ["atom_concat",[o,i,i]],
 ["atom_concat",[o,o,i]],
 ["atom_concat",[i,i,o]],
 ["atomic",[i]],
 ["atom_length",[i,i]],
 ["atom_length",[i,o]],
 */
 ["sub_atom",[i,i,i,i,i]],
 ["sub_atom",[i,i,i,i,o]],
 ["sub_atom",[i,i,i,o,i]],
 ["sub_atom",[i,i,i,o,o]],
 ["sub_atom",[i,i,o,i,i]],
 ["sub_atom",[i,i,o,i,o]],
 ["sub_atom",[i,i,o,o,o]],
 ["sub_atom",[i,o,i,i,i]],
 ["sub_atom",[i,o,i,i,o]],
 ["sub_atom",[i,o,i,o,i]],
 ["sub_atom",[i,o,i,o,o]],
 ["sub_atom",[i,o,o,i,i]],
 ["sub_atom",[i,o,o,i,o]],
 ["sub_atom",[i,o,o,o,i]],
 ["sub_atom",[i,o,o,o,o]],
 ["sub_string",[i,i,i,i,i]],
 ["sub_string",[i,i,i,i,o]],
 ["sub_string",[i,i,i,o,i]],
 ["sub_string",[i,i,i,o,o]],
 ["sub_string",[i,i,o,i,i]],
 ["sub_string",[i,i,o,i,o]],
 ["sub_string",[i,i,o,o,o]],
 ["sub_string",[i,o,i,i,i]],
 ["sub_string",[i,o,i,i,o]],
 ["sub_string",[i,o,i,o,i]],
 ["sub_string",[i,o,i,o,o]],
 ["sub_string",[i,o,o,i,i]],
 ["sub_string",[i,o,o,i,o]],
 ["sub_string",[i,o,o,o,i]],
 ["sub_string",[i,o,o,o,i]],
 ["number_string",[i,i]],
 ["number_string",[i,o]],
 ["number_string",[o,i]],
 ["get_single_char",[i]],
 ["get_single_char",[o]]
 /*,
 ["atom_string",[i,i]],
 ["atom_string",[i,o]],
 ["atom_string",[o,i]],
 ["char_code",[i,i]],
 ["char_code",[i,o]],
 ["char_code",[o,i]],
 ["number_chars",[i,i]],
 ["number_chars",[i,o]],
 ["number_chars",[o,i]],
 ["number_codes",[i,i]],
 ["number_codes",[i,o]],
 ["number_codes",[o,i]],
 ["close",[i,i]],
 ["close",[i]],
 ["stream_property",[i,i]],
 ["stream_property",[i,o]],
 ["stream_property",[o,i]],
 ["stream_property",[o,o]],

 ["at_end_of_stream",[]],
 ["at_end_of_stream",[i]],
 ["set_stream_position",[i,i]],
 ["compound",[i]],
 ["copy_term",[i,i]],
 ["copy_term",[i,o]],
 ["copy_term",[o,i]],
 ["copy_term",[o,o]],
 ["current_prolog_flag",[i,i]],
 ["current_prolog_flag",[i,o]],
 ["current_prolog_flag",[o,i]],
 ["current_prolog_flag",[o,o]],
 ["current_input",[i]],
 ["current_input",[o]],
 ["current_output",[i]],
 ["current_output",[o]],
 ["float",[i]],
 ["get_byte",[i,i]],
 ["get_byte",[i,o]],
 ["get_byte",[i]],
 ["get_byte",[o]],
 ["peek_byte",[i,i]],
 ["peek_byte",[i,o]],
 ["peek_byte",[i]],
 ["peek_byte",[o]],
 ["put_byte",[i,o]],
 ["put_byte",[o,o]],
 ["put_byte",[i]],
 ["put_byte",[o]],
 
 ["peek_char",[i,i]],
 ["peek_char",[i,o]],
 ["peek_char",[i]],
 ["peek_char",[o]],

 ["peek_code",[i,i]],
 ["peek_code",[i,o]],
 ["peek_code",[i]],
 ["peek_code",[o]],
 
 ["get_char",[i]],
 ["get_char",[o]],
 ["get_char",[i,i]],
 ["get_char",[i,o]],
 ["get_code",[i]],
 ["get_code",[o]],
 ["get_code",[i,i]],
 ["get_code",[i,o]],
 
 ["halt",[]],
 ["halt",[i]],

 ["set_prolog_flag",[i,i]],
 ["integer",[i]],
 ["set_input",[i]],
 ["set_output",[i]],
 ["open",[i,i,o,i]],
 ["open",[i,i,o]],
 ["nonvar",[i]],

 ["sin",[i,i]],
 ["sin",[i,o]],
 ["cos",[i,o]],
 ["cos",[i,i]],
 ["atan",[i,i]],
 ["atan",[i,o]],
 %["exp",[i,i]],
 %["exp",[i,o]],
 ["log",[i,i]],
 ["log",[i,o]],
 ["sqrt",[i,i]],
 ["sqrt",[i,o]],

 ["put_char",[i,i]],
 ["put_char",[i]],
 ["put_code",[i,i]],
 ["put_code",[i]],
 ["nl",[]],
 ["nl",[i]],
 
 ["read_term",[i,i,i]],
 ["read_term",[i,o,i]],
 ["read_term",[i,i]],
 ["read_term",[i,o]],
 ["read",[i,i]],
 ["read",[i,o]],
 ["read",[i]],
 ["read",[o]],

 %["write_term",[i,i,i]],
 %["write_term",[i,i]],
 ["write",[i,i]],
 ["write",[i]],
 ["writeq",[i,i]],
 ["writeq",[i]],
 %["write_canonical",[i,i]],
 %["write_canonical",[i]],

 ["abs",[i,i]],
 ["abs",[i,o]],
 ["sign",[i,i]],
 ["sign",[i,o]],
 ["floor",[i,i]],
 ["floor",[i,o]],
 ["round",[i,i]],
 ["round",[i,o]]*/
 %["ceiling",[i,o]]
]),

get_lang_word(Command,Dbw_command1),Dbw_command1=Dbw_command,

%(Dbw_command=string_chars->trace;true),
 %trace,

        interpretpart(command,Command,Args,Variables,Vars1,Vars2).

	%%interpretpart(findall,[Variable1,Variable3],Vars3,Vars2).

/***
        Query1=[[n,grammar_part]|Arguments],
        Arguments=[[RuleName|Variables2]],
        	%%(([Variables4|Rest]=Variables2->Variables3=Variables2;(Variables2=[],Variables3=[]))),

        ((not(terminal(RuleName)),
%%writeln1(["Arguments",Arguments,"Vars1",Vars1]),
        substitutevarsA1(Variables2,Vars1,[],Vars3,[],FirstArgs), %%% var to value, after updatevars:  more vars to values, and select argument vars from latest vars
%%writeln1([substitutevarsA1,arguments,Arguments,vars1,Vars1,vars3,Vars3,firstargs,FirstArgs]),
		  (not(Vars3=[])->(append([RuleName],Vars3,Vars4),Query2=[[n,grammar_part],Vars4]);
		  Query2=[[n,grammar_part],RuleName]), %% Bodyvars2?
%%        	debug(on)->writeln1([call,[Function,[Vars3]]]),
%%writeln1(["Query2",Query2,"Functions0",Functions0]),
        %%notrace,%%****
 interpret2(Query2,Grammar,Grammar,Result1),
 %%trace,%****
	updatevars2(FirstArgs,Result1,[],Vars5),
	updatevars3(Vars1,Vars5,Vars6),
	reverse(Vars6,[],Vars7),
	((not(Vars7=[])->
	%%Vars7=[Var71|Vars72],
	unique1(Vars7,[],Vars8)
)->true;(
%%writeln1(here1),
	Vars8=[]))->true)->true;
(terminal(RuleName),substitutevarsA1(Variables2,Vars1,[],Vars3,[],FirstArgs),
%%writeln1(here), %%****
%%Vars3=[Phrase,End],
%%Vars41=[Phrase,[v,vgp]],
append([RuleName],Vars3,Vars9),
%%writeln1([vars9,Vars9]), %%%%%*****
interpretpart(grammar_part,Vars9,[],Result1),
	updatevars2(FirstArgs,Result1,[],Vars5),
	updatevars3(Vars3,Vars5,Vars6),
	reverse(Vars6,[],Vars7),
	((not(Vars7=[])->
	%%Vars7=[Var71|Vars72],
	unique1(Vars7,[],Vars8)
	%%writeln1([vars8,Vars8]) %%%*****
)->true;(
%%writeln1(here1),
	Vars8=[]))->true)),%%notrace, %%****
	!.
**/

interpretstatement1(non-ssi,Functions0,Functions,Query1,Vars1,Vars8,true,nocut) :-
        
        %trace,
        %(Query1=[[n, flatten2], [[v, e], [v, f], [v, c]]]->trace;true),%writeln1(interpretstatement1(ssi,Functions0,_Functions,Query1,Vars1,Vars8,true,nocut)),
        %trace,
               %writeln(interpretstatement1(ssi,Functions0,_Functions,Query1,Vars1,Vars8,true,nocut)),
%
get_lang_word("v",Dbw_v),
%get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
%get_lang_word("call",Dbw_call1),Dbw_call1=Dbw_call,
%trace,
%%writeln1("h1/10"),

%writeln([Functions0,Functions0]),
%find_pred_sm(Reserved_words1),

        %trace,
       % ((Query1=[[Dbw_n,Dbw_call],[Function,Arguments]]%,        not_reserved_word(Function,Reserved_words1)
        %)->true;
%(
Query1=[Function,Arguments],%,Function=[Dbw_n1,Function_a],atom_string(Function_a,Function_s),
%(Function=[n,paraphrase2]->trace;true),
%)
%),

%trace,
        %%not(Function=[n,grammar]->true;Function=[n,grammar_part]), ****
%%writeln1(["Arguments",Arguments,"Vars1",Vars1]),
        %%***writeln1(substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs)),
        Function=[Dbw_v,Function2],
                not(reserved_word2(Function2)),

        getvalue(Function,Function3,Vars1),
        %reserved_word(Function3),
        append([Function3],[Arguments],Arguments1),
        
interpretstatement1(_,Functions0,Functions,Arguments1,Vars1,Vars8,true,nocut).

        
interpretstatement1(non-ssi,_Functions0,_Functions,Query1,Vars1,Vars8,true,nocut) :-
get_lang_word("v",Dbw_v),
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("call",Dbw_call1),Dbw_call1=Dbw_call,

%%writeln1("h1/10"),
%trace,
%find_pred_sm(Reserved_words1),
        ((Query1=[[Dbw_n,Dbw_call],[[lang,Lang1],Debug1,[Function,Arguments],Functions%,Result
        ]],Tm=off%,
        %not(member(Dbw_call,Reserved_words1))
        )->true;
        (Query1=[[Dbw_n,Dbw_call],[[lang,Lang1],Debug1,[Function,Arguments],Types,Modes,Functions%,Result
        ]],Tm=on)),        
        
        %trace,
        
        lang(Lang2a),
        types(Types2a),
		  (Types2a=on->(typestatements(TypeStatements2a),
		  modestatements(ModeStatements2a));true),
		  
        (Lang1=same->lang(Lang2);Lang2=Lang1),
        (Debug1=same->debug(Debug2);Debug2=Debug1),
        
        %%not(Function=[n,grammar]->true;Function=[n,grammar_part]), ****
%%writeln1(["Arguments",Arguments,"Vars1",Vars1]),
        %%***writeln1(substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs)),
        ((Function=[Dbw_v,F_name],
                not(reserved_word2(F_name)))->
        (append([Function],Arguments,Arguments1),
        substitutevarsA1(Arguments1,Vars1,[],Vars3,[],FirstArgs),
        Vars3=[Function1|Vars31],
        Query2=[Function1,Vars31]);
        (substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs),
        %simplify(Vars32,Vars3), %%% var to value, after updatevars:  more vars to values, and select argument vars from latest vars
%%writeln1([substitutevarsA1,arguments,Arguments,vars1,Vars1,vars3,Vars3,firstargs,FirstArgs]),
        Query2=[Function,Vars3]
        %not(reserved_word2(Vars3))
        )), %% Bodyvars2?
%%        	debug(on)->writeln1([call,[Function,[Vars3]]]),
%%writeln1(["Query2",Query2,"Functions0",Functions0]),
        
        
        %interpret2(Query2,Functions0,Functions0,Result1), 
        
(Tm=off->international_interpret([lang,Lang2],Debug2,Query2,Functions,Result1a);
	international_interpret([lang,Lang2],Debug2,Query2,Types,Modes,Functions,Result1a)),
	member(Result1,Result1a),

	retractall(lang(_)),
 	assertz(lang(Lang2a)),

	retractall(types(_)),
 	assertz(types(Types2a)),

		  (Types2a=on->(
		  	retractall(typestatements(_)),
 
 	%findall([A,C],(member([A,B],TypeStatements2a),expand_types(B,[],C)),TypeStatements2a1),
	assertz(typestatements(TypeStatements2a)),
	retractall(modestatements(_)),
 	assertz(modestatements(ModeStatements2a)));true),


	updatevars2(FirstArgs,Result1,[],Vars5),
	updatevars3(Vars1,Vars5,Vars6),
	reverse(Vars6,[],Vars7),
	((not(Vars7=[])->
	%%Vars7=[Var71|Vars72],
	(%trace,
	unique1(Vars7,[],Vars8)%,notrace
	)
);(
%%writeln1(here1),
	Vars8=[])).        

%%%% Run Prolog

interpretstatement1(ssi,_Functions0,_Functions,[[Dbw_n,Dbw_shell_pl],[I,QP,QV,P,OVar]],Vars1,Vars2,true,nocut) :-
%trace,
%get_lang_word("v",Dbw_v),
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("shell_pl",Dbw_shell_pl1),Dbw_shell_pl1=Dbw_shell_pl,

        interpretpart(shell_pl,I,QP,QV,P,OVar,Vars1,Vars2).


interpretstatement1(ssi,_Functions0,_Functions,[[Dbw_n,Dbw_shell_c],[I,P,OVar]],Vars1,Vars2,true,nocut) :-
%trace,
%get_lang_word("v",Dbw_v),
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("shell_c",Dbw_shell_c1),Dbw_shell_c1=Dbw_shell_c,

        interpretpart(shell_c,I,P,OVar,Vars1,Vars2).

%%% LEGACY INTERPRET FOR SSI


        
interpretstatement1(ssi,_Functions0,_Functions,Query1,Vars1,Vars8,true,nocut) :-
get_lang_word("v",Dbw_v),
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("interpret",Dbw_interpret1),Dbw_interpret1=Dbw_interpret,

%%writeln1("h1/10"),
%trace,
%find_pred_sm(Reserved_words1),
        ((Query1=[[Dbw_n,Dbw_interpret],[[lang,Lang1],Debug1,[Function,Arguments],Functions%,Result
        ]],Tm=off%,
        %not(member(Dbw_call,Reserved_words1))
        )->true;
        (Query1=[[Dbw_n,Dbw_interpret],[[lang,Lang1],Debug1,[Function,Arguments],Types,Modes,Functions%,Result
        ]],Tm=on)),        
        
        %trace,
        
        lang(Lang2a),
        types(Types2a),
		  (Types2a=on->(typestatements(TypeStatements2a),
		  modestatements(ModeStatements2a));true),
		  
        (Lang1=same->lang(Lang2);Lang2=Lang1),
        (Debug1=same->debug(Debug2);Debug2=Debug1),
        
        %%not(Function=[n,grammar]->true;Function=[n,grammar_part]), ****
%%writeln1(["Arguments",Arguments,"Vars1",Vars1]),
        %%***writeln1(substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs)),
        ((Function=[Dbw_v,F_name],
                not(reserved_word2(F_name)))->
        (append([Function],Arguments,Arguments1),
        substitutevarsA1(Arguments1,Vars1,[],Vars3,[],FirstArgs),
        Vars3=[Function1|Vars31],
        Query2=[Function1,Vars31]);
        (substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs),
        %simplify(Vars32,Vars3), %%% var to value, after updatevars:  more vars to values, and select argument vars from latest vars
%%writeln1([substitutevarsA1,arguments,Arguments,vars1,Vars1,vars3,Vars3,firstargs,FirstArgs]),
        Query2=[Function,Vars3]
        %not(reserved_word2(Vars3))
        )), %% Bodyvars2?
%%        	debug(on)->writeln1([call,[Function,[Vars3]]]),
%%writeln1(["Query2",Query2,"Functions0",Functions0]),
        
        
        %interpret2(Query2,Functions0,Functions0,Result1), 
        
(Tm=off->international_interpret([lang,Lang2],Debug2,Query2,Functions,Result1a);
	international_interpret([lang,Lang2],Debug2,Query2,Types,Modes,Functions,Result1a)),
	member(Result1,Result1a),

	retractall(lang(_)),
 	assertz(lang(Lang2a)),

	retractall(types(_)),
 	assertz(types(Types2a)),

		  (Types2a=on->(
		  	retractall(typestatements(_)),
 
 	%findall([A,C],(member([A,B],TypeStatements2a),expand_types(B,[],C)),TypeStatements2a1),
	assertz(typestatements(TypeStatements2a)),
	retractall(modestatements(_)),
 	assertz(modestatements(ModeStatements2a)));true),


	updatevars2(FirstArgs,Result1,[],Vars5),
	updatevars3(Vars1,Vars5,Vars6),
	reverse(Vars6,[],Vars7),
	((not(Vars7=[])->
	%%Vars7=[Var71|Vars72],
	(%trace,
	unique1(Vars7,[],Vars8)%,notrace
	)
);(
%%writeln1(here1),
	Vars8=[])).        

interpretstatement1(non-ssi,Functions0,_Functions,Query1,Vars1,Vars8,true,nocut) :-
        
        %trace,
               %writeln(interpretstatement1(ssi,Functions0,_Functions,Query1,Vars1,Vars8,true,nocut)),

get_lang_word("v",Dbw_v),
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,
get_lang_word("call",Dbw_call1),Dbw_call1=Dbw_call,

%%writeln1("h1/10"),
%trace,
%writeln([Functions0,Functions0]),
%find_pred_sm(Reserved_words1),

        %trace,
        ((Query1=[[Dbw_n,Dbw_call],[Function,Arguments]]%,        not_reserved_word(Function,Reserved_words1)
        )->true;
(Query1=[Function,Arguments]
%not(reserved_word2(Function))%,Function=[Dbw_n1,Function_a],atom_string(Function_a,Function_s),
%,not_reserved_word(Function,Reserved_words1))
)
),

%trace,
        %%not(Function=[n,grammar]->true;Function=[n,grammar_part]), ****
%%writeln1(["Arguments",Arguments,"Vars1",Vars1]),
        %%***writeln1(substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs)),
        ((Function=[Dbw_v,F_name],
                not(reserved_word2(F_name)))->
        (%trace,
        append([Function],Arguments,Arguments1),
        %trace,
        substitutevarsA1(Arguments1,Vars1,[],Vars3,[],FirstArgs),
        Vars3=[Function1|Vars31],
        Query2=[Function1,Vars31]
        );
        (%trace,
                        
        substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs),
        
        Query2=[Function,Vars3],
        
        Function=[Dbw_n,F_name],
                not(reserved_word2(F_name))
        %simplify(Vars32,Vars3), %%% var to value, after updatevars:  more vars to values, and select argument vars from latest vars
%writeln1([substitutevarsA1,arguments,Arguments,vars1,Vars1,vars3,Vars3,firstargs,FirstArgs]),

        %not(reserved_word2(Vars3))
        )), %% Bodyvars2?
%(Function=[n,compound213]->%true
%trace
%;true),
        %trace,
%%        	debug(on)->writeln1([call,[Function,[Vars3]]]),
%%writeln1(["Query2",Query2,"Functions0",Functions0]),
%trace,
%writeln1(interpret2(Query2,Functions0,Functions0,Result1)),

        interpret2(Query2,Functions0,Functions0,Result1), 
        
      %trace,          %writeln1(interpret2(Query2,Functions0,Functions0,Result1)),
	%writeln1(updatevars2(FirstArgs,Result1,[],Vars5)),

	updatevars2(FirstArgs,Result1,[],Vars5),
	updatevars3(Vars1,Vars5,Vars6),
	reverse(Vars6,[],Vars7),
	((not(Vars7=[])->
	%%Vars7=[Var71|Vars72],
	(%trace,
	unique1(Vars7,[],Vars8)%,notrace
	)
);(
%%writeln1(here1),
	Vars8=[])).
	
	
	
	
	
	
		
	
%%**** reverse and take first instance of each variable.
	%%findresult3(Arguments,Vars6,[],Result2)
%%writeln1(["FirstArgs",FirstArgs,"Result1",Result1,"Vars5",Vars5,"Vars4",Vars4]),
%%writeln1(["Vars1:",Vars1,"Vars4:",Vars4]),
%%		debug(on)->writeln1([exit,[Function,[Result2]]]).
interpretstatement1(non-ssi,Functions0,_Functions,Query,Vars,Vars,true,nocut) :-
get_lang_word("n",Dbw_n1),Dbw_n1=Dbw_n,

%find_pred_sm(Reserved_words1),
%trace,
	Query=[Function],

        Function=[Dbw_n,F_name],
        not(reserved_word2(F_name)),
	%trace,
	%not(reserved_word2(Function)),
%debug_call(Skip,[Function]),
        (interpret2(Query,Functions0,Functions0,_Result1)->
true%debug_exit(Skip,[Function])
;     fail%debug_fail(Skip,[Function])
)
,!.

not_reserved_word(Function,Reserved_words) :-
	        %Function=[[_,Function_a]|_]
	        Function=[_,Function_a],(atom(Function_a)->true;string(Function_a)),atom_string(Function_a,Function_s)
,not(member(Function_s,Reserved_words)).


debug_react(Status,115,true) :- Status=call, 
turndebug(off), write0(" "),get_lang_word("skip",Dbw_skip),writeln0(Dbw_skip). %% skip
debug_react(_Status,97,false) :- write0(" "),get_lang_word("abort",Dbw_abort),writeln0(Dbw_abort),abort. %% abort
debug_react(Status,A,false) :- ((Status=call,not(A=115),not(A=97))->true;
(member_exit_fail(Status),not(A=97))), write0(" "),get_lang_word("creep",Dbw_creep),writeln0(Dbw_creep). %% creep

member_exit_fail(exit).
member_exit_fail(fail).

debug_call(Skip,FunctionArguments1) :-
%debug(On),leash1(On2),
%writeln1([debug(on),debug(On),leash1(on),leash1(On2)]),
get_lang_word("call",Dbw_call),
get_lang_word("Press c to creep, s to skip or a to abort.",Dbw_note1),
%trace,
((save_debug(on),debug(on))->(saved_debug(List1),append(List1,[[Dbw_call,FunctionArguments1,Dbw_note1]],List2),
do_saved_debug(List2));true),
((retry_back(on),debug(on))->(append_retry_back_stack([debug,[Dbw_call,FunctionArguments1,Dbw_note1]]));true),
(debug(on)->(write1([Dbw_call,FunctionArguments1,Dbw_note1]),
(leash1(on)->writeln0("");(%print_text,
get_single_char(Key),debug_react(call,Key,Skip))));Skip=false).

debug_fail_fail(Skip) :-
(debug(on)->(Skip=true->turndebug(on);true);true).

debug_fail(Skip,FunctionArguments1) :-
get_lang_word("fail",Dbw_fail),
get_lang_word("Press c to creep or a to abort.",Dbw_note1),

((save_debug(on),debug(on))->(saved_debug(List1),append(List1,[[Dbw_fail,FunctionArguments1,Dbw_note1]],List2),
do_saved_debug(List2));true),
((retry_back(on),debug(on))->(append_retry_back_stack([debug,[Dbw_fail,FunctionArguments1,Dbw_note1]]));true),
((Skip=true->turndebug(on);true),((debug(on)->(write1([Dbw_fail,FunctionArguments1,Dbw_note1]),
(leash1(on)->writeln0("");(%print_text,
get_single_char(Key),debug_react(fail,Key,_Skip))));true),fail)).

debug_exit(Skip,FunctionResult2) :-
get_lang_word("exit",Dbw_exit),
get_lang_word("Press c to creep or a to abort.",Dbw_note1),
((save_debug(on),debug(on))->(saved_debug(List1),append(List1,[[Dbw_exit,FunctionResult2,Dbw_note1]],List2),
do_saved_debug(List2));true),
((retry_back(on),debug(on))->(append_retry_back_stack([debug,[Dbw_exit,FunctionResult2,Dbw_note1]]));true),
((Skip=true->turndebug(on);true),((debug(on)->(write1([Dbw_exit,FunctionResult2,Dbw_note1]),
(leash1(on)->writeln0("");(%print_text,
get_single_char(Key),debug_react(exit,Key,_Skip))));true))).


debug_types_call(FunctionArguments1) :-
get_lang_word("call",Dbw_call),
debug_types(Dbw_call,FunctionArguments1).

debug_types(Call,FunctionArguments1) :-
((save_debug(on),debug(on))->(saved_debug(List1),append(List1,[[Call,FunctionArguments1]],List2),
do_saved_debug(List2));true),
((retry_back(on),debug(on))->(append_retry_back_stack([debug,[Call,FunctionArguments1]]));true),
(debug(on)->(writeln1([Call,FunctionArguments1]));true).

debug_types_fail(FunctionArguments1) :-
get_lang_word("fail",Dbw_fail),
((save_debug(on),debug(on))->(saved_debug(List1),append(List1,[[Dbw_fail,FunctionArguments1]],List2),
do_saved_debug(List2));true),
((retry_back(on),debug(on))->(append_retry_back_stack([debug,[Dbw_fail,FunctionArguments1]]));true),
((debug(on)->(writeln1([Dbw_fail,FunctionArguments1]))
;true),fail).

debug_types_exit(FunctionResult2) :-
get_lang_word("exit",Dbw_exit),
debug_types(Dbw_exit,FunctionResult2).


word1([])-->[].
word1([A|As]) --> [A],word1(As),{%%atom_codes(A,AC),
char_type(A,alpha)},!.
/**interpretstatement1(ssi,_Functions0, _Functions,_Query,_Vars1,_Vars2,false) :-
	writeln1([false]).
**/
/**
interpretstatement2(Value,_Vars,Value) :-
	(number(Value);atom(Value)).
interpretstatement2(Variable,Vars1,Value) :-
	getvalue(Variable,Value,Vars1).
interpretstatement3(A + B,Vars,Value1) :-
        interpretstatement2(A,Vars,Value2),
        interpretstatement2(B,Vars,Value3),
        Value1 = Value2 + Value3.
interpretstatement3(Value,_Vars,Value) :-
	(number(Value);atom(Value)).
interpretstatement3(Variable,Vars,Value) :-
        getvalue(Variable,Value,Vars).
        **/
getvalue(Variable,Value,Vars) :-
        ((not(isvar(Variable)),isvalstrorundef(Value),
        %simplify(Variable,Variable2),%->true;(writeln1(simplify(Variable,Variable2)),abort)),%notrace,
      Variable=Value)->true;
        (isvar(Variable),isvalstrorundef(Value),getvar(Variable,Value,Vars))).
/*putvalue(Variable,Value,Vars1,Vars2) :-
        ((not(isvar(Variable)),isvalstrorundef(Value),Variable=Value,Vars1=Vars2)->true;
        (isvar(Variable),isvalstrorundef(Value),%trace,
        updatevar(Variable,Value,Vars1,Vars2))),!. 
        */
getvar(Variable,Value,Vars) :-
	((member([Variable,Value],Vars),
	not(is_empty(Value)))->true;
	        ((aggregate_all(count,member([Variable,_Value],Vars),0)->true;%%
	(member([Variable,Empty],Vars),is_empty(Empty))),(Empty=Value)))
.
getvar(undef,undef,_Vars) :-
	!.
%%getvar(Variable,empty,Vars) :-
        %%(aggregate_all(count,member([Variable,_Value],Vars),0)->true;%%;
	%%member([Variable,empty],Vars))
	%%.
	
simplify(A,A)	:-
	(blob(A,stream)->%false
	true
	;(variable_name(A)->true;(string(A)->true;(number(A)->true;(atom(A)->true;A=[]))))),!.
%simplify([A,"|",[B|B0]],[A1|[B1|B10]])	:-
%	simplify(A,A1),
%	simplify(B,B1),
%	simplify(B0,B10),!.
simplify([A,"|",B],C)	:-
	simplify(A,A1),
	simplify(B,B1),
	((not(isvar(B1)),is_list(B1))->
	C=[A1|B1];
	C=[A1,"|",B1]),!.
simplify(AB,[A1|B1])	:-
	AB=[A|B],
%(not(is_list(B))->trace;true),
%is_list(B),not(variable_name(B)),
(AB=[_A2,"|"|B2]->
(B2=[B3],(((is_list(B3),not(variable_name(B3)))->true;variable_name(B3))));true),
	simplify(A,A1),
	simplify(B,B1),!.
	
	
all_empty([]) :-	!.
all_empty(Empty) :-	is_empty(Empty),!.
all_empty([A|B]) :-	
	all_empty(A),all_empty(B),!.
	
updatevar(undef,_Value,Vars,Vars) :-
	!.
updatevar(Variable,Value,Vars1,Vars2a) :-
%writeln1(updatevar(Variable,Value,Vars1,Vars2))
%trace,	
	
	((((member([Variable,A],Vars1),
	%trace,
	%(isvar(Variable)->Value2=Value;
	(updatevar_recursive(Value,A,Value2)),
	%notrace,
	%all_empty(A),
	delete(Vars1,[Variable,A],Vars3),
	append(Vars3,[[Variable,Value2]],Vars2)
	)->true;
	((not(member([Variable,Value1],Vars1)),
	((is_empty(Value1))->true;(Value1=Value)))),
        append(Vars1,[[Variable,Value]],Vars2))->true;
	(member([Variable,Value],Vars1),Vars2=Vars1))->true;
	(undef(Variable),
	append(Vars1,[[Variable,Value]],Vars2))),
	
		%(%variable_name(Variable)->
	%(
	%/*trace,
	findall([Variable1,B],(member([Variable1,C],Vars2),
	replace_in_term(C,Variable,Value,B)),
	Vars2a)
	%*/
	%Vars2=Vars2a
	%,writeln1(replace_in_term(Vars1a,Variable,Value,Vars1))
	%);
	%Vars1a=Vars1),

.
	
updatevar_recursive([],[],[]) :- !.
updatevar_recursive(Variable,A,Value) :-
	(is_empty(Variable)->Value=A;
	(is_empty(A)->Value=Variable;
	(Variable=A->Value=Variable;
	(Variable=[B|C],
	A=[D|E],
	updatevar_recursive(B,D,Value1),
	updatevar_recursive(C,E,Value2),
	append([Value1],Value2,Value))))),!.
	
	

/**updatevars(_FirstArgs,[],Vars,Vars).
updatevars(FirstArgs,Vars1,Vars2,Vars3) :-
        Vars1=[[Variable1,Value]|Vars4],
	((member([Variable2,Variable1],FirstArgs), %% removed brackets around firstargs here and 2 line below
	append(Vars2,[[Variable2,Value]],Vars5))->true;
	(member([Variable1,_Variable2],FirstArgs),
	append(Vars2,[[Variable1,Value]],Vars5))),
	updatevars(FirstArgs,Vars4,Vars5,Vars3),
	!.
updatevars(FirstArgs,Vars1,Vars2,Vars3) :-
	Vars1=[_Vars4|Vars5],
	updatevars(FirstArgs,Vars5,Vars2,Vars3).**/

updatevars(FirstArgs,Vars1,Vars2,Vars3) :-
%writeln1(updatevars(FirstArgs,Vars1,Vars2,Vars3)),

%(updatevars(FirstArgs,Vars1,Vars2,Vars3)=updatevars([[[v,vgp3],[v,vgp2]],[[v,i],[v,t]]],[[[v,t1],"b"],[[v,vgp2],",""c"",[]],1]"],[[v,vgp1],"b,""c"",[]],1]"],[[v,t],b]],[],_181890)->trace;true),


%trace,
(equals4(on)->
%(writeln1(e4_updatevars_1(FirstArgs,Vars1,Vars2,Vars3)),
e4_updatevars(FirstArgs,Vars1,Vars2,Vars3)
%,writeln1(e4_updatevars_2(FirstArgs,Vars1,Vars2,Vars3)))
;	updatevars1(FirstArgs,Vars1,Vars2,Vars3)),!.
	

updatevars1([],_Vars1,Vars2,Vars2) :- !.
updatevars1(FirstArgs,Vars1,Vars2,Vars3) :-
	FirstArgs=[[Orig,New]|Rest],
	(expressionnotatom(New)->append(Vars2,[[Orig,New]],Vars4);
	(member([New,Value],Vars1),
	append(Vars2,[[Orig,Value]],Vars4))),
	updatevars1(Rest,Vars1,Vars4,Vars3),!.

updatevars2(_FirstArgs,[],Vars,Vars) :- !.
updatevars2(FirstArgs,Vars1,Vars2,Vars3) :-
%trace,
%writeln(updatevars2(FirstArgs,Vars1,Vars2,Vars3)),
%trace,
        Vars1=[[Variable,Value]|Vars4],
        (%member(Variable,FirstArgs), %% removed brackets around firstargs here and 2 line below, ** vars1 into arg in (10), check cond
        append(Vars2,[[Variable,Value]],Vars5)),
        updatevars2(FirstArgs,Vars4,Vars5,Vars3).

updatevars3(Vars1,Vars2,Vars4) :-
 updatevars31(Vars1,Vars2,Vars11),
 updatevars32(Vars11,Vars2,Vars4).

updatevars31(Vars1,Vars2,Vars11) :-
 findall([V,Value3],(member([V,Val],Vars1),
 
get_lang_word("v",Dbw_v),
get_lang_word("sys1",Dbw_sys1),
%%writeln1(5),
%trace,
         remember_and_turn_off_debug(Debug),
 	%trace,
         %(interpretpart(match4,Variable1,Variable2,Vars1,Vars5,_)->true;(turn_back_debug(Debug),
         %fail
         %interpretpart(match4,Variable1,Variable2,Vars1,_Vars2,_))),
         
         interpretpart(match4,Val,[Dbw_v,Dbw_sys1],Vars2,Vars4,_),

  	  	  getvalue([Dbw_v,Dbw_sys1],Value3,Vars4),
 	  	  
 	  	  turn_back_debug(Debug)),Vars11).
 
 
        %interpretpart(match4,Variable1,Variable2,Vars1,Vars2,Value3)
        %)
 
 %)

updatevars32(Vars1,[],Vars1).
updatevars32(Vars1,Vars2,Vars4) :-
 get_lang_word("v",Dbw_v),
	Vars2=[[Variable,Value]|Vars5],
	delete(Vars1,[Variable,[Dbw_v,_]],Vars6),
	append(Vars6,[[Variable,Value]],Vars7),
	updatevars32(Vars7,Vars5,Vars4),
	!.
updatevars32(Vars1,Vars2,Vars4) :-
	Vars2=[[Variable,Value]|Vars5],
	append(Vars1,[[Variable,Value]],Vars6),
        updatevars32(Vars6,Vars5,Vars4).
reverse([],List,List).
reverse(List1,List2,List3) :-
	List1=[Head|Tail],
	append([Head],List2,List4),
	reverse(Tail,List4,List3).
/**
unique1([Item|Items1],Items2,Items3) :-
	delete(Items1,Item,Items4),
	append(Items2,[Item],Items5),
	unique1(Items4,Items5,Items3).
	**/
	
unique1(A,Items2,Items3) :-
%trace,
unique1a(A,Items2,Items3).
%notrace.
unique1a([],Items,Items).
unique1a([[Item,Val]|Items1],Items2,Items3) :-

	(member([Item,Val2],Items1)->(not(Val=Val2)->
	fail%delete(Items1,[Item,Val2],Items6)
	;true%Items1=Items6
	);
	true%Items1=Items6
	),
	%delete(Items1,Item,Items4),
	%append(Items2,[Item],Items5),
	delete(Items1,[Item,Val],Items4),
	append(Items2,[[Item,Val]],Items5),
	unique1a(Items4,Items5,Items3).
	
	
isvar([Dbw_v,_Value]) :- 
get_lang_word("v",Dbw_v1),Dbw_v1=Dbw_v,!.
isval(Value) :-
	number(Value).
isvalstr(N) :-
	isval(N);string(N).
isvalempty(N) :-
	isval(N);(is_empty(N)).
is_empty(N) :-
	variable_name(N).%=empty.
/**isvalstrempty(N) :-
	isval(N);(string(N);N=empty).**/
isvalstrempty(N) :-
	var(N),!.
isvalstrempty(N) :-
	isval(N),!.
isvalstrempty(N) :-
get_lang_word("v",Dbw_v),
	not(N=Dbw_v),not(N=[Dbw_v,_]),
	string(N).
isvalstrempty(Empty) :- is_empty(Empty).
isvalstrempty([]).
/**isvalstrempty(N) :-
	atom(N),fail,!.
**/
isvalstrorundef(N) :- 
	var(N),!.
isvalstrorundef(N) :- 
	blob(N,stream),!.
isvalstrorundef(N) :- 
	not(var(N)),isval(N),!.
isvalstrorundef(N) :- 
	not(var(N)),expression(N),!.
undef(N) :-
	var(N).
/**
expression(N) :-
	isval(N);(string(N);atom(N)),!.
expression([]).
expression(empty).
expression([N]) :-
	expression(N).
expression([N|Ns]):-
	expression(N),expression(Ns).
**/

expression(Empty) :- is_empty(Empty),
	!.
expression(N) :-
	isval(N),!.
expression(N) :-
	string(N),!.
expression(N) :-
	atom(N),!.
expression([]) :-
	!.
expression(N) :-
	not(atom(N)),
	length_is_list(N,L),L>=1,
	expression2(N).
expression2([]).
expression2([N|Ns]) :-
	%%(
	expression3(N),%%->true;expression2(N)),
	expression2(Ns).
expression3(N) :-
	isval(N),!.
expression3(N) :-
	string(N),!.
expression3(N) :-
	atom(N),!.
expression3(N) :-
	expression2(N),!.

expressionnotatom3(N) :-
	expressionnotatom(N),!.
expressionnotatom3(N) :-
	get_lang_word("v",Dbw_v),
	not(N=[v,_]),not(N=["v",_]),not(N=[Dbw_v,_]),expression(N),!.


expression_or_atom(N) :-
	(isvalstrempty(N)->true;atom(N)),!.
expression_or_atom(N) :-
	is_list(N),
	length(N,L),L>=1,
	expression_or_atom2(N),!.
expression_or_atom(Name) :-
	predicate_or_rule_name(Name),!.
expression_or_atom2([]).
expression_or_atom2([N|Ns]) :-
	(isvalstrempty(N)->true;atom(N)),	
	expression_or_atom2(Ns).

expressionnotatom(N) :-
	isvalstrempty(N),!.
expressionnotatom(N) :-
	not(atom(N)),
	length(N,L),L>=1,
	expressionnotatom2(N),!.
expressionnotatom(Name) :-
	predicate_or_rule_name(Name),!.
expressionnotatom2([]).
expressionnotatom2([N|Ns]) :-
	isvalstrempty(N),	
	expressionnotatom2(Ns).

substitutevarsA1(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2) :-
%writeln1(substitutevarsA1(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2)),
%(Arguments=[[v,d],[[v,a],"|",[v,b]],[v,c]]->trace;true),
	        %simplify(Arguments1,Arguments),
%trace,writeln(substitutevarsA1(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2)),
	(equals4(on)->e4_substitutevarsA1(Arguments,Vars1,Vars2,Vars33,FirstArgs1,FirstArgs2);
	substitutevarsA11(Arguments,Vars1,Vars2,Vars33,FirstArgs1,FirstArgs2)),
	
	findall(Vars31,(member(Vars32,Vars33),simplify(Vars32,Vars31)),Vars3),
	%substitutevarsA2(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2),
	!.
	substitutevarsA11(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2) :-
	substitutevarsA2(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2),!.

substitutevarsA2([],_Vars1,Vars2,Vars2,FirstArgs,FirstArgs):-!.
substitutevarsA2(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2) :-
	Arguments=[Variable|Variables],
	((getvalue(Variable,Value,Vars1),
	is_empty(Value))->
	((append(Vars2,[Variable],Vars4)),
	(isvar(Variable)->append(FirstArgs1,[Variable],
	FirstArgs3);FirstArgs3=FirstArgs1));
	(getvalue(Variable,Value,Vars1),
	append(Vars2,[Value],Vars4)),
	FirstArgs3=FirstArgs1),
        substitutevarsA2(Variables,Vars1,Vars4,Vars3,FirstArgs3,FirstArgs2),!.

findresult3([],_Result,Result2,Result2):-!.
findresult3(Arguments1,Result1,Result2,Result3) :-
	Arguments1=[Value|Arguments2],
	expression_not_var(Value),
	append(Result2,[Value],Result4),
        findresult3(Arguments2,Result1,Result4,Result3),!.
findresult3(Arguments1,Result1,Result2,Result3) :-
        Arguments1=[Variable|Arguments2],

(equals4(on)->(get_lang_word("v",Dbw_v),

	remember_and_turn_off_debug(Debug),

find_sys(Sys_name),
        interpretpart(match4,Variable,[Dbw_v,Sys_name],Result1,Vars3,_),
	 turn_back_debug(Debug),

	getvalue([Dbw_v,Sys_name],Value,Vars3)
	
)

;(        isvar(Variable),
	member([Variable,Value],Result1))),

        append(Result2,[Value],Result4),
        findresult3(Arguments2,Result1,Result4,Result3),!.

strip([],Result2,Result2).
strip(Arguments1,Result2,Result3) :-
	Arguments1=[[Variable,Value]|Arguments2],
        isvar(Variable),
        append(Result2,[Value],Result4),
        strip(Arguments2,Result4,Result3).


 remember_and_turn_off_debug(Debug) :-
 	debug(Debug),retractall(debug(_)),assertz(debug(off)).
 
 turn_back_debug(Debug) :-
 	retractall(debug(_)),assertz(debug(Debug)).

find_sys(Name2) :-
	sys(N1),
	concat_list(["sys",N1],Name1),
	get_lang_word(Name1,Name2),
	%atom_string(Name2,Name1),
	N2 is N1+1,
	retractall(sys(_)),
 	assertz(sys(N2)).
 	
find_query_box_n(Name2) :-
	(query_box_n(N1)->N=N1;
	(retractall(query_box_n(_)),
	assertz(query_box_n(1)),
	N=1)),
	concat_list(["query_box_",N],Name1),
	get_lang_word(Name1,Name2),
	%atom_string(Name2,Name1),
	N2 is N+1,
	retractall(sys(_)),
 	assertz(query_box_n(N2)).

find_v_sys(V_sys) :-
 get_lang_word("v",Dbw_v),
 find_sys(Sys_name),
 V_sys=[Dbw_v,Sys_name],!.