/**
WORKING

make_mind_reading_tree4(["abc","abd"],
[[1, "b", 3], [3, "c", [-, "abc"]], [3, "d", [-, "abd"]]]).

make_mind_reading_tree4(["aaa","aab","acc"],
[[1,"a",2],[2,"a",3],[2,"c",[-,"acc"]],[3,"a",[-,"aaa"]],[3,"b",[-,"aab"]]]).

make_mind_reading_tree4(["cca","ccb"],
[[1, "c", 3], [3, "a", [-, "cca"]], [3, "b", [-, "ccb"]]]).



make_mind_reading_tree4(["acc","bcc"],
[[1, "a", [-, "acc"]], [1, "b", [-, "bcc"]]]).

make_mind_reading_tree4(["ac","bc"],
[[1, "a", [-, "ac"]], [1, "b", [-, "bc"]]]).

make_mind_reading_tree4(["aqa","awx","awy"],
[[1,"a",2],[2,"q",[-,"aqa"]],[2,"w",9],[9,"x",[-,"awx"]],[9,"y",[-,"awy"]]]
).

make_mind_reading_tree4(["ca","cb"],
[[1, "c", 2], [2, "a", [-, "ca"]], [2, "b", [-, "cb"]]]). 

make_mind_reading_tree4(["abc","ade"],
[[1, "a", 2], [2, "b", [-, "abc"]], [2, "d", [-, "ade"]]]).


make_mind_reading_tree4(["cccbbb"],
[[1, "b", [-, "cccbbb"]]]).

make_mind_reading_tree4(["cccbbb","fsfs"],
[[1, "c", [-, "cccbbb"]], [1, "f", [-, "fsfs"]]]).

make_mind_reading_tree4(["abcde"],
[[1, "e", [-, "abcde"]]]).

make_mind_reading_tree4(["abcde","afgde"],
[[1, "a", 2], [2, "b", [-, "abcde"]], [2, "f", [-, "afgde"]]]).


make_mind_reading_tree4(["aaaabbbbcccc","aaaaddddeeee"],
[[1,"a",5],[5,"b",[-,"aaaabbbbcccc"]],[5,"d",[-,"aaaaddddeeee"]]]).

make_mind_reading_tree4(["aaaccc","bbbccc"],
[[1, "a", [-, "aaaccc"]], [1, "b", [-, "bbbccc"]]]).

**/

:-include('../listprologinterpreter/la_strings.pl').
%:- include('../listprologinterpreter/la_strings.pl').

make_mind_reading_tree4(Options0,Options3) :-
	sort(Options0,Options1),
	abort_if_empty_string(Options1),
	string_to_list1(Options1,1,_,[],Options2),
	maplist(append,[Options2],[Options2a]),
%writeln1(merge_lists1a(Options2,Options2a,Options3a)),
	make_mind_reading_tree4_a(Options2a,Options3).

/**
make_mind_reading_tree4_a1(Options2a,Options3) :-
	make_mind_reading_tree4_a(Options2a,Options3a),
	make_mind_reading_tree4_a(Options3a,Options3b),
	(Options3a=Options3b->Options3=Options3a;
	make_mind_reading_tree4_a1(Options3b,Options3)).
**/

make_mind_reading_tree4_a(Options2a,Options3) :-
	%trace,
	merge_lists_a([1],Options2a,[],%%Options2a,
	Options3a),
%writeln1(merge_lists_a([1],Options2a,[],%%Options2a,
%	Options3a)),
	sort(Options3a,Options3c),
	%trace,
	remove_chains_of_one_child_a([1],Options3c,[],Options3b),
	%writeln1(remove_chains_of_one_child_a([1],Options3c,[],Options3b)),
	sort(Options3b,Options3),!.
	

string_to_list1([],N,N,Options,Options) :- !.
string_to_list1(Options1,N1,N2,Options2a,Options2b) :-
	Options1=[B|Rest],
	%%findall(C,(member(B,Options1),
	string_to_list2(B,B,N1,N3,Options2a,Options2c),%%),Options2).
	%%trace,
	[Options2c]=Options2d,
%%trace,
	string_to_list1(Rest,N3,N2,[],Options2e),
	%%trace,
	Options2d=[[[_,D1,D2]|D3]],
	Options2f=[[[1,D1,D2]|D3]],
	append(Options2f,Options2e,Options2b).

string_to_list2(B,B1,N1,N2,A1,A2) :- 
	string_concat(D,"",B),
	string_length(D,1),
	append(A1,[[N1,D,[-,B1]]],A2),
	N2 is N1 + 1,!.
string_to_list2(A,B1,N1,N2,B,C) :-
	string_concat(D,E,A),
	string_length(D,1),
	N3 is N1 + 1,
	append(B,[[N1,D,N3]],F),
	%%maplist(append,[[B,D]],[F]),
	string_to_list2(E,B1,N3,N2,F,C).


merge_lists_a([],Options1,Options2,Options3) :- 
	append(Options1,Options2,Options3),!. %*?
%merge_lists_a([[-,A]],Options0,Options1,Options2) :- 
%	member([N,A1,[-,A]],Options0),
%	append(Options1,[[N,A1,[-,A]]],Options2),!.
%%writeln1(merge_lists_a([-,_],_,Options,Options)),!.
merge_lists_a(N1,Options1,Options2,
Options3) :-
	%trace,
	N1=[M1|Ms],
	abort_if_gone_past_error(M1,Options1),
%writeln1([n1,N1]),
	% If all As lead to the same letter then merge them
	findall(A,(member([M1,A,_N2],Options1)),A1),
	sort(A1,A11),
	% next n1
	merge_lists_a1(M1,A11,Options1,[],Options31,[],N21),
	append(Options2,Options31,Options32),
	append(Ms,N21,M21),
	sort(M21,M2),
	%M21=M2,
	merge_lists_a(M2,Options32,[],Options3).
	%sort(Options32,Options3).


merge_lists_a1(_,[],Options1,Options2,Options3,N,N) :- 
	append(Options1,Options2,Options3),!. %*?
merge_lists_a1(N1,A1,Options1,Options2,Options3,NA61,NA7) :-
	%(N1=2->trace;true),
	%writeln1(merge_lists_a1(N1,A1,Options1,Options2,Options3,NA61,NA7)),
	%notrace,
	A1=[A2|A3],
	findall([N2,A5,N3],(member([N1,A2,N2],Options1),
	member([N2,A5,N3],Options1)),A4),
	%findall([-,_],(member([N1,A2,[-,_]],Options1)),A41),
	findall([N1,A2,N2],(member([N1,A2,N2],Options1)),A6),
	(%trace,
	(merge_lists_a2(A4)
	%->true;(length(A41,L),length(Options1,L)
	)->
	(
	
	%% merge N1 A2 N*, change N* in other states
	%trace,
	merge_lists_a3(A6,Options1,Options4),
	findall(N2,(member([N1,A2,N2],Options4)),NA6));
	%(trace,
	(%trace,
	%subtract(A6,
	merge_lists_a3(A6,Options1,Options4),
	%NA6=[]
	findall(N2,(member([N1,A2,N2],Options4)),NA6) %**
	)),
	append(Options2,Options4,Options5),
	append(NA61,NA6,NA62),
	%Options2=Options4),
	%trace,
	%delete(Options1,[N1,A2,N2],Options1a),
	merge_lists_a1(N1,A3,Options5,[],Options3,NA62,NA7).
	%%sort(Options31,Options3).
 %*?o4
%end state

merge_lists_a2(A4)	:-
	A4=[[_N1,A,_N2]|A5],
	merge_lists_a22(A,A5).
merge_lists_a22(_A,[]) :- !.
merge_lists_a22(A,A5) :-
	A5=[[_N1,A,_N2]|A6],
	merge_lists_a22(A,A6).

merge_lists_a3(A6,Options1,%Options2,
Options3) :-
	A6=[[N1,A,N2]|A8],
	delete(Options1,[N1,A,_],Options1a),
	%%(member([N1,A,N2],Options2)->(trace,Options2=Options2a,A9=A6);
	(append(Options1a,[[N1,A,N2]],Options1aa)%%,A9=A8
	),%),
	merge_lists_a4(N2,A8,Options1aa,[],%Options2a,
	Options3).


merge_lists_a4(_N2,[],Options1,Options2,Options3
) :- 
	append(Options1,Options2,Options3),!.
merge_lists_a4(N2,A8,Options1,Options2,Options3) :-
%trace,
%writeln1(merge_lists_a4(N2,A8,Options1,Options2,Options3)),
	A8=[[N1,A,N3]|A9],
	delete(Options1,[N1,A,N3],Options2aa),
	%%append(Options2,[[N1,A,N2]],Options2a),
	%trace,
	merge_lists_a5(N2,N3,Options2aa,[],Options4,[],Options5),
	% remove Options4=[n from o5
	findall(N4,(member([N4,_,_],Options4)),N41),
	subtract1(Options5,N41,[],Options45),
	append(Options2,Options45,Options245),
	%union(Options4,Options5,Options45),
	%writeln1(Options45),
%writeln1(	merge_lists_a5(N2,N3,Options1,Options2,Options4,[],Options5)),
	merge_lists_a4(N2,A9,Options245,[],%***Options4,
	Options31),
	%(N2=2->trace;true),
	append(Options31,Options4,Options3).
	%(Options4=[[2, "a", 3], [2, "a", 6]]->true;notrace).
	%append(Options45,Options31,Options3).

% point second in pair to changed first state
merge_lists_a5(_N2,_N3,[],Options1,Options1,Options2,Options2) :- !.
merge_lists_a5(N2,N3,Options1,Options2,Options4,Options5,Options6) :-
%(N2=3->trace;true),
	Options1=[[N3,A,N4]|A9],
	delete(Options2,[N3,A,N4],Options2aa),
	%trace,
	append(Options2aa,[[N2,A,N4]],Options2a),
	merge_lists_a5(N2,N3,A9,Options2a,Options4,Options5,Options6).
merge_lists_a5(N2,N3,Options1,Options2,Options4,Options5,Options6) :-
	Options1=[[N2,A,N4]|A9],
	delete(Options2,[N3,A,N4],Options2aa),
	%trace,
	append(Options2aa,[[N2,A,N4]],Options2a),
	merge_lists_a5(N2,N3,A9,Options2a,Options4,Options5,Options6).
merge_lists_a5(N2,N3,Options1,Options2,Options4,Options5,Options6) :-
	Options1=[[N31,A,N4]|A9],
	not(N2=N31),
	append(Options5,[[N31,A,N4]],Options5a),
	merge_lists_a5(N2,N3,A9,Options2,Options4,Options5a,Options6).

subtract1([],_N41,Options45,Options45) :- !.
subtract1(Options5,N41,Options451,Options45) :-
	Options5=[[N42,_,_]|Options51],
	member(N42,N41),
	subtract1(Options51,N41,Options451,Options45).
subtract1(Options5,N41,Options451,Options45) :-
	Options5=[[N42,A,B]|Options51],
	not(member(N42,N41)),
	append(Options451,[[N42,A,B]],Options452),
	subtract1(Options51,N41,Options452,Options45).

subtract2([],_N41,Options45,Options45) :- !.
subtract2(Options5,N41,Options451,Options45) :-
	Options5=[[_,N42,_]|Options51],
	member(N42,N41),
	subtract2(Options51,N41,Options451,Options45).
subtract2(Options5,N41,Options451,Options45) :-
	Options5=[[N42,A,B]|Options51],
	not(member(A,N41)),
	append(Options451,[[N42,A,B]],Options452),
	subtract2(Options51,N41,Options452,Options45).

abort_if_gone_past_error(M1,Options1) :-
	%trace,
	((member([M1,A,N22],Options1),member([M1,A,N23],Options1),not(N22=N23),not(N22=[-,_]),N23=[-,_])->(term_to_atom([M1,A,N22],N221),term_to_atom([M1,A,N23],N231),concat_list(["Error: Conflicting branches ",N221," and ",N231,"."],W),writeln1(W),abort);true),!.

abort_if_empty_string(Options1) :-
	(member("",Options1)->(writeln1("Error: Cannot mind read \"\"."),abort);true),!.

/**


merge_lists1a([],Options,Options) :- !.
merge_lists1a(Options1,Options2a,Options2b) :-
	Options1=[Options4|Options5],
	merge_lists1c(Options4,Options5,Options2a,Options2c),
	merge_lists1a(Options5,Options2c,Options2b).

merge_lists1c(_,[],Options,Options) :- !.
merge_lists1c(Options4,Options5,Options2a,Options2b) :-
	Options5=[Options5a|Options5b],
	merge_lists1b(Options4,Options5a,Options2a,Options2c),
	merge_lists1c(Options4,Options5b,Options2c,Options2b).

merge_lists1b([],[],Options,Options) :- !.
merge_lists1b(Options1,Options2,Options3a,Options3b) :-
	Options1=[Options4|Options5],
	Options2=[Options6|Options7],
%%	trace,
	merge_lists2(Options4,Options6,Options3a,Options3c),
%%writeln1(	merge_lists2(Options4,Options6,Options3a,Options3c)),
	merge_lists1b(Options5,Options7,Options3c,Options3b).

**/

/**
merge_lists1([],Options,Options) :- !.
merge_lists1(Options1,Options3a,Options3b) :-
	Options1=[Options4|Options5],
	%%Options2=[Options6|Options7],
%%	trace,
	merge_lists1b(Options4,Options1,[],Options3c),
	append(Options3a,Options3c,Options3d),
%%writeln1(	merge_lists2(Options4,Options6,Options3a,Options3c)),
	merge_lists1(Options5,Options3d,Options3b).

merge_lists1b([],Options,Options) :- !.
merge_lists1b(Options1,Options3a,Options3b) :-
	Options1=[Options4|Options5],
	%%Options2=[Options6|Options7],
%%	trace,
	merge_lists2(Options4,Options1,[],Options3c),
	append(Options3a,Options3c,Options3d),
%%writeln1(	merge_lists2(Options4,Options6,Options3a,Options3c)),
	merge_lists1b(Options5,Options3d,Options3b).

**/

/**

[debug]  ?- merge_lists2([1, "a", 2],[4, "a", 5],[[[1, "a", 2], [2, "b", 3], [3, "c",-]], [[4, "a", 5], [5, "d", 6], [6, "e",-]]],O).
O = [[[1, "a", 2], [2, "b", 3], [3, "c", -]], [[1, "a", 5], [5, "d", 6], [6, "e", -]]].

[debug]  ?- merge_lists2([2, "b",3],[5, "b", 6],[[[1, "a", 2], [2, "b", 3], [3, "c",-]], [[1, "a", 5], [5, "b", 6], [6, "e",-]]],O).
O = [[[1, "a", 2], [2, "b", 3], [3, "c", -]], [[1, "a", 2], [2, "b", 6], [6, "e", -]]].

remove [1, "a", 2],flatten
does reordering cause a bug?
() replace in place, redo each time changed

merge if no more than 1 parent of each node before it
remove chains of 1-children
flatten, sort at end

* strings must be same length

- same parents, etc in next level x whole thing

debug each pred

fore and post cut in shortening (no middle cut)
- if middle cut (where abd acd->ad ad), find minimum combos of intermediate letters between forks with no conflicting (not the same items in the same order/same place)
	- letter for letter x
	- a single new level x
	- cut only if necessary (leave alone) x
	- a single new letter v
	
	continually merge and shorten until returns the same
	
**/

/**
same_parents([N1,_A1,_N2],[N4,_A2,_N3],Options61) :-
	findall([B1,B2,N1],member([B1,B2,N1],Options61),C1),
	findall([B3,B4,N4],member([B3,B4,N4],Options61),C2),
	subtract(C2,C1,[]).
	%% and vv?
**/
/**
merge_lists2([N1,A1,_N2],Options2,Options61,Options9) :-
	Options2=[N4,A2,N3],
	(A1=A2->
	(findall(Options52,(%%member(Options61,Options6),
	((member([N4,A,N3],Options61),
	no_more_than_one_parent_of_each_node_before1([N4,A,N3],Options61),
	same_parents([N1,A1,_N21],[N4,A2,N3],Options61),
	delete(Options61,[N4,A,N3],Options5),
	append([[N1,A,N3]],Options5,Options52))->true;
	Options61=Options52)
	),[Options8]),
	writeln1(Options8),
%%trace,
%% merge back until forward fork with a predicate
%%trace,
	writeln1(	merge_back_until_forward_fork(1,N4,N1,Options8,[],Options9a)),merge_back_until_forward_fork(1,N4,N1,Options8,[],Options9a),
	sort(Options9a,Options9)
	%%Options8=Options9
	);
	Options61=Options9).
**/
	/**
merge_lists2([N1,A1,_N2],Options2,Options61,Options9) :-
	Options2=[N4,A2,N3],
	(A1=A2->
	(findall(Options52,(%member(Options61,Options6),
	((member([N4,A,N3],Options61),
	delete(Options61,[N4,A,N3],Options5),
	append([[N1,A,N3]],Options5,Options52))->true;
	Options61=Options52)
	),[Options8]),
	writeln(Options8),
%%trace,
	findall(Options7,(member(Options81,Options8),
	(
	(member([N41,A10,N4],Options81),
	delete(Options81,[N41,A10,N4],Options51),
	append([[N41,A10,N1]],Options51,Options7))->true;
	Options81=Options7
	)),Options9));
	Options61=Options9).	
	**/
%%no_more_than_one_parent_of_each_node_before1([1,_A,_N3],_Options61) :- !.
/**
no_more_than_one_parent_of_each_node_before1([N4,_A,_N3],Options61) :-
	%%member([_N2,_A1,N4],Options61),
	%%trace,
	findall([N4,_,N5],(member([N4,_,N5],Options61),N4=1),B),
	not(B=[]),%%->true;fail),%%B=[]),
	%%(B=[_]->true;fail),
	!.
no_more_than_one_parent_of_each_node_before1([N4,_A,_N3],Options61) :-
	%%member([N2,A1,N4],Options61),
	findall([N5,_,N4],(member([N5,_,N4],Options61)),[_]),%%,not(N2=N5)
	findall([N2,A1,N4],(member([N2,A1,N4],Options61),no_more_than_one_parent_of_each_node_before1([N2,A1,N4],Options61)),[_])
	,!.
	
	
get_c(Name2) :-
	c(N1),
	concat_list(["c",N1],Name1),
	atom_string(Name2,Name1),
	N2 is N1+1,
	retractall(c(_)),
 	assertz(c(N2)).

group_by_same_destination1(B,Options8,Options11,Options12) :-
	%%B=[[A1,A2,A3]|B2],
findall([A1,A2,A3,A4,A5],(member([A1,A2,A3],B),member([A3,A4,A5],Options8)),C1),
	sort(C1,C2),
	findall([[A1,A2,C],[C,A4,A5]],(member([A1,A2,A3,A4,A5],C2),
	get_c(C)),Options11a),
	maplist(append,[Options11a],[Options11]),
	
	findall([[A1,A2,A3],[A3,A4,A5]],(member([A1,A2,A3,A4,A5],C2)),Options12a),
	maplist(append,[Options12a],[Options12]).
	%%group_by_same_destination2(B1,Options8,[],Options12),
	
%%group_by_same_destination2(B1,Options8,Options12a,Options12) :-
	

%%merge_back_until_forward_fork(1,1,_,Options1,Options2,Options3) :- 
%%	append(Options1,Options2,Options3),
%%	!.
merge_back_until_forward_fork(_N0,N4,_N1,Options8,Options9,Options10) :-
	(findall([N41,A,N6],(member([N41,_A10,N4],Options8),
	(member([N41,A,N6],Options8),not(N6=N4))),B),
	length(B,L),L>1),
	group_by_same_destination1(B,Options8,Options11,Options12),
	%%append(Options8,Options9,Options10).
	subtract(Options8,Options12,Options13),
	maplist(append,[Options13,Options11,Options9],[Options10]).

merge_back_until_forward_fork(N0,N4,_N1,Options8,Options9,Options10) :-
	(findall([N41,_,N6],(member([N41,A10,N4],Options8),
	member([N41,_,N6],Options8),not(N6=N4)),[_])->
	(member([N41,A10,N4],Options8),
	%%trace,
	delete(Options8,[N41,A10,N4],Options51),
	append(Options51,[[N41,A10,N4]],Options7),
	merge_back_until_forward_fork(N0,N41,N4,Options7,Options9,Options10));
	%%Options9=Options10).
	append(Options8,Options9,Options10)).
	**/
%% put [-,*] in
/**
merge_back_until_forward_fork1(_,[],Options7,Options7,N41,N41) :- !.
merge_back_until_forward_fork1(N1,Options8,Options72,Options7,_N43,N42) :-
	Options8=[[N41,A10,N4]|Rest],
	delete(Options8,[N41,A10,N4],Options51),
	append(Options51,[[N41,A10,N1]],Options73),
	append(Options72,Options73,Options74),
	merge_back_until_forward_fork2(Rest,Options74,Options7,N41,N42).

merge_back_until_forward_fork2([],Options7,Options7,N41,N41) :- !.
merge_back_until_forward_fork2(_,_Options71,_Options72,_N41,_N42) :- fail.

ad
ac
bc

**/

remove_chains_of_one_child_a([],Options1,Options2,Options3) :- 
	append(Options1,Options2,Options3),!. %*?
remove_chains_of_one_child_a(N1,Options0,Options1,Options2) :- 
	N1=[[-,A1]|Ms],
	member([N,A1,[-,A]],Options0),
	append(Options1,[[N,A1,[-,A]]],Options21),
	remove_chains_of_one_child_a(Ms,Options21,[],Options2),!.

remove_chains_of_one_child_a(N1,Options1,Options2,
Options3) :-
	N1=[M1|Ms],
	findall(A,(member([M1,A,_N2],Options1)),A1),
	sort(A1,A11),
	length(A11,A11L),
	(A11L>1->Switch=left;Switch=right),
	remove_chains_of_one_child_a1(Switch,M1,A11,Options1,[],Options31,[],N21),
	append(Options2,Options31,Options32),
	append(Ms,N21,M21),
	sort(M21,M2),
	remove_chains_of_one_child_a(M2,Options32,[],Options3).

remove_chains_of_one_child_a1(_,_,[],Options1,Options2,Options3,N,N) :- 
	append(Options1,Options2,Options3),!. %*?
remove_chains_of_one_child_a1(Switch,N1,A1,Options1,Options2,Options3,_,NA7) :-
	A1=[A2|A3],
	findall([N1,A2,N2],(member([N1,A2,N2],Options1)),A6),

	remove_chains_of_one_child_a3(Switch,A6,Options1,[],Options4),
	findall(N2,(member([N1,A2,N2],Options4)),NA6),
	append(Options2,Options4,Options5),
	remove_chains_of_one_child_a1(Switch,N1,A3,Options5,[],Options3,NA6,NA7).
	
	


remove_chains_of_one_child_a3(_,[],Options1,Options2,Options3
) :- 
	append(Options1,Options2,Options3),!.
remove_chains_of_one_child_a3(Switch,A8,Options1,Options2,Options3) :-
%trace,
	A8=[[N0,A,N1]|A9],
	member([N0,A,N1],Options1), %% ** delete
	delete(Options1,[N0,A,N1],Options6),
	%trace,
%%writeln1(	remove_chains_of_one_children2(N1,N3,Options1,[],_Options4)),
	remove_chains_of_one_child_a4(N0,A,N3,Options1,[],Options41),
	Options41=[_|Options42],
	%writeln([options41,Options41]),
	
	subtract(Options6,Options42,Options6a),
	% * if N0=n3 there are a and b etc.
	% could add a state on to the start x
	%%append(Options4,[[N0,A,N3]],Options4a),
	%trace,
	member([_N01,A2,N3],Options1),
	%trace,
	(Switch=left->[[N0,A,N3]]=Options4a;[[N0,A2,N3]]=Options4a),

	%[[N0,A2,N3]]=Options4a,
	%delete(Options6,[_N0a1,A2,N3],Options6a),
	append(Options2,Options4a,Options5),
	%remove_chains_of_one_children1(N1,Options6a,Options5,Options3).
	
		remove_chains_of_one_child_a3(Switch,A9,Options6a,Options5,Options31),
		(N3=[-,_]->Options31=Options3;
		remove_chains_of_one_child_a([N3],Options31,[],Options3))
		%,notrace
		.
	
remove_chains_of_one_child_a4(N1,A,N3,Options1,Options2,Options3) :-
%trace,
	(N1=[-,_]->(N3=N1,Options2=Options3);
	(member([N1,A,N2],Options1),member([N2,_,N22],Options1),member([N2,_,N23],Options1),not(N22=N23),N3=N2,append(Options2,[[N1,A,N2]],Options3))),!.
remove_chains_of_one_child_a4(N1,A1,N3,Options1,Options2,Options3) :-
	member([N1,A2,N2],Options1),
	append(Options2,[[N1,A2,N2]],Options31),
	remove_chains_of_one_child_a5(N2,A1,N3,Options1,Options31,Options3).

remove_chains_of_one_child_a5(N1,_A1,N3,Options1,Options2,Options3) :-
%trace,
	(N1=[-,_]->(N3=N1,Options2=Options3);
	(member([N1,A,N2],Options1),member([N2,_,N22],Options1),member([N2,_,N23],Options1),not(N22=N23),N3=N2,append(Options2,[[N1,A,N2]],Options3))),!.
remove_chains_of_one_child_a5(N1,A1,N3,Options1,Options2,Options3) :-
	member([N1,A2,N2],Options1),
	append(Options2,[[N1,A2,N2]],Options31),
	remove_chains_of_one_child_a5(N2,A1,N3,Options1,Options31,Options3).
	
	/**
remove_chains_of_one_children1([-,_],Options1,Options2,Options3) :-
%%trace,
	append(Options1,Options2,Options3),!.
remove_chains_of_one_children1(N0,Options1,Options2,Options3) :-
	not(member([N0,_A,_N1],Options1)),
	append(Options1,Options2,Options3),!.
**/

/**
remove_chains_of_one_children0(N3) :-
Options1=[[1,"a",2],[2,"b",[-,"ab"]],[1,"c",4],[4,"d",[-,"cd"]]],
trace,
	remove_chains_of_one_children2(1,N3,Options1,[],_Options41).
	**/
	
/**
remove_chains_of_one_children1(N0,Options1,Options2,Options3) :-

%trace,
	%%remove_chains_of_one_children2(N0,NM1,Options1,[],_Options413),
	%%((NM1=[-,_]->true;(member([-,String],Options1),string_length(String,NM1)))->fail;true),


	%trace,
	findall([N0,A,N1],(member([N0,A,N1],Options1),
	remove_chains_of_one_children2(N1,N3,Options1,[],_Options41)),NN2),

	subtract(Options1,NN2,Options6),

	findall([N0,A,N1,A4,N3],(member([N0,A,N1],Options1),
	remove_chains_of_one_children2(N1,N3,Options1,[],_Options412),
	member([_N5,A4,N3],Options1)),NN3),

	%trace,
	findall(A4,(member([N0,A,N1,A4,N3],NN3)),NN5),
	sort(NN5,NN51),
	findall([N0,A412,N3],(member(A41,NN51),member([N0,A412,N1,A41,N3],NN3)),NN6),
writeln1(NN6),

%trace,
	length(NN6,NN6L),
	((NN6L>1,NN6=[[NN6M1,NN6M2,_]|NN6R])->((member([NN6M1,NN6M2,_],NN6R),delete(NN6R,[NN6M1,NN6M2,_],NN62))->
	NN61=NN62;NN61=NN6
	);NN61=NN6),


%trace,
	findall(A,(member([N0,A,N1,A4,N3],NN3)),NN7),
	sort(NN7,NN71),
	findall([N0,A12,N3],(member(A1,NN71),member([N0,A1,N1,A12,N3],NN3)),NN8),
writeln1(NN8),

%trace,

	length(NN8,NN8L),
	((NN8L>1,NN8=[[NN8M1,NN8M2,_]|NN8R])->((member([NN8M1,NN8M2,_],NN8R),delete(NN8R,[NN8M1,NN8M2,_],NN82))->
	NN81=NN82;NN81=NN8
	);NN81=NN8),
%trace,
append(NN61,NN81,Options4a),
%findall(_,(member(Options4c,Options4b),
%%writeln1(remove_chains_of_one_children2(N1,N3,Options1,[],_Options4)),
	%%append(Options4,[[N0,A,N3]],Options4a),
	
	append(Options2,Options4a,NNA),

%trace,	
	
	findall(NND,(member([_NNB,_NNC,NND],NNA)),NNE),sort(NNE,NNE1),
	findall(NNI,(member(NNE2,NNE1),findall([NNF,NNG,NNE2],(member([NNF,NNG,NNE2],NNA),!),[NNI])),NNH),
	NNH=Options5,
	
	remove_chains_of_one_children1(N0,Options6,Options5,Options3).
	
**/
/**
remove_chains_of_one_children1(N0,Options1,Options2,Options3) :-
%trace,
	member([N0,A,N1],Options1),
	delete(Options1,[N0,A,N1],Options6),
	%trace,
%%writeln1(	remove_chains_of_one_children2(N1,N3,Options1,[],_Options4)),
	remove_chains_of_one_children2(N0,N3,Options1,[],_Options41),
	% * if N0=n3 there are a and b etc.
	% could add a state on to the start x
	%%append(Options4,[[N0,A,N3]],Options4a),
	%trace,
	member([_N01,A2,N3],Options1),
	%trace,
	[[N0,A2,N3]]=Options4a,
	delete(Options6,[_N0a1,A2,N3],Options6a),
	append(Options2,Options4a,Options5),
	remove_chains_of_one_children1(N1,Options6a,Options5,Options3).
**/
%remove_chains_of_one_children2([-,A],[-,A],Options1,Options2,Options3) :-
%	append(Options1,Options2,Options3),!.

%remove_chains_of_one_children2(N1,N1,Options1,_Options2,_Options3) :-
	%(member([N1,_,N22],Options1),member([N1,_,N23],Options1),not(N22=N23)),!.
	/**
remove_chains_of_one_children2(N1,N3,Options1,_Options2,_Options3) :-
	(N1=[-,_]->N3=N1;
	(member([N1,_A,N2],Options1),member([N2,_,N22],Options1),member([N2,_,N23],Options1),not(N22=N23),N3=N2)),!.
remove_chains_of_one_children2(N1,N3,Options1,_Options2,_Options3) :-
	member([N1,_,N2],Options1),
	remove_chains_of_one_children2(N2,N3,Options1,_Options21,_Options31).
	**/
/**
remove_chains_of_one_children2(N1,N3,Options1,Options2,Options3) :-
	findall([N1,A,N2],member([N1,A,N2],Options1),Options4),
	(not(Options4=[_])->
	
	%%remove_chains_of_one_children3(Options2,Options4,Options3)
	
	(%%append(Options2,Options4,Options5),
	Options2=Options5,

%%	(member([N2,_,N22],Options1),member([N2,_,N23],Options1),not(N22=N23)),

remove_chains_of_one_children11(Options4,Options5,Options3))),
Options4=[[N3,_,_]|_].
	%remove_chains_of_one_children1(N2,Options4,Options5,Options3),
	%writeln1([options4,Options4]),
	%Options4=[[N3,_,_]|_]
	%)
	%;fail).%%,!.
	**/
	/**
remove_chains_of_one_children2(N1,N3,Options1,Options2,Options3) :-
	findall([N1,A,N2],member([N1,A,N2],Options1),[_]),
	member([N1,A,N2],Options1),
	delete(Options1,[N1,A,N2],Options4),
writeln1(remove_chains_of_one_children2(N1,N3,Options1,Options2,Options3)),
	%(member([N2,_,N22],Options1),member([N2,_,N23],Options1),not(N22=N23)),	
	remove_chains_of_one_children2(N2,N3,Options4,Options2,Options3).
	
remove_chains_of_one_children11([],Options,Options) :- !.
remove_chains_of_one_children11(Options4,Options5,Options3) :-
	Options4=[[_,_,N2]|N2s],
	remove_chains_of_one_children1(N2,Options4,Options5,Options41),
	remove_chains_of_one_children11(N2s,Options41,Options3).
**/
/**
remove_chains_of_one_children3(Options2,Options4,Options3) :-
	member(B,
	(append(Options2,[[N1,A,N2]],Options5),
	remove_chains_of_one_children1(N2,Options4,Options5,Options3
**/

equals_empty_list([]).

get_item_n(Exposition,Number1,Item) :-
	Number2 is Number1-1,
	length(List,Number2),
	append(List,[Item|_],Exposition).